Create app.py

app.py

@@ -0,0 +1,90 @@
+import streamlit as st
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torchvision
+import torchvision.transforms as transforms
+import matplotlib.pyplot as plt
+
+# Define the neural network
+class Net(nn.Module):
+    def __init__(self):
+        super(Net, self).__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 = torch.relu(self.fc1(x))
+        x = torch.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+
+# Function to train the model
+def train_model(num_epochs):
+    # Define transformations
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize((0.5,), (0.5,))
+    ])
+
+    # Load datasets
+    trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
+    trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
+
+    testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
+    testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)
+
+    # Initialize the network, loss function, and optimizer
+    net = Net()
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)
+
+    # Track loss over epochs
+    loss_values = []
+
+    # Training loop
+    for epoch in range(num_epochs):
+        running_loss = 0.0
+        for i, data in enumerate(trainloader, 0):
+            inputs, labels = data
+            optimizer.zero_grad()
+            outputs = net(inputs)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            running_loss += loss.item()
+        
+        # Append average loss for this epoch
+        loss_values.append(running_loss / len(trainloader))
+        st.write(f'Epoch {epoch + 1}, Loss: {running_loss / len(trainloader):.3f}')
+
+    st.write('Finished Training')
+
+    # Plot the loss values
+    plt.figure(figsize=(10, 5))
+    plt.plot(range(1, num_epochs + 1), loss_values, marker='o')
+    plt.title('Training Loss over Epochs')
+    plt.xlabel('Epoch')
+    plt.ylabel('Loss')
+    st.pyplot(plt)
+
+    # Evaluate the network on the test data
+    correct = 0
+    total = 0
+    with torch.no_grad():
+        for data in testloader:
+            images, labels = data
+            outputs = net(images)
+            _, predicted = torch.max(outputs.data, 1)
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+
+    st.write(f'Accuracy of the network on the 10000 test images: {100 * correct / total}%')
+
+# Streamlit interface
+st.title('MNIST Digit Classification with PyTorch')
+num_epochs = st.number_input('Enter number of epochs:', min_value=1, max_value=100, value=10)
+if st.button('Run'):
+    train_model(num_epochs)