init eval

.github/workflows/pylint.yml

@@ -0,0 +1,23 @@
+name: Pylint
+
+on: [push, pull_request]
+
+jobs:
+ pylint:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Check out code
+ uses: actions/checkout@v2
+
+ - name: Set up Python 3.x
+ uses: actions/setup-python@v2
+ with:
+ python-version: '3.x'
+
+ - name: Install Dependencies
+ run: |
+ python -m pip install --upgrade pip
+ pip install pylint
+
+ - name: Run Pylint
+ run: pylint src/*.py

requirements.txt

@@ -0,0 +1,5 @@
+fastapi==0.68.0
+uvicorn==0.15.0
+torch
+torchvision
+Pillow

src/api.py

@@ -0,0 +1,28 @@
+from fastapi import FastAPI, UploadFile, File
+from PIL import Image
+import torch
+from torchvision import transforms
+from main import Net # Importing Net class from main.py
+
+# Load the model
+model = Net()
+model.load_state_dict(torch.load("mnist_model.pth"))
+model.eval()
+
+# Transform used for preprocessing the image
+transform = transforms.Compose([
+ transforms.ToTensor(),
+ transforms.Normalize((0.5,), (0.5,))
+])
+
+app = FastAPI()
+
+@app.post("/predict/")
+async def predict(file: UploadFile = File(...)):
+ image = Image.open(file.file).convert("L")
+ image = transform(image)
+ image = image.unsqueeze(0) # Add batch dimension
+ with torch.no_grad():
+ output = model(image)
+ _, predicted = torch.max(output.data, 1)
+ return {"prediction": int(predicted[0])}

src/main.py

@@ -0,0 +1,48 @@
+from PIL import Image
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+import numpy as np
+
+# Step 1: Load MNIST Data and Preprocess
+transform = transforms.Compose([
+ transforms.ToTensor(),
+ transforms.Normalize((0.5,), (0.5,))
+])
+
+trainset = datasets.MNIST('.', download=True, train=True, transform=transform)
+trainloader = DataLoader(trainset, batch_size=64, shuffle=True)
+
+# Step 2: Define the PyTorch Model
+class Net(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.fc1 = nn.Linear(28 * 28, 128)
+ self.fc2 = nn.Linear(128, 64)
+ self.fc3 = nn.Linear(64, 10)
+
+ def forward(self, x):
+ x = x.view(-1, 28 * 28)
+ x = nn.functional.relu(self.fc1(x))
+ x = nn.functional.relu(self.fc2(x))
+ x = self.fc3(x)
+ return nn.functional.log_softmax(x, dim=1)
+
+# Step 3: Train the Model
+model = Net()
+optimizer = optim.SGD(model.parameters(), lr=0.01)
+criterion = nn.NLLLoss()
+
+# Training loop
+epochs = 3
+for epoch in range(epochs):
+ for images, labels in trainloader:
+ optimizer.zero_grad()
+ output = model(images)
+ loss = criterion(output, labels)
+ loss.backward()
+ optimizer.step()
+
+torch.save(model.state_dict(), "mnist_model.pth")