Upload folder using huggingface_hub

SimpleRNN.py

@@ -0,0 +1,16 @@
+import torch
+import torch.nn as nn
+
+class SimpleRNN(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size):
+        super(SimpleRNN, self).__init__()
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
+        self.fc = nn.Linear(hidden_size, output_size)
+
+    def forward(self, x, hidden):
+        x = torch.nn.functional.one_hot(x, num_classes=self.input_size).float()
+        out, hidden = self.rnn(x.unsqueeze(0), hidden)
+        out = self.fc(out[:, -1, :])  # Take last time step's output
+        return out, hidden

parameter.json

@@ -1,6 +1,6 @@
 {
     "hidden_size": 2048,
     "sequence_length": 5,
-    "learning_rate": 0.0001,
+    "learning_rate": 0.0002,
     "model_path": "tiny_llm_hidden2048.pth"
 }

run.py

@@ -1,26 +1,11 @@
 import torch
-import torch.nn as nn
+from SimpleRNN import SimpleRNN
 import json
 from tqdm import tqdm, trange
 
-# Model parameters
 parameters = json.loads(open("parameter.json").read())
 model_path = parameters["model_path"]
 
-# Define the simple RNN model
-class SimpleRNN(nn.Module):
-    def __init__(self, input_size, hidden_size, output_size):
-        super(SimpleRNN, self).__init__()
-        self.hidden_size = hidden_size
-        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
-        self.fc = nn.Linear(hidden_size, output_size)
-
-    def forward(self, x, hidden):
-        x = torch.nn.functional.one_hot(x, num_classes=input_size).float()
-        out, hidden = self.rnn(x.unsqueeze(0), hidden)
-        out = self.fc(out[:, -1, :])  # Take last time step's output
-        return out, hidden
-
 model = torch.load(model_path, weights_only=False)
 with open("vocab.json", "r") as f:
     chars = json.loads(f.read())
@@ -32,7 +17,6 @@ input_size = len(chars)
 hidden_size = parameters["hidden_size"]
 output_size = len(chars)
 
-# Text generation function
 def generate_text(start_text, length):
     model.eval()
     hidden = torch.zeros(1, 1, hidden_size)
@@ -47,7 +31,6 @@ def generate_text(start_text, length):
 
     return generated_text
 
-# Generate some text
 while True:
     prompt = input("Ask LLM: ")
     length = int(input("Length of text: "))

tiny_llm_hidden128.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dbc68ba1d2ccf1481ef6f369ecd6a5e8a402fffbd5d55233b3053964421ed0c0
+size 134326

tiny_llm_hidden2048_legacy.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2bca2e08a529c052f0a8867dc6a6096c7c5efeba3e75865238932611fec3c63
+size 17813696

tiny_llm_hidden512_legacy.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b62f88c702e3d9d06394d079547ac58b37b2b70f4135aec363cdff9100e54d9
+size 1310902

train.py

@@ -1,18 +1,17 @@
 import torch
 import torch.nn as nn
 import torch.optim as optim
+from SimpleRNN import SimpleRNN
 import os
 import json
 from tqdm import tqdm, trange
 import time
 
-# Generate simple training data
 training_text = open("train_data.txt", encoding="utf-8").read()
 chars = sorted(list(set(training_text)))  # Unique characters
 char_to_idx = {ch: i for i, ch in enumerate(chars)}
 idx_to_char = {i: ch for i, ch in enumerate(chars)}
 
-# Model parameters
 parameters = json.loads(open("parameter.json").read())
 input_size = len(chars)
 hidden_size = parameters["hidden_size"]
@@ -22,27 +21,12 @@ epochs = 1000
 learning_rate = parameters["learning_rate"]
 model_path = parameters["model_path"]
 
-# Create training data (input-output pairs)
 train_data = []
 for i in range(len(training_text) - sequence_length):
     input_seq = training_text[i : i + sequence_length]
     target_char = training_text[i + sequence_length]
     train_data.append((torch.tensor([char_to_idx[ch] for ch in input_seq]), char_to_idx[target_char]))
 
-# Define the simple RNN model
-class SimpleRNN(nn.Module):
-    def __init__(self, input_size, hidden_size, output_size):
-        super(SimpleRNN, self).__init__()
-        self.hidden_size = hidden_size
-        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
-        self.fc = nn.Linear(hidden_size, output_size)
-
-    def forward(self, x, hidden):
-        x = torch.nn.functional.one_hot(x, num_classes=input_size).float()
-        out, hidden = self.rnn(x.unsqueeze(0), hidden)
-        out = self.fc(out[:, -1, :])  # Take last time step's output
-        return out, hidden
-
 if os.path.exists(model_path):
     model = torch.load(model_path, weights_only=False)
     print("Loaded pre-trained model. Continue training...")
@@ -77,7 +61,6 @@ for epoch in range(epochs):
 hidden = torch.zeros(1, 1, hidden_size)
 output, hidden = model(input_seq, hidden.detach())
 
-# Save the trained model
 torch.save(model, model_path)
 with open("vocab.json", "w") as f:
     f.write(json.dumps(chars))