Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,13 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.git
+.gitignore
+.env
+venv
+data/
+training_plot.png
+check_libs.py
+implementation_plan.md
+train_cifar10.py

Dockerfile

@@ -16,8 +16,8 @@ COPY requirements.txt .
 # Install any needed packages specified in requirements.txt
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy the application code and model
-COPY web_app/ .
+# Copy everything from the current directory (where Dockerfile is)
+COPY . .
 
 # Create uploads directory
 RUN mkdir -p uploads && chmod 777 uploads

README.md

@@ -1,10 +1,47 @@
----
-title: CNN2
-emoji: 🦀
-colorFrom: pink
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# CIFAR-10 CNN Classifier
+
+This project implements a Convolutional Neural Network (CNN) to classify images from the CIFAR-10 dataset into 10 categories.
+
+## Dataset
+The CIFAR-10 dataset consists of 60,000 32x32 color images in 10 classes, with 6,000 images per class. There are 50,000 training images and 10,000 test images.
+
+## Model Architecture
+The CNN uses a multi-block architecture:
+- 3 Convolutional Blocks:
+  - 2x Conv2D layers with ReLU activation
+  - Batch Normalization
+  - Max Pooling
+  - Dropout for regularization
+- Flattened layer
+- Dense hidden layer (128 units)
+- Output layer (10 units with Softmax)
+
+## Setup and Usage
+1. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+2. Run the training script:
+   ```bash
+   python train_cifar10.py
+   ```
+
+## Files
+- `train_cifar10.py`: The main training and evaluation script.
+- `web_app/`: Complete web application for interactive inference.
+  - `server.py`: Flask backend.
+  - `static/`, `templates/`: Frontend assets.
+- `implementation_plan.md`: Detailed plan of the implementation.
+- `requirements.txt`: Python package dependencies.
+
+## Web Application
+To run the interactive vision tool:
+1. Navigate to the web app directory:
+   ```bash
+   cd web_app
+   ```
+2. Start the server:
+   ```bash
+   python server.py
+   ```
+3. Open `http://127.0.0.1:5000` in your browser.

check_libs.py

@@ -0,0 +1,25 @@
+import sys
+print(f"Python version: {sys.version}")
+try:
+    import tensorflow as tf
+    print(f"TensorFlow version: {tf.__version__}")
+except Exception as e:
+    print(f"TensorFlow import failed: {e}")
+
+try:
+    import keras
+    print(f"Keras version: {keras.__version__}")
+except Exception as e:
+    print(f"Keras import failed: {e}")
+
+try:
+    from tensorflow import keras as tf_keras
+    print("from tensorflow import keras successful")
+except Exception as e:
+    print(f"from tensorflow import keras failed: {e}")
+
+try:
+    import torch
+    print(f"PyTorch version: {torch.__version__}")
+except Exception as e:
+    print(f"PyTorch import failed: {e}")

deploy_to_hf.py

@@ -0,0 +1,56 @@
+from huggingface_hub import HfApi, login
+import os
+import sys
+
+def deploy():
+    # Use the token provided by the user in the next step
+    # For now, this script will try to use the stored token or prompt
+    api = HfApi()
+    
+    try:
+        user_info = api.whoami()
+        print(f"Logged in as: {user_info['name']}")
+    except Exception as e:
+        print(f"Authentication failed: {e}")
+        print("Please provide a valid WRITE token from https://huggingface.co/settings/tokens")
+        token = input("Enter your Hugging Face Write Token: ")
+        try:
+            login(token=token, add_to_git_credential=True)
+            user_info = api.whoami()
+            print(f"Successfully logged in as: {user_info['name']}")
+        except Exception as login_e:
+            print(f"Login failed even with token: {login_e}")
+            return
+
+    repo_id = f"{user_info['name']}/CNN2"
+    print(f"Creating/Checking Space: {repo_id}")
+    
+    try:
+        api.create_repo(
+            repo_id=repo_id,
+            repo_type="space",
+            space_sdk="docker",
+            exist_ok=True
+        )
+        print(f"Space {repo_id} is ready.")
+        
+        print("Uploading files...")
+        # Uploading the files from the current directory
+        # We upload Dockerfile, requirements.txt and everything in web_app/
+        
+        # Upload everything in the directory
+        api.upload_folder(
+            folder_path=".",
+            repo_id=repo_id,
+            repo_type="space",
+            ignore_patterns=[".git*", "data*", "__pycache__*", "venv*", "*.pyc", "web_app*"]
+        )
+        
+        print(f"\nDeployment Successful!")
+        print(f"View your Space at: https://huggingface.co/spaces/{repo_id}")
+        
+    except Exception as e:
+        print(f"Deployment failed: {e}")
+
+if __name__ == "__main__":
+    deploy()

implementation_plan.md

@@ -0,0 +1,39 @@
+# Implementation Plan - CIFAR-10 CNN Classifier
+
+This plan outlines the steps to build, train, and evaluate a Convolutional Neural Network (CNN) for the CIFAR-10 dataset.
+
+## 1. Environment Setup
+- Verify installation of `torch`, `torchvision`, `matplotlib`.
+- Import necessary modules.
+
+## 2. Data Preparation
+- Load CIFAR-10 dataset using `torchvision.datasets`.
+- Normalize and transform data to Tensors.
+- Explore data shapes and visualize sample images.
+
+## 3. Model Architecture
+- Build a PyTorch `nn.Module` CNN:
+  - Input layer: 32x32x3 images.
+  - Multiple Convolutional blocks (Conv2d -> BatchNorm2d -> ReLU -> MaxPool2d -> Dropout).
+  - Flatten layer.
+  - Fully connected layers with BatchNorm and Dropout.
+  - Output layer: 10 units.
+
+## 4. Training Configuration
+- Loss Function: `nn.CrossEntropyLoss()`.
+- Optimizer: `optim.Adam`.
+- Device: Use CUDA if available, else CPU.
+
+## 5. Model Training
+- Train the model on the training set.
+- Validate on the test/validation set.
+- Save the training history.
+
+## 6. Evaluation and Visualization
+- Evaluate the model on the test set.
+- Plot Training vs. Validation Accuracy/Loss.
+- Display a confusion matrix or classification report.
+- Save the final model.
+
+## 7. Inference Script (Optional)
+- Create a script to load the model and predict labels for new images.

train_cifar10.py

@@ -0,0 +1,131 @@
+import os
+import tensorflow as tf
+from tensorflow.keras import layers, models, callbacks
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Set random seed for reproducibility
+tf.random.set_seed(42)
+np.random.seed(42)
+
+def load_and_preprocess_data():
+    """Loads CIFAR-10 dataset and normalizes pixel values."""
+    print("Loading CIFAR-10 dataset...")
+    (train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.cifar10.load_data()
+
+    # Normalize pixel values to be between 0 and 1
+    train_images, test_images = train_images / 255.0, test_images / 255.0
+    
+    print(f"Train images shape: {train_images.shape}")
+    print(f"Test images shape: {test_images.shape}")
+    
+    return (train_images, train_labels), (test_images, test_labels)
+
+def build_cnn_model():
+    """Defines a robust CNN architecture for CIFAR-10."""
+    print("Building CNN architecture...")
+    model = models.Sequential([
+        # Block 1
+        layers.Conv2D(32, (3, 3), padding='same', activation='relu', input_shape=(32, 32, 3)),
+        layers.BatchNormalization(),
+        layers.Conv2D(32, (3, 3), padding='same', activation='relu'),
+        layers.BatchNormalization(),
+        layers.MaxPooling2D((2, 2)),
+        layers.Dropout(0.2),
+
+        # Block 2
+        layers.Conv2D(64, (3, 3), padding='same', activation='relu'),
+        layers.BatchNormalization(),
+        layers.Conv2D(64, (3, 3), padding='same', activation='relu'),
+        layers.BatchNormalization(),
+        layers.MaxPooling2D((2, 2)),
+        layers.Dropout(0.3),
+
+        # Block 3
+        layers.Conv2D(128, (3, 3), padding='same', activation='relu'),
+        layers.BatchNormalization(),
+        layers.Conv2D(128, (3, 3), padding='same', activation='relu'),
+        layers.BatchNormalization(),
+        layers.MaxPooling2D((2, 2)),
+        layers.Dropout(0.4),
+
+        # Classification Head
+        layers.Flatten(),
+        layers.Dense(128, activation='relu'),
+        layers.BatchNormalization(),
+        layers.Dropout(0.5),
+        layers.Dense(10, activation='softmax')
+    ])
+
+    model.compile(optimizer='adam',
+                  loss='sparse_categorical_crossentropy',
+                  metrics=['accuracy'])
+    
+    return model
+
+def train_and_evaluate():
+    # 1. Prepare Data
+    (train_images, train_labels), (test_images, test_labels) = load_and_preprocess_data()
+    
+    # 2. Build Model
+    model = build_cnn_model()
+    model.summary()
+
+    # 3. Callbacks
+    early_stop = callbacks.EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)
+    reduce_lr = callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=3, min_lr=1e-6)
+
+    # 4. Train
+    print("\nStarting training (limited to 2 epochs for demonstration)...")
+    history = model.fit(
+        train_images, train_labels,
+        epochs=2, # Increase to 50 for full training
+        batch_size=64,
+        validation_data=(test_images, test_labels),
+        callbacks=[early_stop, reduce_lr]
+    )
+
+    # 5. Evaluate
+    print("\nEvaluating model...")
+    test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
+    print(f"\nFinal Test Accuracy: {test_acc*100:.2f}%")
+
+    # 6. Save Model
+    model.save('cifar10_cnn_v1.h5')
+    print("Model saved to cifar10_cnn_v1.h5")
+
+    return history
+
+def plot_results(history):
+    """Visualizes training history."""
+    acc = history.history['accuracy']
+    val_acc = history.history['val_accuracy']
+    loss = history.history['loss']
+    val_loss = history.history['val_loss']
+    epochs_range = range(len(acc))
+
+    plt.figure(figsize=(12, 5))
+    
+    plt.subplot(1, 2, 1)
+    plt.plot(epochs_range, acc, label='Training Accuracy')
+    plt.plot(epochs_range, val_acc, label='Validation Accuracy')
+    plt.title('Accuracy')
+    plt.legend()
+
+    plt.subplot(1, 2, 2)
+    plt.plot(epochs_range, loss, label='Training Loss')
+    plt.plot(epochs_range, val_loss, label='Validation Loss')
+    plt.title('Loss')
+    plt.legend()
+
+    plt.savefig('training_plot.png')
+    print("Training plots saved as training_plot.png")
+
+if __name__ == "__main__":
+    try:
+        hist = train_and_evaluate()
+        plot_results(hist)
+    except Exception as e:
+        print(f"\n[ERROR] An error occurred: {e}")
+        print("\nNote: If you encounter DLL errors or ModuleNotFound errors, please ensure "
+              "TensorFlow is correctly installed in your environment (e.g., pip install tensorflow).")