Delete continue.py

continue.py

@@ -1,117 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.optim as optim
-import pickle
-from torch.utils.data import Dataset, DataLoader
-from safetensors.torch import load_file, save_file
-import logging
-import json
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-# Hyperparameters
-sequence_length = 16
-batch_size = 32
-num_epochs = 1  # Continue training for 1 more epoch
-learning_rate = 0.00001
-embedding_dim = 256
-hidden_dim = 512
-num_layers = 2
-
-# LSTM Model
-class LSTMModel(nn.Module):
-    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers):
-        super(LSTMModel, self).__init__()
-        self.embedding = nn.Embedding(vocab_size, embedding_dim)
-        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers, batch_first=True)
-        self.fc = nn.Linear(hidden_dim, vocab_size)
-
-    def forward(self, x):
-        embeds = self.embedding(x)
-        lstm_out, _ = self.lstm(embeds)
-        logits = self.fc(lstm_out[:, -1, :])
-        return logits
-
-# Load the model and vocabulary
-logging.info('Loading the model and vocabulary...')
-model_state_dict = load_file('lstm_model.safetensors')
-with open('word2idx.pkl', 'rb') as f:
-    word2idx = pickle.load(f)
-with open('idx2word.pkl', 'rb') as f:
-    idx2word = pickle.load(f)
-
-vocab_size = len(word2idx)
-model = LSTMModel(vocab_size, embedding_dim, hidden_dim, num_layers)
-model.load_state_dict(model_state_dict)
-model.train()
-
-logging.info('Model and vocabulary loaded successfully.')
-
-# Output the total number of parameters
-total_params = sum(p.numel() for p in model.parameters())
-logging.info(f'Total number of parameters: {total_params}')
-
-# Read the text file
-logging.info('Reading the text file...')
-with open('text.txt', 'r') as file:
-    text = file.read()
-logging.info('Text file read successfully.')
-
-# Preprocess the text
-logging.info('Preprocessing the text...')
-words = json.loads(text)
-sequences = []
-for i in range(len(words) - sequence_length):
-    seq = words[i:i + sequence_length]
-    label = words[i + sequence_length]
-    sequences.append((seq, label))
-
-logging.info(f'Number of sequences: {len(sequences)}')
-
-# Dataset and DataLoader
-class TextDataset(Dataset):
-    def __init__(self, sequences, word2idx):
-        self.sequences = sequences
-        self.word2idx = word2idx
-
-    def __len__(self):
-        return len(self.sequences)
-
-    def __getitem__(self, idx):
-        seq, label = self.sequences[idx]
-        seq_idx = [self.word2idx.get(word, self.word2idx['<UNK>']) for word in seq]
-        label_idx = self.word2idx.get(label, self.word2idx['<UNK>'])
-        return torch.tensor(seq_idx, dtype=torch.long), torch.tensor(label_idx, dtype=torch.long)
-
-logging.info('Creating dataset and dataloader...')
-dataset = TextDataset(sequences, word2idx)
-dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
-
-# Continue training
-criterion = nn.CrossEntropyLoss()
-optimizer = optim.Adam(model.parameters(), lr=learning_rate)
-
-logging.info('Starting continued training...')
-for epoch in range(num_epochs):
-    for batch_idx, batch in enumerate(dataloader):
-        inputs, targets = batch
-        outputs = model(inputs)
-        loss = criterion(outputs, targets)
-
-        optimizer.zero_grad()
-        loss.backward()
-        optimizer.step()
-
-        if batch_idx % 10 == 0:
-            logging.info(f'Epoch [{epoch+1}/{num_epochs}], Batch [{batch_idx}/{len(dataloader)}], Loss: {loss.item():.4f}')
-
-# Save the updated model
-logging.info('Saving the updated model...')
-save_file(model.state_dict(), 'lstm_model.safetensors')
-with open('word2idx.pkl', 'wb') as f:
-    pickle.dump(word2idx, f)
-with open('idx2word.pkl', 'wb') as f:
-    pickle.dump(idx2word, f)
-
-logging.info('Updated model and vocabulary saved successfully.')