You can deploy this model and start earning money today!

jeevan-bhat/
mnist

Name: mnist
Availability: InStock

Views

No views yet

MNIST CNN Model - Complete Implementation

This project implements a Convolutional Neural Network (CNN) for digit classification on the MNIST dataset using PyTorch with a web interface for live predictions.

🎯 Project Overview

The project consists of:

Data Loader (data_loader.py): Parses MNIST idx-ubyte binary files
CNN Model (model.py): 2-layer convolutional neural network
Training Script (train.py): Model training with visualization
Web Application (app.py): Flask web server with interactive digit drawing

📁 Project Structure

mighty/
├── archive/                    # MNIST dataset
│   ├── train-images.idx3-ubyte
│   ├── train-labels.idx1-ubyte
│   ├── t10k-images.idx3-ubyte
│   └── t10k-labels.idx1-ubyte
├── static/
│   ├── style.css              # Modern web interface styling
│   └── script.js              # Interactive canvas and prediction logic
├── templates/
│   └── index.html             # Web interface template
├── data_loader.py             # Dataset loading utilities
├── model.py                   # CNN architecture (PyTorch)
├── train.py                   # Training script
├── app.py                     # Flask web application
└── requirements.txt           # Python dependencies

🔧 Installation

Prerequisites

Python 3.8 or higher
Windows Long Path support MUST be enabled

Enable Windows Long Path Support

IMPORTANT: Before installing dependencies, you MUST enable Windows Long Path support:

Method 1: Registry Editor (Recommended)

Press Win + R, type regedit, and press Enter
Navigate to: COMPUTER\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem
Find LongPathsEnabled (or create it as a DWORD if it doesn't exist)
Set the value to 1
Restart your computer

Method 2: PowerShell (Administrator)

New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name "LongPathsEnabled" -Value 1 -PropertyType DWORD -Force

Install Dependencies

After enabling Long Path support and restarting:

bash

pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
pip install flask matplotlib pillow opencv-python numpy

Or use the requirements file:

pip install -r requirements.txt

🚀 Usage

1. Train the Model

python train.py

This will:

Load the MNIST dataset from the archive folder
Train the CNN for 10 epochs
Save the trained model to mnist_cnn_model.pth
Generate training history plots (training_history.png)
Display test accuracy

Expected output:

CNN Training Script (PyTorch)
============================================================
Using device: cpu

[1/5] Loading data...
✓ Loaded 60000 training samples and 10000 test samples

[2/5] Preprocessing data...
✓ Data preprocessed and loaded
  Training samples: 54000
  Validation samples: 6000
  Test samples: 10000

[3/5] Creating model...
...

[4/5] Training model...
Epoch 1/10 - Train Loss: 0.2345, Train Acc: 0.9234 - Val Loss: 0.1234, Val Acc: 0.9567
...

[5/5] Evaluating model...
✓ Test Accuracy: 0.9812 (98.12%)
✓ Model saved to: mnist_cnn_model.pth

2. Start the Web Application

python app.py

The web server will start on http://localhost:5000

3. Use the Web Interface

Open your browser and navigate to http://localhost:5000
Draw a digit (0-9) on the canvas
Click "🔮 Predict" to see the model's prediction
View confidence scores and probability distribution
Click "🗑️ Clear" to draw again

🎨 Web Interface Features

Interactive Drawing Canvas: Draw digits with your mouse or touch
Real-time Predictions: Get instant predictions with confidence scores
Probability Visualization: See probability distribution for all digits (0-9)
Modern UI: Beautiful gradient design with smooth animations
Responsive: Works on desktop and mobile devices

📊 Model Architecture

CNNModel(
  (conv1): Conv2d(1, 32, kernel_size=(3, 3), padding=1)
  (pool1): MaxPool2d(kernel_size=2, stride=2)
  (conv2): Conv2d(32, 64, kernel_size=(3, 3), padding=1)
  (pool2): MaxPool2d(kernel_size=2, stride=2)
  (fc1): Linear(in_features=3136, out_features=128)
  (dropout): Dropout(p=0.5)
  (fc2): Linear(in_features=128, out_features=10)
)

Parameters:

Input: 28x28 grayscale images
Conv layers: 32 and 64 filters
Fully connected: 128 hidden units
Output: 10 classes (digits 0-9)
Total parameters: ~600K

🌐 Hosting Options

Local Network Access

To make the app accessible on your local network:

python

# In app.py, change the last line to:
app.run(debug=True, host='0.0.0.0', port=5000)

Then access from other devices using: http://<your-ip-address>:5000

Cloud Deployment Options

Option 1: Heroku

Create a Procfile:

web: python app.py

Update app.py to use PORT from environment:

python

import os
port = int(os.environ.get('PORT', 5000))
app.run(debug=False, host='0.0.0.0', port=port)

Deploy:

bash

git init
heroku create mnist-digit-classifier
git add .
git commit -m "Initial commit"
git push heroku main

Option 2: Render

Create account at https://render.com
Create new Web Service
Connect your GitHub repository
Build command: pip install -r requirements.txt
Start command: python app.py

Option 3: Railway

Create account at https://railway.app
Create new project from GitHub
Railway auto-detects Python and installs dependencies
Access your app at the provided URL

Option 4: Replit

Go to https://replit.com
Create new Python repl
Upload all files
Run python app.py
Replit provides automatic public URL

⚠️ Troubleshooting

Issue: Long Path Error During Installation

Solution: Enable Windows Long Path support (see Installation section above)

Issue: Model file not found

Solution: Train the model first using python train.py

Issue: Port 5000 already in use

Solution: Change the port in app.py:

app.run(debug=True, port=8000) # Use any available port

Issue: Low accuracy

Solution:

Ensure dataset is loaded correctly
Increase training epochs (edit train.py)
Check data preprocessing

📈 Expected Performance

Training Time: ~5-10 minutes on CPU (10 epochs)
Test Accuracy: ~98%+
Model Size: ~2.4 MB
Inference Time: <100ms per prediction

🔑 Key Files Explained

`data_loader.py`

Loads and preprocesses MNIST binary files:

Reads idx-ubyte format
Normalizes pixel values to [0, 1]
Returns train/test splits

`model.py`

Defines CNN architecture:

2 convolutional layers
Max pooling
Dropout for regularization
Fully connected output layer

`train.py`

Training pipeline:

Data loading and preprocessing
Model training with validation
Performance visualization
Model checkpoint saving

`app.py`

Flask web server:

Handles image upload from canvas
Preprocesses drawn digits
Returns predictions with confidence

🎓 Dataset Information

MNIST Dataset:

60,000 training images
10,000 test images
28x28 grayscale images
10 classes (digits 0-9)

📝 License

This project is for educational purposes.

🤝 Contributing

Feel free to submit issues or pull requests for improvements!

Built with ❤️ using PyTorch and Flask

jeevan-bhat/mnist