Upload folder using huggingface_hub

MultiplicationNet.py

@@ -0,0 +1,15 @@
+import torch.nn as nn
+
+class MultiplicationNet(nn.Module):
+    def __init__(self):
+        super(MultiplicationNet, self).__init__()
+        layer_sizes = [2, 64, 128, 256, 1]
+        layers = []
+        for i in range(len(layer_sizes) - 1):
+            layers.append(nn.Linear(layer_sizes[i], layer_sizes[i + 1]))
+            layers.append(nn.ReLU())
+        layers.pop()
+        self.model = nn.Sequential(*layers)
+
+    def forward(self, x):
+        return self.model(x)

model.pth

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

run.py

@@ -0,0 +1,13 @@
+import torch
+
+model = torch.load("model.pth", weights_only=False)
+
+def run(test):
+    with torch.no_grad():
+        test_data = torch.tensor([test], dtype=torch.float)
+        predictions = model(test_data)
+        return predictions.squeeze().numpy()
+
+if __name__ == '__main__':
+    x, y = map(int, input().split())
+    print(run([x, y]))

train.py

@@ -0,0 +1,39 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+from MultiplicationNet import MultiplicationNet
+
+def generate_data(num_samples, min_val=0, max_val=100):
+    x1 = np.random.randint(min_val, max_val, size=(num_samples, 1))
+    x2 = np.random.randint(min_val, max_val, size=(num_samples, 1))
+    y = x1 * x2
+    return np.hstack([x1, x2]), y
+
+def train():
+    num_samples = 10000
+    num_epochs = 5000
+    learning_rate = 0.01
+
+    x, y = generate_data(num_samples)
+    x_train = torch.tensor(x, dtype=torch.float)
+    y_train = torch.tensor(y, dtype=torch.float)
+
+    model = MultiplicationNet()
+    criterion = nn.MSELoss()
+    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
+    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=100, gamma=0.95)
+
+    for epoch in range(num_epochs):
+        outputs = model(x_train)
+        loss = criterion(outputs, y_train)
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+        scheduler.step()
+        print(f"Epoch {epoch}, loss = {loss.item()}")
+
+    torch.save(model, "model.pth")
+
+if __name__ == '__main__':
+    train()