Update model card for progressive resizing experiment

README.md

@@ -1,104 +1,82 @@
----
 license: mit
-language:
-- en
+language: en
 tags:
-- image-classification
-- medical-imaging
-- diabetic-retinopathy
-- resnet
-- sih-2025
----
 
-Fine-Tuned ResNet50 for Diabetic Retinopathy Grading
-This is a ResNet50 model fine-tuned for the task of Diabetic Retinopathy (DR) grading based on fundus images. The model classifies a given retina scan into one of five severity grades, following the International Clinical Diabetic Retinopathy scale.
+image-classification
 
-This model was trained as a prototype for the Smart India Hackathon (SIH) 2025.
+medical-imaging
 
-Model Details
-Model Architecture: ResNet50
+diabetic-retinopathy
 
-Pre-trained on: ImageNet-1K (V1)
+resnet
 
-Fine-tuned on: IDRiD (Indian Diabetic Retinopathy Image Dataset)
+fine-tuning
 
-Task: Image Classification
+progressive-resizing
 
-Classes (5):
+sih-2025
+base_model: microsoft/resnet-50
 
-Grade 0: No DR
+Progressively Resized ResNet50 for Diabetic Retinopathy Grading
+This repository contains a collection of ResNet50 models fine-tuned for classifying diabetic retinopathy severity. These models are the result of an advanced, multi-stage progressive resizing experiment.
 
-Grade 1: Mild
+The strategy involves starting with a fine-tuned model and continuing to train it on progressively higher image resolutions. This allows the model to first learn general features on smaller images and then refine its understanding by learning fine-grained details from larger, higher-quality images.
 
-Grade 2: Moderate
+Model Versions
+This repository contains several model checkpoints, each representing the best-performing model at a specific resolution stage. The final model from the highest resolution stage represents the culmination of this experiment.
 
-Grade 3: Severe
+best_model_384px.pth: Fine-tuned on 384x384 images.
 
-Grade 4: Proliferative DR
+best_model_512px.pth: Fine-tuned on 512x512 images.
 
-How to Use
-To use this model, you need to have torch and torchvision installed.
+best_model_768px.pth: Fine-tuned on 768x768 images.
 
-import torch
-import torchvision
-from torchvision import models, transforms
-from PIL import Image
-
-# 1. Define the model architecture
-model = models.resnet50(weights=None)
-num_ftrs = model.fc.in_features
-model.fc = torch.nn.Linear(num_ftrs, 5) # 5 classes
-
-# 2. Load the fine-tuned weights from the Hub
-weights_path = hf_hub_download(repo_id="Arko007/Diabetic-Retinopathy", filename="resnet50_finetuned_retinopathy.pth")
-model.load_state_dict(torch.load(weights_path, map_location='cpu'))
-model.eval()
-
-# 3. Create the same data transform used for validation/testing
-transform = transforms.Compose([
-    transforms.Resize((224, 224)),
-    transforms.ToTensor(),
-    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-])
-
-# 4. Load an image and make a prediction
-# Make sure to replace 'path/to/your/image.jpg'
-img = Image.open('path/to/your/image.jpg').convert('RGB')
-img_t = transform(img)
-batch_t = torch.unsqueeze(img_t, 0)
-
-with torch.no_grad():
-    output = model(batch_t)
-    _, predicted_idx = torch.max(output, 1)
+best_model_1024px.pth: The final model, fine-tuned on 1024x1024 images.
 
-class_names = ['No DR', 'Mild', 'Moderate', 'Severe', 'Proliferative DR']
-print(f"Prediction: {class_names[predicted_idx.item()]}")
+Performance (Final Model)
+The final model's performance was evaluated on the official test set from the IDRiD dataset.
 
+Classification Report
+               precision    recall  f1-score   support
 
-Evaluation Results
-The model was evaluated on a held-out test set from the IDRiD dataset.
+      Grade 0       0.76      0.65      0.70        34
+      Grade 1       0.11      0.40      0.17         5
+      Grade 2       0.59      0.59      0.59        32
+      Grade 3       0.64      0.47      0.55        19
+      Grade 4       0.40      0.31      0.35        13
 
-Confusion Matrix:
+     accuracy                           0.54       103
+    macro avg       0.50      0.48      0.47       103
+ weighted avg       0.61      0.54      0.57       103
 
-(Upload your confusion_matrix_resnet50.png file here)
+Confusion Matrix
+         Grade 0  Grade 1  Grade 2  Grade 3  Grade 4
+Grade 0       22       10        2        0        0
+Grade 1        2        2        1        0        0
+Grade 2        4        4       19        3        2
+Grade 3        0        2        4        9        4
+Grade 4        1        0        6        2        4
 
-Classification Report:
+How to Use a Specific Model
+You can load any of the model versions using PyTorch. Make sure to use the correct filename.
 
-[PASTE THE CLASSIFICATION REPORT FROM YOUR TRAINING SCRIPT'S FINAL OUTPUT HERE]
-
-Training Procedure
-The model was trained on an NVIDIA A100 GPU using a two-phase transfer learning strategy:
-
-Head Training: The pre-trained ResNet50 backbone was frozen, and only the new classification head was trained for 15 epochs.
-
-Fine-Tuning: The entire model was unfrozen and trained for an additional 30 epochs with a much smaller learning rate to fine-tune the deep features.
-
-Key hyperparameters:
+import torch
+from torchvision import models
+from huggingface_hub import hf_hub_download
 
-Image Size: 224x224
+# 1. Define the model architecture
+model = models.resnet50(weights=None)
+model.fc = torch.nn.Linear(model.fc.in_features, 5) # 5 classes
 
-Batch Size: 128
+# 2. Load the fine-tuned weights for the desired resolution
+weights_path = hf_hub_download(
+    repo_id="Arko007/Diabetic-Retinopathy",
+    filename="best_model_1024px.pth" # Change this to load other versions
+)
+model.load_state_dict(torch.load(weights_path, map_location='cpu'))
+model.eval()
 
-Optimizer: Adam
+# 3. Preprocess your image using the correct size for the model you loaded
+# ...
 
-Loss Function: Cross-Entropy Loss with class weights to handle imbalance.
+Developed by: Arko007 for SIH 2025.