Upload 6 files

lstm-chatbot-training/chatbot.py

@@ -0,0 +1,78 @@
+import torch
+import torch.nn as nn
+from nltk.tokenize import word_tokenize
+import json
+import numpy as np
+
+# توکن‌سازی
+def tokenize(text):
+    return word_tokenize(text.lower())
+
+# بارگذاری vocab
+with open('vocab.json', 'r') as f:
+    vocab = json.load(f)
+vocab_size = len(vocab)
+
+# مدل LSTM با Dropout و لایه‌های متعدد
+class LSTMModel(nn.Module):
+    def __init__(self, vocab_size, embed_size, hidden_size, num_layers=1):
+        super(LSTMModel, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_size)
+        self.lstm = nn.LSTM(embed_size, hidden_size, num_layers=num_layers, dropout=0, batch_first = True)
+        self.fc = nn.Linear(hidden_size, vocab_size)
+
+    def forward(self, x):
+        x = self.embedding(x)
+        lstm_out, _ = self.lstm(x)
+        out = self.fc(lstm_out)
+        return out
+
+# بارگذاری مدل
+embed_size = 64
+hidden_size = 512
+model = LSTMModel(vocab_size, embed_size, hidden_size)
+model.load_state_dict(torch.load('lstm_model.pth', weights_only= True))
+model.eval()
+
+# Beam Search با Top-k Sampling
+def beam_search_with_top_k_sampling(model, start_text, vocab, tokenizer, beam_width=1, top_k=2, max_length= 64):
+    model.eval()
+    indices = [vocab.get(token, vocab['<unk>']) for token in tokenize(start_text)]
+    input_seq = torch.tensor(indices).unsqueeze(0)
+    beams = [(input_seq, start_text, 0)]  # (sequence, text, score)
+
+    for _ in range(max_length):
+        new_beams = []
+        for beam in beams:
+            seq, text, score = beam
+            with torch.no_grad():
+                outputs = model(seq)
+                next_word_probs = outputs[:, -1, :]
+                topk_probs, topk_indices = torch.topk(next_word_probs, top_k, dim=1)
+
+                # Sample from top-k probabilities
+                probabilities = torch.softmax(topk_probs, dim=1).squeeze().cpu().numpy()
+                for i in range(top_k):
+                    next_index = np.random.choice(topk_indices[0].cpu().numpy(), p=probabilities)
+                    next_word = [word for word, index in vocab.items() if index == next_index][0]
+                    new_seq = torch.cat([seq, torch.tensor([[next_index]])], dim=1)
+                    new_score = score + np.log(probabilities[i])  # Update score with log probability
+                    new_beams.append((new_seq, text + ' ' + next_word, new_score))
+
+        # Select the top beams
+        beams = sorted(new_beams, key=lambda x: x[2], reverse = False)[:beam_width]
+
+    return beams[-1][1]  # Return the highest scoring beam
+
+# چت بات
+def chat():
+    print("Chatbot is ready. Type 'exit' to end the chat.")
+    while True:
+        user_input = input("You: ")
+        if user_input.lower() == 'exit':
+            break
+        response = beam_search_with_top_k_sampling(model, user_input, vocab, tokenize)
+        print(f"Bot: {response}")
+
+# شروع چت
+chat()

lstm-chatbot-training/chatbot2.py

@@ -0,0 +1,74 @@
+import torch
+import torch.nn as nn
+import json
+from nltk.tokenize import word_tokenize
+
+# بارگذاری vocab
+with open('vocab.json', 'r') as f:
+    vocab = json.load(f)
+
+# بارگذاری مدل
+class LSTMModel(nn.Module):
+    def __init__(self, vocab_size, embed_size, hidden_size, num_layers=2):
+        super(LSTMModel, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_size)
+        self.lstm = nn.LSTM(embed_size, hidden_size, num_layers=num_layers, dropout=0, batch_first=True, bidirectional=True)
+        self.fc = nn.Linear(hidden_size * 2, vocab_size)
+
+    def forward(self, x):
+        x = self.embedding(x)
+        lstm_out, _ = self.lstm(x)
+        out = self.fc(lstm_out)
+        return out
+
+vocab_size = len(vocab)
+embed_size = 64
+hidden_size = 512
+model = LSTMModel(vocab_size, embed_size, hidden_size)
+model.load_state_dict(torch.load('lstm_model.pth', weights_only=True))
+model.eval()
+
+# توکن‌سازی و پردازش ورودی
+def tokenize(text):
+    return word_tokenize(text.lower())
+
+def tokens_to_indices(tokens, vocab):
+    return [vocab.get(token, vocab['<unk>']) for token in tokens]
+
+def indices_to_tokens(indices, vocab):
+    inv_vocab = {v: k for k, v in vocab.items()}
+    return [inv_vocab.get(index, '<unk>') for index in indices]
+
+# تولید پاسخ
+def generate_response(model, input_text, vocab, max_length=20):
+    tokens = tokenize(input_text)
+    input_indices = tokens_to_indices(tokens, vocab)
+    input_tensor = torch.tensor(input_indices, dtype=torch.long).unsqueeze(0)  # اضافه کردن بعد برای batch
+
+    response_indices = []
+    with torch.no_grad():
+        for _ in range(max_length):
+            output = model(input_tensor)
+            next_token_id = output.argmax(dim=-1)[:, -1].item()  # پیدا کردن کلمه بعدی
+            response_indices.append(next_token_id)
+            input_tensor = torch.cat([input_tensor, torch.tensor([[next_token_id]], dtype=torch.long)], dim=1)
+
+            if next_token_id == vocab['<pad>']:
+                break
+
+    response_tokens = indices_to_tokens(response_indices, vocab)
+    return ' '.join(response_tokens).replace('<pad>', '')
+
+# حلقه چت
+def chat():
+    print("Chatbot is ready! Type 'quit' to exit.")
+    while True:
+        user_input = input("You: ")
+        if user_input.lower() == 'quit':
+            print("Goodbye!")
+            break
+        response = generate_response(model, user_input, vocab)
+        print(f"Bot: {response}")
+
+if __name__ == "__main__":
+    chat()

lstm-chatbot-training/train.py

@@ -0,0 +1,105 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from torch.nn.utils.rnn import pad_sequence
+import nltk
+from nltk.tokenize import word_tokenize
+from collections import Counter
+import json
+
+# دانلود بسته‌های nltk
+#nltk.download('punkt')
+
+# بارگذاری داده‌ها از فایل
+def load_text_data(file_path):
+    with open(file_path, 'r') as file:
+        data = file.readlines()
+    return [line.strip() for line in data]
+
+# بارگذاری داده‌ها
+file_path = 'data.txt'
+sentences = load_text_data(file_path)
+
+# توکن‌سازی
+def tokenize(text):
+    return word_tokenize(text.lower())
+
+# ساخت vocab
+def build_vocab(sentences):
+    tokens = [token for sentence in sentences for token in tokenize(sentence)]
+    vocab = {word: i for i, (word, _) in enumerate(Counter(tokens).items())}
+    vocab['<unk>'] = len(vocab)
+    vocab['<pad>'] = len(vocab)
+    return vocab
+
+vocab = build_vocab(sentences)
+vocab_size = len(vocab)
+print(f"Vocabulary size: {vocab_size}")
+
+# ذخیره vocab
+with open('vocab.json', 'w') as f:
+    json.dump(vocab, f)
+print('Vocabulary saved to vocab.json')
+
+# آماده‌سازی داده‌ها
+class TextDataset(Dataset):
+    def __init__(self, sentences, vocab, seq_length= 8):
+        self.data = []
+        self.vocab = vocab
+        self.seq_length = seq_length
+        for sentence in sentences:
+            tokens = tokenize(sentence)
+            indices = [vocab.get(token, vocab['<unk>']) for token in tokens]
+            for i in range(len(indices) - seq_length):
+                self.data.append((indices[i:i+seq_length], indices[i+1:i+seq_length+1]))
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        inputs, targets = self.data[idx]
+        return torch.tensor(inputs, dtype=torch.long), torch.tensor(targets, dtype=torch.long)
+
+dataset = TextDataset(sentences, vocab, seq_length= 8)
+dataloader = DataLoader(dataset, batch_size=1, shuffle = True, collate_fn=lambda x: (
+    pad_sequence([i[0] for i in x], batch_first = True),
+    pad_sequence([i[1] for i in x], batch_first = True)
+))
+
+# مدل LSTM با Dropout و لایه‌های متعدد
+class LSTMModel(nn.Module):
+    def __init__(self, vocab_size, embed_size, hidden_size, num_layers=1):
+        super(LSTMModel, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_size)
+        self.lstm = nn.LSTM(embed_size, hidden_size, num_layers=num_layers, dropout=0, batch_first = True)
+        self.fc = nn.Linear(hidden_size, vocab_size)
+
+    def forward(self, x):
+        x = self.embedding(x)
+        lstm_out, _ = self.lstm(x)
+        out = self.fc(lstm_out)
+        return out
+
+# پارامترها و مدل
+embed_size = 64
+hidden_size = 512
+model = LSTMModel(vocab_size, embed_size, hidden_size)
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.AdamW(model.parameters(), lr=0.01)  # استفاده از AdamW به جای Adam
+
+# آموزش مدل
+num_epochs = 8
+for epoch in range(num_epochs):
+    for inputs, targets in dataloader:
+        optimizer.zero_grad()
+        outputs = model(inputs)
+        loss = criterion(outputs.view(-1, vocab_size), targets.view(-1))  # تغییر شکل برای محاسبه loss
+        loss.backward()
+        optimizer.step()
+    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
+
+# ذخیره مدل
+model_path = 'lstm_model.pth'
+torch.save(model.state_dict(), model_path)
+print(f'Model saved to {model_path}')

lstm-chatbot-training/train2.py

@@ -0,0 +1,137 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from torch.nn.utils.rnn import pad_sequence
+import nltk
+from nltk.tokenize import word_tokenize
+from collections import Counter
+import json
+
+# دانلود بسته‌های nltk
+# nltk.download('punkt')
+
+# بارگذاری داده‌ها از فایل
+def load_text_data(file_path):
+    with open(file_path, 'r') as file:
+        data = file.readlines()
+    return [line.strip() for line in data]
+
+# بارگذاری داده‌ها
+file_path = 'data.txt'
+sentences = load_text_data(file_path)
+print(f"Loaded sentences: {sentences[:0]}")  # نمایش چند جمله اول برای بررسی
+
+# توکن‌سازی
+def tokenize(text):
+    return word_tokenize(text.lower())
+
+# ساخت vocab
+def build_vocab(sentences):
+    tokens = [token for sentence in sentences for token in tokenize(sentence)]
+    vocab = {word: i for i, (word, _) in enumerate(Counter(tokens).items())}
+    vocab['<unk>'] = len(vocab)
+    vocab['<pad>'] = len(vocab)
+    return vocab
+
+vocab = build_vocab(sentences)
+vocab_size = len(vocab)
+print(f"Vocabulary size: {vocab_size}")
+
+# ذخیره vocab
+with open('vocab.json', 'w') as f:
+    json.dump(vocab, f)
+print('Vocabulary saved to vocab.json')
+
+# آماده‌سازی داده‌ها
+class TextDataset(Dataset):
+    def __init__(self, sentences, vocab, seq_length=10):
+        self.data = []
+        self.vocab = vocab
+        self.seq_length = seq_length
+        for sentence in sentences:
+            tokens = tokenize(sentence)
+            indices = [vocab.get(token, vocab['<unk>']) for token in tokens]
+            if len(indices) >= seq_length + 1:
+                for i in range(len(indices) - seq_length):
+                    self.data.append((indices[i:i+seq_length], indices[i+1:i+seq_length+1]))
+        print(f"Dataset size: {len(self.data)}")  # نمایش تعداد نمونه‌ها
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        inputs, targets = self.data[idx]
+        return torch.tensor(inputs, dtype=torch.long), torch.tensor(targets, dtype=torch.long)
+
+dataset = TextDataset(sentences, vocab, seq_length=10)
+print(f"Number of samples in dataset: {len(dataset)}")
+
+def collate_fn(batch):
+    inputs, targets = zip(*batch)
+    inputs_pad = pad_sequence(inputs, batch_first=True, padding_value=vocab['<pad>'])
+    targets_pad = pad_sequence(targets, batch_first=True, padding_value=vocab['<pad>'])
+    return inputs_pad, targets_pad
+
+dataloader = DataLoader(dataset, batch_size=1, shuffle=True, collate_fn=collate_fn)
+
+# مدل Transformer
+class Transformer(nn.Module):
+    def __init__(self, vocab_size, embed_size, num_heads, hidden_size, num_layers):
+        super(Transformer, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_size)
+        self.transformer = nn.Transformer(
+            d_model=embed_size,
+            nhead=num_heads,
+            num_encoder_layers=num_layers,
+            num_decoder_layers=num_layers,
+            dim_feedforward=hidden_size,
+            batch_first=True  # اطمینان از تنظیم batch_first=True
+        )
+        self.fc = nn.Linear(embed_size, vocab_size)
+
+    def forward(self, src, tgt, src_mask=None, tgt_mask=None):
+        src = self.embedding(src)
+        tgt = self.embedding(tgt)
+        output = self.transformer(src, tgt, src_mask=src_mask, tgt_mask=tgt_mask)
+        output = self.fc(output)
+        return output
+
+# پارامترها و مدل
+embed_size = 10
+num_heads = 5
+hidden_size = 100
+num_layers = 2
+model = Transformer(vocab_size, embed_size, num_heads, hidden_size, num_layers)
+
+# استفاده از GPU در صورت در دسترس بودن
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+model.to(device)
+
+criterion = nn.CrossEntropyLoss(ignore_index=vocab['<pad>'])
+optimizer = optim.AdamW(model.parameters(), lr=0.01)
+
+# آموزش مدل
+num_epochs = 5
+for epoch in range(num_epochs):
+    total_loss = 0
+    for src_batch, tgt_batch in dataloader:
+        src_batch = src_batch.squeeze(0).to(device)
+        tgt_batch = tgt_batch.squeeze(0).to(device)
+
+        src_mask = tgt_mask = None  # در اینجا می‌توانید ماسک‌های مناسب اضافه کنید
+
+        optimizer.zero_grad()
+        outputs = model(src_batch, tgt_batch, src_mask, tgt_mask)
+        loss = criterion(outputs.view(-1, vocab_size), tgt_batch.view(-1))  # تغییر شکل برای محاسبه loss
+        loss.backward()
+        optimizer.step()
+        total_loss += loss.item()
+
+    avg_loss = total_loss / len(dataloader)
+    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {avg_loss:.4f}')
+
+# ذخیره مدل
+model_path = 'transformer_model.pth'
+torch.save(model.state_dict(), model_path)
+print(f'Model saved to {model_path}')

lstm-chatbot-training/train3.py

@@ -0,0 +1,105 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from torch.nn.utils.rnn import pad_sequence
+import nltk
+from nltk.tokenize import word_tokenize
+from collections import Counter
+import json
+
+# دانلود بسته‌های nltk
+#nltk.download('punkt')
+
+# بارگذاری داده‌ها از فایل
+def load_text_data(file_path):
+    with open(file_path, 'r') as file:
+        data = file.readlines()
+    return [line.strip() for line in data]
+
+# بارگذاری داده‌ها
+file_path = 'data.txt'
+sentences = load_text_data(file_path)
+
+# توکن‌سازی
+def tokenize(text):
+    return word_tokenize(text.lower())
+
+# ساخت vocab
+def build_vocab(sentences):
+    tokens = [token for sentence in sentences for token in tokenize(sentence)]
+    vocab = {word: i for i, (word, _) in enumerate(Counter(tokens).items())}
+    vocab['<unk>'] = len(vocab)
+    vocab['<pad>'] = len(vocab)
+    return vocab
+
+vocab = build_vocab(sentences)
+vocab_size = len(vocab)
+print(f"Vocabulary size: {vocab_size}")
+
+# ذخیره vocab
+with open('vocab.json', 'w') as f:
+    json.dump(vocab, f)
+print('Vocabulary saved to vocab.json')
+
+# آماده‌سازی داده‌ها
+class TextDataset(Dataset):
+    def __init__(self, sentences, vocab, seq_length=64):  # افزایش seq_length
+        self.data = []
+        self.vocab = vocab
+        self.seq_length = seq_length
+        for sentence in sentences:
+            tokens = tokenize(sentence)
+            indices = [vocab.get(token, vocab['<unk>']) for token in tokens]
+            for i in range(len(indices) - seq_length):
+                self.data.append((indices[i:i+seq_length], indices[i+1:i+seq_length+1]))
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        inputs, targets = self.data[idx]
+        return torch.tensor(inputs, dtype=torch.long), torch.tensor(targets, dtype=torch.long)
+
+dataset = TextDataset(sentences, vocab, seq_length=64)
+dataloader = DataLoader(dataset, batch_size=16, shuffle=True, collate_fn=lambda x: (  # افزایش batch_size
+    pad_sequence([i[0] for i in x], batch_first=True),
+    pad_sequence([i[1] for i in x], batch_first=True)
+))
+
+# مدل LSTM با Dropout و لایه‌های متعدد
+class LSTMModel(nn.Module):
+    def __init__(self, vocab_size, embed_size, hidden_size, num_layers=2):  # افزایش num_layers
+        super(LSTMModel, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_size)
+        self.lstm = nn.LSTM(embed_size, hidden_size, num_layers=num_layers, dropout=0, batch_first=True, bidirectional=True)  # افزودن bidirectional=True
+        self.fc = nn.Linear(hidden_size * 2, vocab_size)  # تغییر اندازه ورودی به fc برای LSTM دوطرفه
+
+    def forward(self, x):
+        x = self.embedding(x)
+        lstm_out, _ = self.lstm(x)
+        out = self.fc(lstm_out)
+        return out
+
+# پارامترها و مدل
+embed_size = 64  # افزایش embed_size
+hidden_size = 512
+model = LSTMModel(vocab_size, embed_size, hidden_size)
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.AdamW(model.parameters(), lr=0.01, weight_decay=1e-5)  # اضافه کردن weight decay
+
+# آموزش مدل
+num_epochs = 8  # افزایش num_epochs
+for epoch in range(num_epochs):
+    for inputs, targets in dataloader:
+        optimizer.zero_grad()
+        outputs = model(inputs)
+        loss = criterion(outputs.view(-1, vocab_size), targets.view(-1))  # تغییر شکل برای محاسبه loss
+        loss.backward()
+        optimizer.step()
+    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
+
+# ذخیره مدل
+model_path = 'lstm_model.pth'
+torch.save(model.state_dict(), model_path)
+print(f'Model saved to {model_path}')

lstm-chatbot-training/train4.py

@@ -0,0 +1,109 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from torch.nn.utils.rnn import pad_sequence
+import spacy
+from collections import Counter
+import json
+
+# بارگذاری مدل توکن‌سازی spaCy
+nlp = spacy.load('en_core_web_sm')
+
+# بارگذاری داده‌ها از فایل
+def load_text_data(file_path):
+    with open(file_path, 'r') as file:
+        data = file.readlines()
+    return [line.strip() for line in data]
+
+# بارگذاری داده‌ها
+file_path = 'data.txt'
+sentences = load_text_data(file_path)
+
+# توکن‌سازی
+def tokenize(text):
+    return [token.text.lower() for token in nlp(text).tokenize]
+
+# ساخت vocab
+def build_vocab(sentences):
+    tokens = [token for sentence in sentences for token in tokenize(sentence)]
+    vocab = {word: i for i, (word, _) in enumerate(Counter(tokens).items())}
+    vocab['<unk>'] = len(vocab)
+    vocab['<pad>'] = len(vocab)
+    return vocab
+
+vocab = build_vocab(sentences)
+vocab_size = len(vocab)
+print(f"Vocabulary size: {vocab_size}")
+
+# ذخیره vocab
+with open('vocab.json', 'w') as f:
+    json.dump(vocab, f)
+print('Vocabulary saved to vocab.json')
+
+# آماده‌سازی داده‌ها
+class TextDataset(Dataset):
+    def __init__(self, sentences, vocab, seq_length=8):
+        self.data = []
+        self.vocab = vocab
+        self.seq_length = seq_length
+        for sentence in sentences:
+            tokens = tokenize(sentence)
+            indices = [vocab.get(token, vocab['<unk>']) for token in tokens]
+            for i in range(len(indices) - seq_length):
+                self.data.append((indices[i:i+seq_length], indices[i+1:i+seq_length+1]))
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        inputs, targets = self.data[idx]
+        return torch.tensor(inputs, dtype=torch.long), torch.tensor(targets, dtype=torch.long)
+
+dataset = TextDataset(sentences, vocab, seq_length=8)
+dataloader = DataLoader(dataset, batch_size=64, shuffle=True, collate_fn=lambda x: (
+    pad_sequence([i[0] for i in x], batch_first=True),
+    pad_sequence([i[1] for i in x], batch_first=True)
+))
+
+# مدل LSTM با Dropout و لایه‌های متعدد
+class LSTMModel(nn.Module):
+    def __init__(self, vocab_size, embed_size, hidden_size, num_layers=2, dropout=0.5):
+        super(LSTMModel, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_size)
+        self.lstm = nn.LSTM(embed_size, hidden_size, num_layers=num_layers, dropout=dropout, batch_first=True)
+        self.fc = nn.Linear(hidden_size, vocab_size)
+
+    def forward(self, x):
+        x = self.embedding(x)
+        lstm_out, _ = self.lstm(x)
+        out = self.fc(lstm_out)
+        return out
+
+# پارامترها و مدل
+embed_size = 64  # افزایش اندازه embedding برای قابلیت یادگیری بهتر
+hidden_size = 512
+model = LSTMModel(vocab_size, embed_size, hidden_size)
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.AdamW(model.parameters(), lr=0.001)  # کاهش نرخ یادگیری برای دقت بهتر
+
+# آموزش مدل
+num_epochs = 10
+for epoch in range(num_epochs):
+    model.train()  # فعال کردن حالت آموزش
+    total_loss = 0
+    for inputs, targets in dataloader:
+        optimizer.zero_grad()
+        outputs = model(inputs)
+        loss = criterion(outputs.view(-1, vocab_size), targets.view(-1))  # تغییر شکل برای محاسبه loss
+        loss.backward()
+        nn.utils.clip_grad_norm_(model.parameters(), 1.0)  # جلوگیری از انفجار گرادیان
+        optimizer.step()
+        total_loss += loss.item()
+    avg_loss = total_loss / len(dataloader)
+    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {avg_loss:.4f}')
+
+# ذخیره مدل
+model_path = 'lstm_model.pth'
+torch.save(model.state_dict(), model_path)
+print(f'Model saved to {model_path}')