Create 11_FFNN.py

pages/11_FFNN.py

@@ -0,0 +1,107 @@
+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
+import numpy as np
+
+# Define the Feedforward Neural Network
+class FeedforwardNeuralNetwork(nn.Module):
+    def __init__(self, input_size, hidden1_size, hidden2_size, hidden3_size, output_size):
+        super(FeedforwardNeuralNetwork, self).__init__()
+        self.fc1 = nn.Linear(input_size, hidden1_size)
+        self.fc2 = nn.Linear(hidden1_size, hidden2_size)
+        self.fc3 = nn.Linear(hidden2_size, hidden3_size)
+        self.fc4 = nn.Linear(hidden3_size, output_size)
+        self.relu = nn.ReLU()
+
+    def forward(self, x):
+        x = x.view(-1, 28 * 28)
+        x = self.relu(self.fc1(x))
+        x = self.relu(self.fc2(x))
+        x = self.relu(self.fc3(x))
+        x = self.fc4(x)
+        return x
+
+# Function to load the data
+@st.cache
+def load_data():
+    transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
+    trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
+    testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
+    trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
+    testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)
+    return trainloader, testloader
+
+# Function to train the network
+def train_network(net, trainloader, criterion, optimizer, epochs):
+    for epoch in range(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()
+        st.write(f'Epoch {epoch + 1}: loss {running_loss / len(trainloader):.3f}')
+    st.write('Finished Training')
+
+# Function to test the network
+def test_network(net, testloader):
+    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:.2f}%')
+
+# Load the data
+trainloader, testloader = load_data()
+
+# Streamlit sidebar for input parameters
+st.sidebar.header('Model Hyperparameters')
+input_size = st.sidebar.slider('Input Size', 784, 784, 784)
+hidden1_size = st.sidebar.slider('Hidden Layer 1 Size', 128, 1024, 512)
+hidden2_size = st.sidebar.slider('Hidden Layer 2 Size', 128, 1024, 256)
+hidden3_size = st.sidebar.slider('Hidden Layer 3 Size', 128, 1024, 128)
+output_size = st.sidebar.slider('Output Size', 10, 10, 10)
+learning_rate = st.sidebar.slider('Learning Rate', 0.001, 0.1, 0.01, step=0.001)
+momentum = st.sidebar.slider('Momentum', 0.0, 1.0, 0.9, step=0.1)
+epochs = st.sidebar.slider('Epochs', 1, 20, 5)
+
+# Create the network
+net = FeedforwardNeuralNetwork(input_size, hidden1_size, hidden2_size, hidden3_size, output_size)
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=momentum)
+
+# Train the network
+if st.sidebar.button('Train Network'):
+    train_network(net, trainloader, criterion, optimizer, epochs)
+
+# Test the network
+if st.sidebar.button('Test Network'):
+    test_network(net, testloader)
+
+# Visualize some test results
+def imshow(img):
+    img = img / 2 + 0.5  # unnormalize
+    npimg = img.numpy()
+    plt.imshow(np.transpose(npimg, (1, 2, 0)))
+    plt.show()
+
+if st.sidebar.button('Show Test Results'):
+    dataiter = iter(testloader)
+    images, labels = dataiter.next()
+    imshow(torchvision.utils.make_grid(images))
+    st.write('GroundTruth: ', ' '.join(f'{labels[j]}' for j in range(8)))
+    outputs = net(images)
+    _, predicted = torch.max(outputs, 1)
+    st.write('Predicted: ', ' '.join(f'{predicted[j]}' for j in range(8)))