Upload folder using huggingface_hub

README.md

@@ -1,3 +1,41 @@
----
-license: mit
----
+# SolveQ
+
+Simple neural network that learns `y = 2x + 3`. Built with PyTorch.
+
+## What it does
+
+Trains a small network to approximate a linear function. The model has one hidden layer and learns from synthetic data.
+
+## Setup
+
+```bash
+pip install -r requirements.txt
+```
+
+## Running
+
+Train the model:
+
+```bash
+python src/train.py
+```
+
+This generates 200 samples, trains for 1000 epochs, shows the loss plot, and saves to `models/model.pt`.
+
+![Training Loss](models/loss.png)
+
+Make predictions:
+
+```bash
+python src/predict.py
+```
+
+Predicts `x = 4.0` by default. To test other values, edit the `predict()` call in `predict.py`.
+
+## Model
+
+- Input: 1 neuron
+- Hidden: 16 neurons (ReLU)
+- Output: 1 neuron
+
+Uses Adam optimizer (lr=0.01) and MSE loss.

models/model.pt

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

requirements.txt

@@ -0,0 +1,2 @@
+torch>=2.0.0
+matplotlib>=3.5.0

src/dataset.py

@@ -0,0 +1,11 @@
+import torch
+
+def get_data(n=200):
+  x = torch.linspace(-10,10,n).unsqueeze(1)
+  y = 2 * x + 3
+  return x, y
+
+if __name__ == '__main__':
+    x,y = get_data()
+    print(x)
+    print(y)

src/model.py

@@ -0,0 +1,12 @@
+import torch.nn as nn
+
+class LinearModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(1,16),
+            nn.ReLU(),
+            nn.Linear(16,1)
+        )
+    def forward(self, x):
+        return self.net(x)

src/predict.py

@@ -0,0 +1,16 @@
+import torch
+from model import LinearModel
+
+def predict(x_value):
+    model = LinearModel()
+    model.load_state_dict(torch.load("models/model.pt"))
+    model.eval()
+
+    x = torch.tensor([[x_value]], dtype=torch.float32)
+    y = model(x)
+    print(f"Input: {x_value} | Prediction: {y.item()}")
+def actual(x):
+    return 2 * x + 3
+if __name__ == "__main__":
+    predict(4.0)
+    print(f"Actual: {actual(4.0)}")

src/train.py

@@ -0,0 +1,34 @@
+import torch
+import torch.nn as nn
+from dataset import get_data
+from model import LinearModel
+from matplotlib import pyplot as plt
+def train():
+    x_train, y_train = get_data()
+    model = LinearModel()
+    loss_fn = nn.MSELoss()
+    optimizer = torch.optim.Adam(model.parameters(),lr=0.01)
+    epochs = 1000
+    y_axis = []
+    for epoch in range(epochs):
+        pred = model(x_train)
+        loss = loss_fn(pred,y_train)
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+        y_axis.append(loss.item())
+        if epoch % 100 == 0:
+            print(f'Epoch {epoch}, Loss: {loss.item()}')
+    x_axis = range(epochs)
+    plt.plot(x_axis, y_axis)
+    plt.xlabel('Epochs')
+    plt.ylabel('Loss')
+    plt.title('Training Loss over Epochs')
+    
+    
+    torch.save(model.state_dict(),'models/model.pt')
+    print('Model saved!')
+    plt.show()
+        
+if __name__ == '__main__':
+    train()