Upload folder using huggingface_hub

README.md

@@ -11,7 +11,7 @@ app_port: 7860
 
 ![Demonstration](https://varak.dev/host/EMNIST-OCR-DEMO.webp)
 
-Use the tool live [here](https://ocr.varak.dev).
+Use the tool [live here](https://ocr.varak.dev).
 
 This is an optical character recognition (OCR) tool that extracts characters from drawings. It's made with FastAPI for the backend, vanilla JS/HTML for the frontend, and the model was trained using PyTorch.
 
@@ -21,7 +21,7 @@ The only two routes for the backend are `/` for the home page and `/predict` for
 
 ## Usage
 
-Once again, the tool is hosted [here](https://ocr.varak.dev) for easy access. 
+Once again, the tool is hosted [on this webpage](https://ocr.varak.dev) for easy access.
 
 Draw the character you want to recognize on the left canvas. The right canvas will display the top-k predictions, where k can be adjusted using the slider below it. The slider is capped at 15 since, after 15, all of the predictions are basically guaranteed to be at 0% probability.
 
@@ -31,67 +31,66 @@ To run this project locally, take the following steps:
 
 1. Clone this repository.
 
-```bash
-git clone https://github.com/intelligent-username/OCR
-cd OCR
-```
+    ```bash
+    git clone https://github.com/intelligent-username/OCR
+    cd OCR
+    ```
 
 2. Install the Python dependencies to a virtual environment.
 
-```bash
-python -m venv OCR-env
-OCR-env\Scripts\activate        # On Windows
-source OCR-env/bin/activate     # On mac/Linux
-pip install -r requirements.txt
-```
+    ```bash
+    python -m venv OCR-env
+    OCR-env\Scripts\activate        # On Windows
+    source OCR-env/bin/activate     # On mac/Linux
+    pip install -r requirements.txt
+    ```
 
 3. Run the backend.
 
-<!--
+    ```bash
+    uvicorn backend.app:app --reload
+    ```
 
-Note that, to run the backend from the `backend/` folder, some adjustments to the file paths in `app.py` need to be made, since this version of the project is for the HuggingFace deployment, which uses the root directory as the working directory. The only real difference will be to add `../` to the files paths. Here's the list of changes to make in `app.py`:
+    <!--
 
-Change lines 5 and 6 to:
+    Note that, to run the backend from the `backend/` folder, some adjustments to the file paths in `app.py` need to be made, since this version of the project is for the HuggingFace deployment, which uses the root directory as the working directory. The only real difference will be to add `../` to the files paths. Here's the list of changes to make in `app.py`:
 
-```python
-from utils import predict_image
-from model import EMNIST_VGG
+    Change lines 5 and 6 to:
 
-```
+    ```python
+    from utils import predict_image
+    from model import EMNIST_VGG
 
-- Change line 40 to:
+    ```
 
-```python
-model.load_state_dict(t.load("EMNIST_CNN.pth", map_location=device, weights_only=True))
+    - Change line 40 to:
 
-```
+    ```python
+    model.load_state_dict(t.load("EMNIST_CNN.pth", map_location=device, weights_only=True))
 
-- Change line 43 to:
+    ```
 
-```python
-model = t.load("EMNIST_CNN.pth", map_location=device, weights_only=False)
-```
+    - Change line 43 to:
 
-- Change line 47 to:
+    ```python
+    model = t.load("EMNIST_CNN.pth", map_location=device, weights_only=False)
+    ```
 
-```python
-app.mount("/static", StaticFiles(directory="frontend"), name="static")
-```
+    - Change line 47 to:
 
-- Change line 51 to:
+    ```python
+    app.mount("/static", StaticFiles(directory="frontend"), name="static")
+    ```
 
-```python
-path = os.path.join("..", "frontend", "index.html")
-``` 
+    - Change line 51 to:
 
-You may want to run it from the backend folder if you really want to avoid typing `backend.` at the beginning of the uvicorn command.
+    ```python
+    path = os.path.join("..", "frontend", "index.html")
+    ``` 
 
--->
+    You may want to run it from the backend folder if you really want to avoid typing `backend.` at the beginning of the uvicorn command.
 
-
-```bash
-uvicorn backend.app:app --reload
-```
+    -->
 
 4. Once the backend is running, go to [http://127.0.0.1:8000/](http://127.0.0.1:8000/) in your web browser to access the frontend. This link will appear in the terminal when you run the backend.
 

backend/model.py

@@ -1,28 +1,31 @@
 """
 VGG-style CNN for EMNIST character classification.
 See the README for a more detailed description.
-"""
 
-# The .pth file (weights) for this model will be downloaded from HuggingFace by app.py
-# It's hosted at https://huggingface.co/compendious/EMNIST-OCR-WEIGHTS/
-# The file is EMNIST_CNN.pth
-# Go here to download directly: 
-#               https://huggingface.co/compendious/EMNIST-OCR-WEIGHTS/resolve/main/EMNIST_CNN.pth?download=true
+The .pth file (weights) for this model will be downloaded from HuggingFace by app.py
+It's hosted at https://huggingface.co/compendious/EMNIST-OCR-WEIGHTS/
+The file is EMNIST_CNN.pth
+Go here to download directly: 
+              https://huggingface.co/compendious/EMNIST-OCR-WEIGHTS/resolve/main/EMNIST_CNN.pth?download=true
+
+"""
 
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
 
 class ConvBlock(nn.Module):
-    """Convolutional block: 2 conv layers, ReLU, MaxPool"""
+    """Convolutional block: 2 conv layers, LeakyReLU, MaxPool"""
     def __init__(self, in_channels, out_channels, padding=1, pool_kernel=2, pool_stride=2):
         super(ConvBlock, self).__init__()
         self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=padding)
         self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=padding)
         self.pool = nn.MaxPool2d(kernel_size=pool_kernel, stride=pool_stride)
+    
     def forward(self, x):
-        x = F.relu(self.conv1(x))
-        x = F.relu(self.conv2(x))
+        # CHANGE 1: LeakyReLU prevents "dead neurons," critical for 62-class differentiation.
+        x = F.leaky_relu(self.conv1(x), negative_slope=0.1)
+        x = F.leaky_relu(self.conv2(x), negative_slope=0.1)
         x = self.pool(x)
         return x
 
@@ -35,41 +38,58 @@ class EMNIST_VGG(nn.Module):
     def __init__(self, num_classes=62):
         super(EMNIST_VGG, self).__init__()
         
-        # The two blocks
+        # The four blocks
         self.conv1 = ConvBlock(in_channels=1, out_channels=32, pool_kernel=2, pool_stride=2)
         self.bn1 = nn.BatchNorm2d(32)
+        
         self.conv2 = ConvBlock(in_channels=32, out_channels=64, pool_stride=2)
         self.bn2 = nn.BatchNorm2d(64)
+        
         self.conv3 = ConvBlock(in_channels=64, out_channels=128, pool_stride=1)
         self.bn3 = nn.BatchNorm2d(128)
+        
         self.conv4 = ConvBlock(in_channels=128, out_channels=256, pool_stride=1)
         self.bn4 = nn.BatchNorm2d(256)
 
+        # CHANGE 2: Spatial Dropout. 
+        # Drops entire feature maps to force redundancy, unlike standard dropout.
+        self.spatial_drop = nn.Dropout2d(p=0.1)
+
         # Flatten layer (no parameters needed, only reshaping)
         self.flatten = nn.Flatten()
 
-        # (Since the Dense layers just take flat inputs)
-
         # Two fully-connected layers
 
-        # For the first layer, notice that, due to the stride and pool sizes, we need to adjust the input size to 256 * 5 * 5
-        self.fc1 = nn.Linear(256 * 5 * 5, 256)
+        # CHANGE 3: Expanded Width (256 -> 512). 
+        # Your Keras model used 512; 256 is a bottleneck for 62 classes.
+        self.fc1 = nn.Linear(256 * 5 * 5, 512)
+        self.bn_fc = nn.BatchNorm1d(512) # Added BN to the dense layer for stability
         self.dropout = nn.Dropout(p=0.5)
 
         # Classifier
-        self.fc2 = nn.Linear(256, num_classes)
+        self.fc2 = nn.Linear(512, num_classes)
 
     def forward(self, x):
         x = self.conv1(x)
         x = self.bn1(x)
+        
         x = self.conv2(x)
         x = self.bn2(x)
+        x = self.spatial_drop(x) # Apply mild spatial regularization
+        
         x = self.conv3(x)
         x = self.bn3(x)
+        x = self.spatial_drop(x) 
+        
         x = self.conv4(x)
         x = self.bn4(x)
+        
         x = self.flatten(x)
-        x = F.relu(self.fc1(x))
+        
+        # Dense Pass
+        x = self.fc1(x)
+        x = self.bn_fc(x)
+        x = F.leaky_relu(x, negative_slope=0.1)
         x = self.dropout(x)
         x = self.fc2(x)
         return x

frontend/main.js

@@ -46,9 +46,6 @@ function performPrediction() {
         // console.log("Input Array: ", inputArray);
         // console.log("Temp: ", temp);
 
-        // (Preview drawing removed — bar graph will visualize predictions)
-
-        // Send to server with error handling (non-blocking)
         fetch("/predict", {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -85,7 +82,7 @@ canvas.addEventListener("mousedown", (e) => {
     ctx.beginPath();
     ctx.moveTo(x, y);
     
-    if (e.button === 2) { // Right click
+    if (e.button === 2) { // Right click erases
         erase = true;
         ctx.strokeStyle = "white";
     } else {