Update app.py

app.py

@@ -1,90 +1,55 @@
+
+
 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)
+
+# Introduction
+st.title("PyTorch Hands-On Course")
+st.write("""
+### Introduction
+
+Welcome to the PyTorch Hands-On Course! This course is designed to provide you with a practical understanding of PyTorch, a powerful and flexible deep learning framework. Throughout this course, you'll engage with ten carefully crafted exercises that will guide you from the basics of tensor operations to advanced topics such as convolutional neural networks, recurrent neural networks, and generative adversarial networks. By the end of this course, you'll have the skills and confidence to build, train, and deploy your own deep learning models using PyTorch.
+""")
+
+# Course Content
+st.write("""
+### Course Exercises
+
+1. **Introduction to PyTorch Tensors**
+   - **Exercise**: Create and manipulate tensors. Perform basic tensor operations such as addition, subtraction, and element-wise multiplication.
+
+2. **Linear Regression with PyTorch**
+   - **Exercise**: Implement a simple linear regression model from scratch using PyTorch. Train the model on a small dataset and visualize the results.
+
+3. **Logistic Regression for Binary Classification**
+   - **Exercise**: Build and train a logistic regression model for a binary classification task (e.g., predicting whether a student passes or fails based on study hours).
+
+4. **Feedforward Neural Network (FFNN)**
+   - **Exercise**: Implement a multi-layer feedforward neural network for a classification task (e.g., MNIST digit classification). Use PyTorch’s built-in modules and functions.
+
+5. **Convolutional Neural Networks (CNNs)**
+   - **Exercise**: Develop a CNN for image classification using a dataset like CIFAR-10. Include layers such as convolutional, pooling, and fully connected layers.
+
+6. **Recurrent Neural Networks (RNNs) and LSTMs**
+   - **Exercise**: Create an RNN or LSTM network to perform sequence prediction (e.g., text generation or time series forecasting).
+
+7. **Transfer Learning with Pre-trained Models**
+   - **Exercise**: Use a pre-trained model (e.g., ResNet, VGG) from the PyTorch library for a custom image classification task. Fine-tune the model on a new dataset.
+
+8. **Natural Language Processing (NLP) with PyTorch**
+   - **Exercise**: Implement a text classification model using an RNN or a Transformer-based model. Train the model on a dataset like IMDB movie reviews for sentiment analysis.
+
+9. **Generative Adversarial Networks (GANs)**
+   - **Exercise**: Build and train a simple GAN to generate synthetic images. Use a dataset like MNIST to generate handwritten digits.
+
+10. **Deploying PyTorch Models**
+    - **Exercise**: Learn how to save, load, and deploy PyTorch models. Create a simple web application using Flask to serve a trained model for inference.
+""")
+
+# Conclusion
+st.write("""
+### Conclusion
+
+Congratulations on completing the PyTorch Hands-On Course! You've taken a significant step in your journey as a deep learning practitioner. Through these exercises, you've learned how to create and manipulate tensors, build and train various types of neural networks, and even deploy your models. PyTorch's versatility and ease of use make it an excellent choice for both research and production applications. Keep experimenting, stay curious, and continue to build upon the foundation you've established here. Happy coding!
+""")
+
+