Deploying CNN App (clean)

.dockerignore

@@ -0,0 +1,9 @@
+__pycache__
+.git
+.venv
+.env
+*.pyc
+*.pyo
+*.pyd
+.DS_Store
+MNIST/

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.9
+
+WORKDIR /app
+
+COPY requirements.txt requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+# Create uploads directory and set permissions for potentially non-root user
+RUN mkdir -p uploads && chmod 777 uploads
+
+EXPOSE 7860
+
+CMD ["flask", "run", "--host=0.0.0.0", "--port=7860"]

README.md

@@ -1,10 +1,30 @@
----
-title: CNN CIFAR10 Classifier
-emoji: 🐢
-colorFrom: gray
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: CNN Cifar10 Classifier
+emoji: 🚀
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: false
+license: mit
+---
+# CNN Image Classification
+
+This project implements a Convolutional Neural Network (CNN) to classify images from the CIFAR-10 dataset using PyTorch.
+
+
+## Structure
+
+- `src/`: Source code for the model and data processing.
+- `main.py`: Entry point for training and evaluation.
+
+## Usage
+
+1. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. Run the training pipeline:
+   ```bash
+   python main.py
+   ```

app.py

@@ -0,0 +1,58 @@
+
+import os
+import torch
+import torchvision.transforms as transforms
+from flask import Flask, request, render_template, redirect, url_for
+from PIL import Image
+from src.model import create_model
+
+app = Flask(__name__)
+UPLOAD_FOLDER = 'uploads'
+if not os.path.exists(UPLOAD_FOLDER):
+    os.makedirs(UPLOAD_FOLDER)
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+
+# Load Model
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+model = create_model()
+model.load_state_dict(torch.load('models/cifar10_cnn.pth', map_location=device))
+model.to(device)
+model.eval()
+
+# Classes
+CLASSES = ('plane', 'car', 'bird', 'cat',
+           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+
+def transform_image(image_path):
+    transform = transforms.Compose([
+        transforms.Resize((32, 32)),
+        transforms.ToTensor(),
+        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
+    ])
+    image = Image.open(image_path)
+    return transform(image).unsqueeze(0).to(device)
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    if request.method == 'POST':
+        if 'file' not in request.files:
+            return redirect(request.url)
+        file = request.files['file']
+        if file.filename == '':
+            return redirect(request.url)
+        if file:
+            file_path = os.path.join(app.config['UPLOAD_FOLDER'], file.filename)
+            file.save(file_path)
+            
+            # Predict
+            input_tensor = transform_image(file_path)
+            with torch.no_grad():
+                output = model(input_tensor)
+                _, predicted = torch.max(output, 1)
+                predicted_class = CLASSES[predicted.item()]
+            
+            return render_template('index.html', prediction=predicted_class, image_path=file_path)
+    return render_template('index.html', prediction=None, image_path=None)
+
+if __name__ == '__main__':
+    app.run(debug=True)

deploy_to_hf.py

@@ -0,0 +1,51 @@
+from huggingface_hub import HfApi, create_repo
+import os
+
+def deploy():
+    api = HfApi()
+    username = api.whoami()["name"]
+    repo_name = "CNN-CIFAR10-Classifier"
+    repo_id = f"{username}/{repo_name}"
+    
+    print(f"Deploying to Space: {repo_id}")
+    
+    # Clean up existing repo to free quota
+    try:
+        from huggingface_hub import delete_repo
+        print("Deleting existing repository to ensure clean state...")
+        delete_repo(repo_id, repo_type="space")
+        print("Repository deleted.")
+    except Exception as e:
+        print(f"Repository deletion skipped or failed (might not exist): {e}")
+
+    # Create the Space
+    try:
+        create_repo(repo_id, repo_type="space", space_sdk="docker", private=False)
+        print("Space repository created.")
+    except Exception as e:
+        print(f"Creation error: {e}")
+
+    # Determine ignore patterns
+    ignore_patterns = [
+        ".git*", 
+        ".venv*", 
+        "__pycache__*", 
+        "*.pyc", 
+        ".DS_Store",
+        "data/*",      # Exclude dataset
+        "MNIST/*",     # Exclude unrelated folder
+        "uploads/*"    # Exclude user uploads
+    ]
+
+    print("Uploading files...")
+    api.upload_folder(
+        folder_path=".",
+        repo_id=repo_id,
+        repo_type="space",
+        ignore_patterns=ignore_patterns,
+        commit_message="Deploying CNN App (clean)"
+    )
+    print(f"Successfully uploaded files to https://huggingface.co/spaces/{repo_id}")
+
+if __name__ == "__main__":
+    deploy()

main.py

@@ -0,0 +1,39 @@
+
+from src.data_loader import load_data
+from src.model import create_model
+from src.train import train_model
+from src.evaluate import evaluate_model
+import torch
+import os
+
+def main():
+    print("Starting CNN CIFAR-10 Project (PyTorch)...")
+    
+    # Load Data
+    print("Loading data...")
+    trainloader, testloader, classes = load_data()
+    print(f"Data loaded: Train batches {len(trainloader)}, Test batches {len(testloader)}")
+
+    # Create Model
+    print("Creating model...")
+    model = create_model()
+    # print(model)
+
+    # Train Model
+    print("Training model...")
+    # Using 1 epoch for verification
+    history = train_model(model, trainloader, testloader, epochs=10) 
+
+    # Evaluate Model
+    print("Evaluating model...")
+    accuracy = evaluate_model(model, testloader)
+    print(f"Test Accuracy: {accuracy:.4f}")
+
+    # Save Model
+    if not os.path.exists('models'):
+        os.makedirs('models')
+    torch.save(model.state_dict(), 'models/cifar10_cnn.pth')
+    print("Model saved to models/cifar10_cnn.pth")
+
+if __name__ == "__main__":
+    main()

models/cifar10_cnn.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c285a2b53075ba6ba234c5eed862d68c3bc602e21597acce4104d16ae3497dd7
+size 2208203

requirements.txt

@@ -0,0 +1,7 @@
+torch
+torchvision
+numpy
+matplotlib
+scikit-learn
+flask
+pillow

src/data_loader.py

@@ -0,0 +1,30 @@
+
+import torch
+import torchvision
+import torchvision.transforms as transforms
+
+def load_data(batch_size=64):
+    """
+    Loads and preprocesses the CIFAR-10 dataset using PyTorch.
+    
+    Returns:
+        tuple: (trainloader, testloader)
+    """
+    transform = transforms.Compose(
+        [transforms.ToTensor(),
+         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
+
+    trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
+                                            download=True, transform=transform)
+    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
+                                              shuffle=True, num_workers=0)
+
+    testset = torchvision.datasets.CIFAR10(root='./data', train=False,
+                                           download=True, transform=transform)
+    testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
+                                             shuffle=False, num_workers=0)
+
+    classes = ('plane', 'car', 'bird', 'cat',
+               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+    
+    return trainloader, testloader, classes

src/evaluate.py

@@ -0,0 +1,23 @@
+
+import torch
+
+def evaluate_model(model, testloader):
+    """
+    Evaluates the model on the test set.
+    """
+    correct = 0
+    total = 0
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    model.to(device)
+    model.eval()
+    
+    with torch.no_grad():
+        for data in testloader:
+            images, labels = data[0].to(device), data[1].to(device)
+            outputs = model(images)
+            _, predicted = torch.max(outputs.data, 1)
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+
+    accuracy = correct / total
+    return accuracy

src/model.py

@@ -0,0 +1,59 @@
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Net(nn.Module):
+    def __init__(self):
+        super(Net, self).__init__()
+        # First Conv Block
+        self.conv1_1 = nn.Conv2d(3, 32, 3, padding=1)
+        self.conv1_2 = nn.Conv2d(32, 32, 3, padding=1)
+        self.pool = nn.MaxPool2d(2, 2)
+        self.dropout1 = nn.Dropout(0.2)
+
+        # Second Conv Block
+        self.conv2_1 = nn.Conv2d(32, 64, 3, padding=1)
+        self.conv2_2 = nn.Conv2d(64, 64, 3, padding=1)
+        self.dropout2 = nn.Dropout(0.3)
+
+        # Third Conv Block
+        self.conv3_1 = nn.Conv2d(64, 128, 3, padding=1)
+        self.conv3_2 = nn.Conv2d(128, 128, 3, padding=1)
+        self.dropout3 = nn.Dropout(0.4)
+
+        # Dense Layers
+        self.fc1 = nn.Linear(128 * 4 * 4, 128)
+        self.dropout4 = nn.Dropout(0.5)
+        self.fc2 = nn.Linear(128, 10)
+
+    def forward(self, x):
+        # Block 1
+        x = F.relu(self.conv1_1(x))
+        x = F.relu(self.conv1_2(x))
+        x = self.pool(x)
+        x = self.dropout1(x)
+
+        # Block 2
+        x = F.relu(self.conv2_1(x))
+        x = F.relu(self.conv2_2(x))
+        x = self.pool(x)
+        x = self.dropout2(x)
+
+        # Block 3
+        x = F.relu(self.conv3_1(x))
+        x = F.relu(self.conv3_2(x))
+        x = self.pool(x)
+        x = self.dropout3(x)
+
+        # Flatten
+        x = x.view(-1, 128 * 4 * 4)
+        
+        # Dense
+        x = F.relu(self.fc1(x))
+        x = self.dropout4(x)
+        x = self.fc2(x)
+        return x
+
+def create_model():
+    return Net()

src/train.py

@@ -0,0 +1,48 @@
+
+import torch
+import torch.optim as optim
+import torch.nn as nn
+
+def train_model(model, trainloader, testloader, epochs=10, learning_rate=0.001):
+    """
+    Trains the PyTorch model.
+    """
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    print(f"Training on device: {device}")
+    model.to(device)
+
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
+
+    history = {'accuracy': [], 'loss': []}
+
+    for epoch in range(epochs):
+        running_loss = 0.0
+        correct = 0
+        total = 0
+        
+        model.train()
+        for i, data in enumerate(trainloader, 0):
+            inputs, labels = data[0].to(device), data[1].to(device)
+
+            optimizer.zero_grad()
+
+            outputs = model(inputs)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+
+            running_loss += loss.item()
+            _, predicted = torch.max(outputs.data, 1)
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+
+        epoch_loss = running_loss / len(trainloader)
+        epoch_acc = correct / total
+        history['loss'].append(epoch_loss)
+        history['accuracy'].append(epoch_acc)
+        
+        print(f'Epoch {epoch + 1}/{epochs} - Loss: {epoch_loss:.4f} - Accuracy: {epoch_acc:.4f}')
+
+    print('Finished Training')
+    return history

templates/index.html

@@ -0,0 +1,68 @@
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>CIFAR-10 Classifier</title>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background-color: #f4f4f9;
+            color: #333;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            height: 100vh;
+            margin: 0;
+        }
+        h1 {
+            color: #4a90e2;
+        }
+        .container {
+            background: white;
+            padding: 2rem;
+            border-radius: 10px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            text-align: center;
+        }
+        input[type="file"] {
+            margin: 1rem 0;
+        }
+        button {
+            background-color: #4a90e2;
+            color: white;
+            border: none;
+            padding: 10px 20px;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 1rem;
+        }
+        button:hover {
+            background-color: #357abd;
+        }
+        .result {
+            margin-top: 2rem;
+            font-size: 1.2rem;
+            font-weight: bold;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>CIFAR-10 Image Classifier</h1>
+        <form method="post" enctype="multipart/form-data">
+            <input type="file" name="file" accept="image/*" required>
+            <br>
+            <button type="submit">Classify Image</button>
+        </form>
+
+        {% if prediction %}
+            <div class="result">
+                <p>Prediction: <span style="color: #e74c3c;">{{ prediction }}</span></p>
+            </div>
+        {% endif %}
+    </div>
+</body>
+</html>