Upload folder using huggingface_hub

README.md

@@ -1,40 +1,64 @@
-# 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
+---
+language:
+- en
+license: apache-2.0
+tags:
+- pytorch
+- timeseries
+- power-systems
+- fault-detection
+- computer-vision
+- s-transform
+pipeline_tag: image-classification
+---
+
+# ChronoGrid FusionNet: IEEE 9-Bus Fault Detection
+
+## Model Description
+ChronoGrid FusionNet is a highly specialized deep learning architecture designed for the classification of electrical transmission line faults in the IEEE 9-Bus (WSCC) test system. It processes time-series electrical signals that have been transformed into 2D S-Transform heatmaps to detect and classify 11 different fault conditions.
+
+The architecture is a fusion of three core components:
+1. **1D CNN Backbone:** Extracts multi-band temporal distortions from the frequency dimension.
+2. **BiLSTM Sequence Modeler:** Captures bidirectional evolution of the electrical transient over time.
+3. **Self-Attention Mechanism:** Dynamically focuses on the most critical time-steps of the fault clearing process.
+
+## Intended Uses
+- **Academic Research:** Benchmarking fault detection algorithms on power systems.
+- **Power System Analysis:** Classifying Single Line to Ground (SLG), Line to Line (LL), Double Line to Ground (LLG), and Three Phase (LLL) faults.
+
+## How to Get Started with the Model
+Because this is a custom PyTorch architecture, you must pass `trust_remote_code=True` when loading the model from Hugging Face.
+
+```python
+import torch
+from transformers import AutoModel, AutoConfig
+from PIL import Image
+import numpy as np
+
+# 1. Load the model and configuration
+repo_id = "Sanath2709/chronogrid-fusionnet"
+config = AutoConfig.from_pretrained(repo_id, trust_remote_code=True)
+model = AutoModel.from_pretrained(repo_id, config=config, trust_remote_code=True)
+model.eval()
+
+# 2. Preprocess an S-Transform Heatmap Image
+image_path = "path/to/your/s_transform_heatmap.jpg"
+img = Image.open(image_path).convert('L').resize((227, 227))
+arr = np.array(img, dtype=np.float32) / 255.0
+x = torch.tensor(arr).unsqueeze(0)
+
+# 3. Run Inference
+with torch.no_grad():
+    logits = model(x)[0]
+    probs = torch.softmax(logits, dim=1).squeeze().numpy()
+    
+# 4. Display Results
+FAULT_CLASSES = ['AG','BG','CG','AB','AC','BC','ABG','ACG','BCG','ABCG','NF']
+print("Predictions:", {FAULT_CLASSES[i]: float(probs[i]) for i in range(len(FAULT_CLASSES))})
 ```
 
-### 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.
+## Training Data
+The model was trained on synthetic data generated using the **WSCC 9-Bus system** in Simulink, simulating various fault locations, inception angles, and loads. The raw voltage and current signals were converted into 227x227 time-frequency heatmaps using the discrete S-Transform.
+
+## License & Citation
+If you use this model in your research, please refer to the attached manuscript or citation details once published.