Upload folder using huggingface_hub

README.md

@@ -0,0 +1,40 @@
+# Hugging Face Deployment Checklist
+
+Welcome to the `hf_deployment` folder! This directory contains everything needed to wrap your `ChronoGridFusionNet` model into a native Hugging Face model and push it to the Hub.
+
+## What is in here?
+1. `configuration_chronogrid.py`: The Hugging Face config class (stores hyperparameters like image size and num classes).
+2. `modeling_chronogrid.py`: Your PyTorch architecture, wrapped in `PreTrainedModel`.
+3. `push_to_hf.py`: The script you will run to package everything and push it to your Hugging Face account.
+
+## What you need to do BEFORE publishing:
+
+### 1. Authenticate with Hugging Face
+You need to be logged into your Hugging Face account on your terminal so the script can push files.
+- Open your terminal and run: `huggingface-cli login`
+- Paste your Hugging Face **Access Token** (you can generate one with `write` permissions in your account Settings -> Access Tokens).
+
+### 2. Update the `push_to_hf.py` script
+Open `push_to_hf.py` and modify two things:
+1.  **Line 13:** Change `repo_id = "your-username/chronogrid-fusionnet"` to your actual HF username and desired repo name.
+2.  **Line 21:** Ensure `model_path = '../models/Chronogrid_fold5.pt'` points to the exact `.pt` file you saved after training.
+
+### 3. Provide your Preprocessing logic
+Right now, if someone downloads your model, they won't know how to turn a raw grid signal into a 227x227 image.
+- **Action:** Create a `preprocess.py` file in this folder. It should contain whatever Python code you used (like S-Transform functions) to generate the `.jpg` heatmaps you used for training. 
+- You will upload this `preprocess.py` file manually to your Hugging Face repo later, or add an `api.upload_file(...)` line in `push_to_hf.py` for it.
+
+### 4. Run the Push Script!
+When you are ready:
+```bash
+cd /Users/sanathbs/02_College_UG/IEEE-9bus/hf_deployment
+pip install transformers huggingface_hub
+python push_to_hf.py
+```
+
+### 5. Finalize the Model Card (README.md)
+Once the model is pushed, go to the model's page on huggingface.co and edit the `README.md` (Model Card).
+You should explain:
+- **What this is:** Fault detection for WSCC 9-Bus system.
+- **How to use it:** Provide a small code snippet showing how to use `AutoModel.from_pretrained(...)`.
+- **Metrics:** Paste your final test accuracy and confusion matrix stats.

config.json

@@ -0,0 +1,10 @@
+{
+  "architectures": [
+    "ChronoGridModelForSequenceClassification"
+  ],
+  "dtype": "float32",
+  "img_size": 227,
+  "model_type": "chronogrid",
+  "num_classes": 11,
+  "transformers_version": "5.12.1"
+}

configuration_chronogrid.py

@@ -0,0 +1,14 @@
+from transformers import PretrainedConfig
+
+class ChronoGridConfig(PretrainedConfig):
+    model_type = "chronogrid"
+
+    def __init__(
+        self,
+        img_size=227,
+        num_classes=11,
+        **kwargs
+    ):
+        self.img_size = img_size
+        self.num_classes = num_classes
+        super().__init__(**kwargs)

model.safetensors

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

modeling_chronogrid.py

@@ -0,0 +1,61 @@
+import torch
+import torch.nn as nn
+from transformers import PreTrainedModel
+from configuration_chronogrid import ChronoGridConfig
+
+def make_cnn_backbone(img_size):
+    return nn.Sequential(
+        # Block 1 — kernel-3 (captures short transients)
+        nn.Conv1d(img_size, 64,  kernel_size=3, padding=1),
+        nn.BatchNorm1d(64), nn.ReLU(),
+        # Block 2 — kernel-5 (captures broader waveform distortions)
+        nn.Conv1d(64,  128, kernel_size=5, padding=2),
+        nn.BatchNorm1d(128), nn.ReLU(), nn.MaxPool1d(2),  # → [B, 128, 113]
+        # Block 3 — kernel-3 (deep feature abstraction)
+        nn.Conv1d(128, 256, kernel_size=3, padding=1),
+        nn.BatchNorm1d(256), nn.ReLU(), nn.MaxPool1d(2),  # → [B, 256, 56]
+    )
+
+class _ScaledDotAttn(nn.Module):
+    '''Scaled dot-product multi-head self-attention with residual + LayerNorm.'''
+    def __init__(self, d_model=256, num_heads=8, dropout=0.1):
+        super().__init__()
+        self.mha  = nn.MultiheadAttention(d_model, num_heads, dropout=dropout,
+                                           batch_first=True)
+        self.norm = nn.LayerNorm(d_model)
+
+    def forward(self, x):
+        out, w = self.mha(x, x, x, need_weights=True, average_attn_weights=True)
+        return self.norm(x + out), w          # w: [B, seq, seq]
+
+class ChronoGridModelForSequenceClassification(PreTrainedModel):
+    config_class = ChronoGridConfig
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_classes = config.num_classes
+        
+        # 1. Initialize your architecture
+        self.cnn = make_cnn_backbone(config.img_size)
+        self.bilstm = nn.LSTM(256, 128, num_layers=2, batch_first=True, bidirectional=True, dropout=0.3)
+        self.attention = _ScaledDotAttn(d_model=256, num_heads=8)
+        self.head = nn.Sequential(
+            nn.Dropout(0.3),
+            nn.Linear(256, 128), nn.ReLU(),
+            nn.Linear(128, self.num_classes),
+        )
+
+    def forward(self, x, labels=None):
+        # x shape: [B, 227, 227]
+        x = self.cnn(x).permute(0, 2, 1)     
+        x, _ = self.bilstm(x)                 
+        x, attn_w = self.attention(x)         
+        feat = x.mean(dim=1)                  
+        logits = self.head(feat)
+        
+        loss = None
+        if labels is not None:
+            loss_fct = nn.CrossEntropyLoss()
+            loss = loss_fct(logits.view(-1, self.num_classes), labels.view(-1))
+
+        return (loss, logits) if loss is not None else (logits,)