Add files using upload-large-folder tool

.gitattributes

@@ -1,35 +1,5 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
 *.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.hfignore

@@ -0,0 +1,6 @@
+venv/
+__pycache__/
+*.pyc
+.DS_Store
+*.ipynb_checkpoints
+

README.md

@@ -0,0 +1,2 @@
+# ai-eye-disease-detection
+# ai-eye-disease-detection

backup.ipynb

@@ -0,0 +1,765 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "30e80151",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#!/usr/bin/env python3\n",
+    "\"\"\"\n",
+    "Advanced Eye Disease Detection Training Script - Fixed Version\n",
+    "\"\"\"\n",
+    "\n",
+    "import os\n",
+    "import sys\n",
+    "import json\n",
+    "import numpy as np\n",
+    "import cv2\n",
+    "from pathlib import Path\n",
+    "from tqdm import tqdm\n",
+    "import matplotlib.pyplot as plt\n",
+    "from collections import Counter\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "# Check if required packages are available\n",
+    "try:\n",
+    "    import tensorflow as tf\n",
+    "    from tensorflow import keras\n",
+    "    from tensorflow.keras import layers\n",
+    "    from tensorflow.keras.applications import EfficientNetB3, ResNet152V2, DenseNet201\n",
+    "    from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+    "    from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint\n",
+    "    from sklearn.model_selection import train_test_split, StratifiedKFold\n",
+    "    from sklearn.preprocessing import LabelEncoder\n",
+    "    from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
+    "    from sklearn.utils.class_weight import compute_class_weight\n",
+    "    import seaborn as sns\n",
+    "    from imblearn.over_sampling import SMOTE\n",
+    "    from imblearn.combine import SMOTETomek\n",
+    "    # Optional: Kaggle API (install if needed)\n",
+    "    try:\n",
+    "        from kaggle.api.kaggle_api_extended import KaggleApi\n",
+    "        KAGGLE_AVAILABLE = True\n",
+    "    except ImportError:\n",
+    "        KAGGLE_AVAILABLE = False\n",
+    "        print(\"⚠️  Kaggle API not available. Manual dataset download required.\")\n",
+    "except ImportError as e:\n",
+    "    print(f\"Missing required package: {e}\")\n",
+    "    print(\"Please run: pip install tensorflow opencv-python scikit-learn matplotlib tqdm seaborn imbalanced-learn\")\n",
+    "    sys.exit(1)\n",
+    "\n",
+    "print(\"✅ All required packages are available!\")\n",
+    "\n",
+    "class AdvancedFundusPreprocessor:\n",
+    "    \"\"\"Advanced preprocessing pipeline for fundus images\"\"\"\n",
+    "    \n",
+    "    def __init__(self, image_size=(224, 224)):\n",
+    "        self.image_size = image_size\n",
+    "        self.setup_clahe_variants()\n",
+    "    \n",
+    "    def setup_clahe_variants(self):\n",
+    "        \"\"\"Setup multiple CLAHE variants for different image characteristics\"\"\"\n",
+    "        self.clahe_normal = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))\n",
+    "        self.clahe_aggressive = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(4,4))\n",
+    "        self.clahe_gentle = cv2.createCLAHE(clipLimit=1.5, tileGridSize=(16,16))\n",
+    "    \n",
+    "    def advanced_preprocess_image(self, image_path):\n",
+    "        \"\"\"Advanced preprocessing with multiple enhancement techniques\"\"\"\n",
+    "        try:\n",
+    "            # Read image\n",
+    "            image = cv2.imread(str(image_path))\n",
+    "            if image is None:\n",
+    "                print(f\"⚠️ Could not read image: {image_path}\")\n",
+    "                return None\n",
+    "            \n",
+    "            # Convert to RGB\n",
+    "            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "            \n",
+    "            # Apply advanced preprocessing pipeline\n",
+    "            image = self.enhance_fundus_image(image)\n",
+    "            \n",
+    "            # Resize with high-quality interpolation\n",
+    "            image = cv2.resize(image, self.image_size, interpolation=cv2.INTER_LANCZOS4)\n",
+    "            \n",
+    "            # Normalize to [0, 1]\n",
+    "            image = image.astype(np.float32) / 255.0\n",
+    "            \n",
+    "            return image\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error processing {image_path}: {e}\")\n",
+    "            return None\n",
+    "    \n",
+    "    def enhance_fundus_image(self, image):\n",
+    "        \"\"\"Advanced fundus-specific enhancement techniques\"\"\"\n",
+    "        # Apply CLAHE to LAB color space\n",
+    "        lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)\n",
+    "        l_channel = lab[:,:,0]\n",
+    "        \n",
+    "        # Apply CLAHE to L channel\n",
+    "        l_clahe = self.clahe_normal.apply(l_channel)\n",
+    "        lab[:,:,0] = l_clahe\n",
+    "        image_enhanced = cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)\n",
+    "        \n",
+    "        # Green channel enhancement (important for fundus images)\n",
+    "        green_enhanced = cv2.equalizeHist(image_enhanced[:,:,1])\n",
+    "        image_enhanced[:,:,1] = green_enhanced\n",
+    "        \n",
+    "        # Apply gamma correction\n",
+    "        image_enhanced = self.adjust_gamma(image_enhanced, gamma=1.2)\n",
+    "        \n",
+    "        return image_enhanced\n",
+    "    \n",
+    "    def adjust_gamma(self, image, gamma=1.0):\n",
+    "        \"\"\"Apply gamma correction\"\"\"\n",
+    "        inv_gamma = 1.0 / gamma\n",
+    "        table = np.array([((i / 255.0) ** inv_gamma) * 255 for i in np.arange(0, 256)]).astype(\"uint8\")\n",
+    "        return cv2.LUT(image, table)\n",
+    "\n",
+    "class AdvancedEnsembleModel:\n",
+    "    \"\"\"Advanced ensemble model combining multiple architectures\"\"\"\n",
+    "    \n",
+    "    def __init__(self, image_size=(224, 224), num_classes=7):\n",
+    "        self.image_size = image_size\n",
+    "        self.num_classes = num_classes\n",
+    "        \n",
+    "    def create_efficientnet_model(self):\n",
+    "        \"\"\"Create EfficientNetB3 based model\"\"\"\n",
+    "        base_model = EfficientNetB3(\n",
+    "            weights='imagenet',\n",
+    "            include_top=False,\n",
+    "            input_shape=(*self.image_size, 3)\n",
+    "        )\n",
+    "        \n",
+    "        # Fine-tune top layers\n",
+    "        base_model.trainable = True\n",
+    "        for layer in base_model.layers[:-30]:\n",
+    "            layer.trainable = False\n",
+    "        \n",
+    "        inputs = keras.Input(shape=(*self.image_size, 3))\n",
+    "        \n",
+    "        # Base model\n",
+    "        x = base_model(inputs, training=False)\n",
+    "        \n",
+    "        # Advanced pooling\n",
+    "        gap = layers.GlobalAveragePooling2D()(x)\n",
+    "        gmp = layers.GlobalMaxPooling2D()(x)\n",
+    "        x = layers.Concatenate()([gap, gmp])\n",
+    "        \n",
+    "        # Advanced head\n",
+    "        x = layers.BatchNormalization()(x)\n",
+    "        x = layers.Dropout(0.5)(x)\n",
+    "        \n",
+    "        x = layers.Dense(512, activation='relu')(x)\n",
+    "        x = layers.BatchNormalization()(x)\n",
+    "        x = layers.Dropout(0.4)(x)\n",
+    "        \n",
+    "        x = layers.Dense(256, activation='relu')(x)\n",
+    "        x = layers.BatchNormalization()(x)\n",
+    "        x = layers.Dropout(0.3)(x)\n",
+    "        \n",
+    "        outputs = layers.Dense(self.num_classes, activation='softmax')(x)\n",
+    "        \n",
+    "        return keras.Model(inputs, outputs, name='EfficientNetB3_Model')\n",
+    "    \n",
+    "    def create_resnet_model(self):\n",
+    "        \"\"\"Create ResNet152V2 based model\"\"\"\n",
+    "        base_model = ResNet152V2(\n",
+    "            weights='imagenet',\n",
+    "            include_top=False,\n",
+    "            input_shape=(*self.image_size, 3)\n",
+    "        )\n",
+    "        \n",
+    "        base_model.trainable = True\n",
+    "        for layer in base_model.layers[:-40]:\n",
+    "            layer.trainable = False\n",
+    "        \n",
+    "        inputs = keras.Input(shape=(*self.image_size, 3))\n",
+    "        \n",
+    "        x = base_model(inputs, training=False)\n",
+    "        \n",
+    "        # Global pooling\n",
+    "        x = layers.GlobalAveragePooling2D()(x)\n",
+    "        x = layers.BatchNormalization()(x)\n",
+    "        x = layers.Dropout(0.5)(x)\n",
+    "        \n",
+    "        x = layers.Dense(512, activation='relu')(x)\n",
+    "        x = layers.BatchNormalization()(x)\n",
+    "        x = layers.Dropout(0.4)(x)\n",
+    "        \n",
+    "        outputs = layers.Dense(self.num_classes, activation='softmax')(x)\n",
+    "        \n",
+    "        return keras.Model(inputs, outputs, name='ResNet152V2_Model')\n",
+    "    \n",
+    "    def create_densenet_model(self):\n",
+    "        \"\"\"Create DenseNet201 based model\"\"\"\n",
+    "        base_model = DenseNet201(\n",
+    "            weights='imagenet',\n",
+    "            include_top=False,\n",
+    "            input_shape=(*self.image_size, 3)\n",
+    "        )\n",
+    "        \n",
+    "        base_model.trainable = True\n",
+    "        for layer in base_model.layers[:-50]:\n",
+    "            layer.trainable = False\n",
+    "        \n",
+    "        inputs = keras.Input(shape=(*self.image_size, 3))\n",
+    "        \n",
+    "        x = base_model(inputs, training=False)\n",
+    "        \n",
+    "        x = layers.GlobalAveragePooling2D()(x)\n",
+    "        x = layers.BatchNormalization()(x)\n",
+    "        x = layers.Dropout(0.5)(x)\n",
+    "        \n",
+    "        x = layers.Dense(512, activation='relu')(x)\n",
+    "        x = layers.BatchNormalization()(x)\n",
+    "        x = layers.Dropout(0.4)(x)\n",
+    "        \n",
+    "        outputs = layers.Dense(self.num_classes, activation='softmax')(x)\n",
+    "        \n",
+    "        return keras.Model(inputs, outputs, name='DenseNet201_Model')\n",
+    "\n",
+    "class AdvancedFundusTrainer:\n",
+    "    def __init__(self):\n",
+    "        self.dataset_path = \"fundus_dataset\"\n",
+    "        self.model_path = \"models\"\n",
+    "        self.image_size = (224, 224)\n",
+    "        self.batch_size = 16\n",
+    "        \n",
+    "        # Initialize components\n",
+    "        self.preprocessor = AdvancedFundusPreprocessor(self.image_size)\n",
+    "        self.ensemble_model = AdvancedEnsembleModel(self.image_size)\n",
+    "        \n",
+    "        # Create directories\n",
+    "        Path(self.model_path).mkdir(exist_ok=True)\n",
+    "        Path(\"logs\").mkdir(exist_ok=True)\n",
+    "        Path(\"plots\").mkdir(exist_ok=True)\n",
+    "    \n",
+    "    def download_dataset(self):\n",
+    "        \"\"\"Download the Kaggle dataset\"\"\"\n",
+    "        if not KAGGLE_AVAILABLE:\n",
+    "            print(\"❌ Kaggle API not available. Please download dataset manually.\")\n",
+    "            print(\"Dataset: https://www.kaggle.com/datasets/linchundan/fundusimage1000\")\n",
+    "            print(f\"Extract to: {self.dataset_path}/\")\n",
+    "            return False\n",
+    "            \n",
+    "        print(\"📥 Downloading dataset from Kaggle...\")\n",
+    "        \n",
+    "        try:\n",
+    "            api = KaggleApi()\n",
+    "            api.authenticate()\n",
+    "            \n",
+    "            api.dataset_download_files(\n",
+    "                \"linchundan/fundusimage1000\",\n",
+    "                path=self.dataset_path,\n",
+    "                unzip=True\n",
+    "            )\n",
+    "            print(\"✅ Dataset downloaded successfully!\")\n",
+    "            return True\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            print(f\"❌ Download failed: {e}\")\n",
+    "            print(\"Please download dataset manually and extract to fundus_dataset/\")\n",
+    "            return False\n",
+    "    \n",
+    "    def load_dataset(self):\n",
+    "        \"\"\"Load dataset with preprocessing - Fixed Version\"\"\"\n",
+    "        print(\"📁 Loading dataset...\")\n",
+    "        \n",
+    "        images = []\n",
+    "        labels = []\n",
+    "        \n",
+    "        dataset_path = Path(self.dataset_path)\n",
+    "        \n",
+    "        # Debug: Print directory structure\n",
+    "        print(f\"\\nDirectory structure at {dataset_path}:\")\n",
+    "        for item in dataset_path.rglob('*'):\n",
+    "            print(f\"  {item.relative_to(dataset_path)}\")\n",
+    "        \n",
+    "        # Check for common dataset structures\n",
+    "        possible_paths = [\n",
+    "            dataset_path,\n",
+    "            dataset_path / \"1000images\",\n",
+    "            dataset_path / \"fundusimage1000\",\n",
+    "            dataset_path / \"images\",\n",
+    "            dataset_path / \"data\"\n",
+    "        ]\n",
+    "        \n",
+    "        actual_path = None\n",
+    "        for path in possible_paths:\n",
+    "            if path.exists():\n",
+    "                print(f\"\\nChecking path: {path}\")\n",
+    "                # Count image files in this path\n",
+    "                image_count = sum(1 for _ in path.rglob('*.[jJ][pP][gG]')) + \\\n",
+    "                             sum(1 for _ in path.rglob('*.[jJ][pP][eE][gG]')) + \\\n",
+    "                             sum(1 for _ in path.rglob('*.[pP][nN][gG]'))\n",
+    "                print(f\"  Found {image_count} images\")\n",
+    "                if image_count > 0:\n",
+    "                    actual_path = path\n",
+    "                    break\n",
+    "        \n",
+    "        if actual_path is None:\n",
+    "            print(f\"\\n❌ No valid dataset found in {dataset_path}\")\n",
+    "            print(\"Please ensure the dataset contains image files in one of these structures:\")\n",
+    "            print(\"1. Directly in fundus_dataset/\")\n",
+    "            print(\"2. In fundus_dataset/1000images/\")\n",
+    "            print(\"3. In fundus_dataset/fundusimage1000/\")\n",
+    "            print(\"4. In subdirectories by class\")\n",
+    "            return None, None, None\n",
+    "        \n",
+    "        print(f\"\\n✅ Using dataset path: {actual_path}\")\n",
+    "        \n",
+    "        # Find all image files\n",
+    "        image_files = list(actual_path.rglob('*.[jJ][pP][gG]')) + \\\n",
+    "                     list(actual_path.rglob('*.[jJ][pP][eE][gG]')) + \\\n",
+    "                     list(actual_path.rglob('*.[pP][nN][gG]'))\n",
+    "        \n",
+    "        if not image_files:\n",
+    "            print(\"❌ No image files found in the dataset directory\")\n",
+    "            return None, None, None\n",
+    "        \n",
+    "        print(f\"\\nFound {len(image_files)} image files\")\n",
+    "        \n",
+    "        # Process images\n",
+    "        class_counts = Counter()\n",
+    "        for image_file in tqdm(image_files, desc=\"Processing images\"):\n",
+    "            processed_image = self.preprocessor.advanced_preprocess_image(image_file)\n",
+    "            if processed_image is not None:\n",
+    "                images.append(processed_image)\n",
+    "                # Use parent directory name as class label\n",
+    "                class_label = image_file.parent.name\n",
+    "                if class_label == actual_path.name:  # If image is in root directory\n",
+    "                    class_label = \"unknown\"\n",
+    "                labels.append(class_label)\n",
+    "                class_counts[class_label] += 1\n",
+    "        \n",
+    "        if len(images) == 0:\n",
+    "            print(\"❌ No images loaded successfully\")\n",
+    "            return None, None, None\n",
+    "        \n",
+    "        # Print class distribution\n",
+    "        print(\"\\nClass distribution:\")\n",
+    "        for class_name, count in class_counts.most_common():\n",
+    "            print(f\"  {class_name}: {count} images\")\n",
+    "        \n",
+    "        # Convert to numpy arrays\n",
+    "        X = np.array(images)\n",
+    "        y = np.array(labels)\n",
+    "        \n",
+    "        # Encode labels\n",
+    "        label_encoder = LabelEncoder()\n",
+    "        y_encoded = label_encoder.fit_transform(y)\n",
+    "        \n",
+    "        print(f\"\\n✅ Dataset loaded: {len(X)} images, {len(label_encoder.classes_)} classes\")\n",
+    "        \n",
+    "        return X, y_encoded, label_encoder.classes_\n",
+    "    \n",
+    "    def balance_dataset(self, X, y):\n",
+    "        \"\"\"Balance dataset using SMOTE\"\"\"\n",
+    "        print(\"⚖️ Balancing dataset...\")\n",
+    "        \n",
+    "        try:\n",
+    "            # Reshape for SMOTE\n",
+    "            X_flattened = X.reshape(X.shape[0], -1)\n",
+    "            \n",
+    "            # Apply SMOTE\n",
+    "            smote = SMOTE(random_state=42, k_neighbors=min(5, len(np.unique(y))-1))\n",
+    "            X_balanced, y_balanced = smote.fit_resample(X_flattened, y)\n",
+    "            \n",
+    "            # Reshape back\n",
+    "            X_balanced = X_balanced.reshape(-1, *self.image_size, 3)\n",
+    "            \n",
+    "            print(f\"Dataset balanced: {len(X_balanced)} samples\")\n",
+    "            return X_balanced, y_balanced\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            print(f\"SMOTE failed: {e}, using original dataset\")\n",
+    "            return X, y\n",
+    "    \n",
+    "    def create_data_generators(self, X_train, y_train, X_val, y_val):\n",
+    "        \"\"\"Create data generators with augmentation\"\"\"\n",
+    "        # Training data generator with augmentation\n",
+    "        train_datagen = ImageDataGenerator(\n",
+    "            rotation_range=20,\n",
+    "            width_shift_range=0.15,\n",
+    "            height_shift_range=0.15,\n",
+    "            horizontal_flip=True,\n",
+    "            vertical_flip=True,\n",
+    "            zoom_range=0.15,\n",
+    "            brightness_range=[0.8, 1.2],\n",
+    "            shear_range=0.1,\n",
+    "            fill_mode='reflect'\n",
+    "        )\n",
+    "        \n",
+    "        # Validation data generator (no augmentation)\n",
+    "        val_datagen = ImageDataGenerator()\n",
+    "        \n",
+    "        train_generator = train_datagen.flow(\n",
+    "            X_train, y_train, \n",
+    "            batch_size=self.batch_size,\n",
+    "            shuffle=True\n",
+    "        )\n",
+    "        \n",
+    "        val_generator = val_datagen.flow(\n",
+    "            X_val, y_val,\n",
+    "            batch_size=self.batch_size,\n",
+    "            shuffle=False\n",
+    "        )\n",
+    "        \n",
+    "        return train_generator, val_generator\n",
+    "    \n",
+    "    def create_ensemble(self, num_classes):\n",
+    "        \"\"\"Create ensemble model\"\"\"\n",
+    "        print(\"🧠 Creating ensemble model...\")\n",
+    "        \n",
+    "        # Create individual models\n",
+    "        efficientnet_model = self.ensemble_model.create_efficientnet_model()\n",
+    "        resnet_model = self.ensemble_model.create_resnet_model()\n",
+    "        densenet_model = self.ensemble_model.create_densenet_model()\n",
+    "        \n",
+    "        # Update number of classes for each model\n",
+    "        self.ensemble_model.num_classes = num_classes\n",
+    "        \n",
+    "        # Compile models\n",
+    "        optimizer = keras.optimizers.Adam(learning_rate=1e-4)\n",
+    "        \n",
+    "        for model in [efficientnet_model, resnet_model, densenet_model]:\n",
+    "            model.compile(\n",
+    "                optimizer=optimizer,\n",
+    "                loss='sparse_categorical_crossentropy',\n",
+    "                metrics=['accuracy']\n",
+    "            )\n",
+    "        \n",
+    "        models = [efficientnet_model, resnet_model, densenet_model]\n",
+    "        model_names = ['EfficientNetB3', 'ResNet152V2', 'DenseNet201']\n",
+    "        \n",
+    "        print(f\"✅ Created ensemble with {len(models)} models\")\n",
+    "        return models, model_names\n",
+    "    \n",
+    "    def train_ensemble(self, models, model_names, train_gen, val_gen, class_names, epochs=30):\n",
+    "        \"\"\"Train ensemble models\"\"\"\n",
+    "        print(\"🚀 Training ensemble...\")\n",
+    "        \n",
+    "        # Calculate class weights for imbalanced data\n",
+    "        y_train_full = []\n",
+    "        for _ in range(len(train_gen)):\n",
+    "            _, y_batch = next(train_gen)\n",
+    "            y_train_full.extend(y_batch)\n",
+    "        \n",
+    "        class_weights = compute_class_weight(\n",
+    "            'balanced',\n",
+    "            classes=np.unique(y_train_full),\n",
+    "            y=y_train_full\n",
+    "        )\n",
+    "        class_weight_dict = dict(enumerate(class_weights))\n",
+    "        \n",
+    "        # Reset generator\n",
+    "        train_gen.reset()\n",
+    "        \n",
+    "        # Train each model\n",
+    "        histories = []\n",
+    "        for model, model_name in zip(models, model_names):\n",
+    "            print(f\"\\n{'='*50}\")\n",
+    "            print(f\"Training {model_name}\")\n",
+    "            print(f\"{'='*50}\")\n",
+    "            \n",
+    "            # Callbacks\n",
+    "            callbacks = [\n",
+    "                EarlyStopping(\n",
+    "                    monitor='val_accuracy',\n",
+    "                    patience=10,\n",
+    "                    restore_best_weights=True,\n",
+    "                    verbose=1\n",
+    "                ),\n",
+    "                ReduceLROnPlateau(\n",
+    "                    monitor='val_loss',\n",
+    "                    patience=5,\n",
+    "                    factor=0.5,\n",
+    "                    min_lr=1e-7,\n",
+    "                    verbose=1\n",
+    "                ),\n",
+    "                ModelCheckpoint(\n",
+    "                    f\"{self.model_path}/best_{model_name.lower()}_model.h5\",\n",
+    "                    monitor='val_accuracy',\n",
+    "                    save_best_only=True,\n",
+    "                    verbose=1\n",
+    "                )\n",
+    "            ]\n",
+    "            \n",
+    "            history = model.fit(\n",
+    "                train_gen,\n",
+    "                epochs=epochs,\n",
+    "                validation_data=val_gen,\n",
+    "                callbacks=callbacks,\n",
+    "                class_weight=class_weight_dict,\n",
+    "                verbose=1\n",
+    "            )\n",
+    "            \n",
+    "            histories.append(history)\n",
+    "            train_gen.reset()\n",
+    "            val_gen.reset()\n",
+    "        \n",
+    "        return histories\n",
+    "    \n",
+    "    def evaluate_ensemble(self, models, model_names, X_test, y_test, class_names):\n",
+    "        \"\"\"Evaluate ensemble model\"\"\"\n",
+    "        print(\"📊 Evaluating ensemble...\")\n",
+    "        \n",
+    "        # Individual model predictions\n",
+    "        all_predictions = []\n",
+    "        individual_scores = []\n",
+    "        \n",
+    "        for model, model_name in zip(models, model_names):\n",
+    "            print(f\"\\nEvaluating {model_name}:\")\n",
+    "            \n",
+    "            test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0)\n",
+    "            predictions = model.predict(X_test, verbose=0)\n",
+    "            all_predictions.append(predictions)\n",
+    "            \n",
+    "            individual_scores.append({\n",
+    "                'model': model_name,\n",
+    "                'accuracy': test_accuracy,\n",
+    "                'loss': test_loss\n",
+    "            })\n",
+    "            \n",
+    "            print(f\"  Accuracy: {test_accuracy:.4f}\")\n",
+    "        \n",
+    "        # Ensemble predictions (weighted average)\n",
+    "        weights = [0.4, 0.35, 0.25]  # EfficientNet gets highest weight\n",
+    "        ensemble_predictions = np.average(all_predictions, axis=0, weights=weights)\n",
+    "        ensemble_pred_classes = np.argmax(ensemble_predictions, axis=1)\n",
+    "        \n",
+    "        # Calculate ensemble accuracy\n",
+    "        ensemble_accuracy = accuracy_score(y_test, ensemble_pred_classes)\n",
+    "        \n",
+    "        print(f\"\\n🎯 ENSEMBLE RESULTS:\")\n",
+    "        print(f\"Ensemble Accuracy: {ensemble_accuracy:.4f} ({ensemble_accuracy*100:.2f}%)\")\n",
+    "        \n",
+    "        # Classification report\n",
+    "        print(\"\\nEnsemble Classification Report:\")\n",
+    "        report = classification_report(\n",
+    "            y_test, ensemble_pred_classes, \n",
+    "            target_names=class_names,\n",
+    "            output_dict=True,\n",
+    "            zero_division=0\n",
+    "        )\n",
+    "        print(classification_report(y_test, ensemble_pred_classes, target_names=class_names, zero_division=0))\n",
+    "        \n",
+    "        # Plot confusion matrix\n",
+    "        self.plot_confusion_matrix(y_test, ensemble_pred_classes, class_names)\n",
+    "        \n",
+    "        return ensemble_accuracy, individual_scores, report\n",
+    "    \n",
+    "    def plot_confusion_matrix(self, y_true, y_pred, class_names):\n",
+    "        \"\"\"Plot and save confusion matrix\"\"\"\n",
+    "        cm = confusion_matrix(y_true, y_pred)\n",
+    "        \n",
+    "        plt.figure(figsize=(10, 8))\n",
+    "        sns.heatmap(\n",
+    "            cm, \n",
+    "            annot=True, \n",
+    "            fmt='d', \n",
+    "            cmap='Blues',\n",
+    "            xticklabels=class_names,\n",
+    "            yticklabels=class_names,\n",
+    "            annot_kws={'size': 10}\n",
+    "        )\n",
+    "        plt.title('Ensemble Confusion Matrix', fontsize=16)\n",
+    "        plt.ylabel('True Label', fontsize=12)\n",
+    "        plt.xlabel('Predicted Label', fontsize=12)\n",
+    "        plt.xticks(rotation=45, ha='right')\n",
+    "        plt.yticks(rotation=0)\n",
+    "        plt.tight_layout()\n",
+    "        \n",
+    "        plt.savefig('plots/confusion_matrix.png', dpi=300, bbox_inches='tight')\n",
+    "        plt.close()\n",
+    "        \n",
+    "        print(\"✅ Confusion matrix saved to plots/confusion_matrix.png\")\n",
+    "    \n",
+    "    def plot_training_history(self, histories, model_names):\n",
+    "        \"\"\"Plot training history\"\"\"\n",
+    "        plt.figure(figsize=(15, 10))\n",
+    "        \n",
+    "        colors = ['blue', 'red', 'green']\n",
+    "        \n",
+    "        # Accuracy\n",
+    "        plt.subplot(2, 2, 1)\n",
+    "        for history, model_name, color in zip(histories, model_names, colors):\n",
+    "            plt.plot(history.history['accuracy'], label=f'{model_name} Train', color=color, linestyle='-')\n",
+    "            plt.plot(history.history['val_accuracy'], label=f'{model_name} Val', color=color, linestyle='--')\n",
+    "        \n",
+    "        plt.title('Model Accuracy')\n",
+    "        plt.xlabel('Epoch')\n",
+    "        plt.ylabel('Accuracy')\n",
+    "        plt.legend()\n",
+    "        plt.grid(True)\n",
+    "        \n",
+    "        # Loss\n",
+    "        plt.subplot(2, 2, 2)\n",
+    "        for history, model_name, color in zip(histories, model_names, colors):\n",
+    "            plt.plot(history.history['loss'], label=f'{model_name} Train', color=color, linestyle='-')\n",
+    "            plt.plot(history.history['val_loss'], label=f'{model_name} Val', color=color, linestyle='--')\n",
+    "        \n",
+    "        plt.title('Model Loss')\n",
+    "        plt.xlabel('Epoch')\n",
+    "        plt.ylabel('Loss')\n",
+    "        plt.legend()\n",
+    "        plt.grid(True)\n",
+    "        \n",
+    "        plt.tight_layout()\n",
+    "        plt.savefig('plots/training_history.png', dpi=300, bbox_inches='tight')\n",
+    "        plt.close()\n",
+    "        \n",
+    "        print(\"✅ Training history saved to plots/training_history.png\")\n",
+    "    \n",
+    "    def save_ensemble(self, models, model_names, class_names, ensemble_accuracy, individual_scores):\n",
+    "        \"\"\"Save ensemble models and metadata\"\"\"\n",
+    "        print(\"💾 Saving ensemble...\")\n",
+    "        \n",
+    "        # Save individual models\n",
+    "        model_files = []\n",
+    "        for model, model_name in zip(models, model_names):\n",
+    "            model_file = f\"{self.model_path}/{model_name.lower()}_model.keras\"\n",
+    "            model.save(model_file)\n",
+    "            model_files.append(model_file)\n",
+    "            print(f\"✅ {model_name} saved to: {model_file}\")\n",
+    "        \n",
+    "        # Save metadata\n",
+    "        metadata = {\n",
+    "            'ensemble_accuracy': float(ensemble_accuracy),\n",
+    "            'individual_models': individual_scores,\n",
+    "            'model_files': model_files,\n",
+    "            'num_classes': len(class_names),\n",
+    "            'image_size': self.image_size,\n",
+    "            'class_names': class_names.tolist(),\n",
+    "            'ensemble_weights': [0.4, 0.35, 0.25]\n",
+    "        }\n",
+    "        \n",
+    "        metadata_file = f\"{self.model_path}/ensemble_metadata.json\"\n",
+    "        with open(metadata_file, 'w') as f:\n",
+    "            json.dump(metadata, f, indent=2)\n",
+    "        \n",
+    "        # Save class names\n",
+    "        classes_file = f\"{self.model_path}/classes.json\"\n",
+    "        with open(classes_file, 'w') as f:\n",
+    "            json.dump(class_names.tolist(), f, indent=2)\n",
+    "        \n",
+    "        print(f\"✅ Metadata saved to: {metadata_file}\")\n",
+    "        print(f\"✅ Classes saved to: {classes_file}\")\n",
+    "    \n",
+    "    def run_training(self):\n",
+    "        \"\"\"Run the complete training pipeline\"\"\"\n",
+    "        print(\"🎯 Eye Disease Detection - Advanced Training Pipeline\")\n",
+    "        print(\"=\" * 60)\n",
+    "        \n",
+    "        # Step 1: Download dataset if needed\n",
+    "        if not os.path.exists(self.dataset_path):\n",
+    "            if not self.download_dataset():\n",
+    "                print(\"Please download and extract the dataset manually.\")\n",
+    "                return False\n",
+    "        \n",
+    "        # Step 2: Load dataset\n",
+    "        result = self.load_dataset()\n",
+    "        if result[0] is None:\n",
+    "            print(\"❌ Failed to load dataset. Exiting.\")\n",
+    "            return False\n",
+    "        \n",
+    "        X, y, class_names = result\n",
+    "        \n",
+    "        if len(X) < 50:\n",
+    "            print(f\"❌ Not enough images ({len(X)}). Need at least 50 for training.\")\n",
+    "            return False\n",
+    "        \n",
+    "        # Step 3: Balance dataset\n",
+    "        X_balanced, y_balanced = self.balance_dataset(X, y)\n",
+    "        \n",
+    "        # Step 4: Split dataset\n",
+    "        print(\"✂️ Splitting dataset...\")\n",
+    "        X_train, X_temp, y_train, y_temp = train_test_split(\n",
+    "            X_balanced, y_balanced, test_size=0.3, random_state=42, stratify=y_balanced\n",
+    "        )\n",
+    "        X_val, X_test, y_val, y_test = train_test_split(\n",
+    "            X_temp, y_temp, test_size=0.5, random_state=42, stratify=y_temp\n",
+    "        )\n",
+    "        \n",
+    "        print(f\"Train: {len(X_train)}, Val: {len(X_val)}, Test: {len(X_test)}\")\n",
+    "        \n",
+    "        # Step 5: Create data generators\n",
+    "        train_gen, val_gen = self.create_data_generators(X_train, y_train, X_val, y_val)\n",
+    "        \n",
+    "        # Step 6: Create and train ensemble\n",
+    "        models, model_names = self.create_ensemble(len(class_names))\n",
+    "        histories = self.train_ensemble(models, model_names, train_gen, val_gen, class_names)\n",
+    "        \n",
+    "        # Step 7: Evaluate ensemble\n",
+    "        ensemble_accuracy, individual_scores, report = self.evaluate_ensemble(\n",
+    "            models, model_names, X_test, y_test, class_names\n",
+    "        )\n",
+    "        \n",
+    "        # Step 8: Save results\n",
+    "        self.save_ensemble(models, model_names, class_names, ensemble_accuracy, individual_scores)\n",
+    "        self.plot_training_history(histories, model_names)\n",
+    "        \n",
+    "        print(\"\\n🎉 TRAINING COMPLETED!\")\n",
+    "        print(f\"🎯 Final Ensemble Accuracy: {ensemble_accuracy:.4f} ({ensemble_accuracy*100:.2f}%)\")\n",
+    "        \n",
+    "        return True\n",
+    "\n",
+    "def main():\n",
+    "    \"\"\"Main function\"\"\"\n",
+    "    print(\"🚀 Advanced Eye Disease Detection Training\")\n",
+    "    print(\"=\" * 50)\n",
+    "    \n",
+    "    # System information\n",
+    "    print(f\"🔧 System Information:\")\n",
+    "    print(f\"   TensorFlow version: {tf.__version__}\")\n",
+    "    print(f\"   GPU available: {len(tf.config.list_physical_devices('GPU')) > 0}\")\n",
+    "    \n",
+    "    # GPU setup\n",
+    "    gpus = tf.config.experimental.list_physical_devices('GPU')\n",
+    "    if gpus:\n",
+    "        try:\n",
+    "            for gpu in gpus:\n",
+    "                tf.config.experimental.set_memory_growth(gpu, True)\n",
+    "            print(\"   ✅ GPU memory growth enabled\")\n",
+    "        except RuntimeError as e:\n",
+    "            print(f\"   ⚠️ GPU setup warning: {e}\")\n",
+    "    \n",
+    "    print()\n",
+    "    \n",
+    "    # Initialize and run trainer\n",
+    "    trainer = AdvancedFundusTrainer()\n",
+    "    success = trainer.run_training()\n",
+    "    \n",
+    "    if success:\n",
+    "        print(\"\\n\" + \"=\"*50)\n",
+    "        print(\"🎉 TRAINING SUCCESSFULLY COMPLETED!\")\n",
+    "        print(\"=\"*50)\n",
+    "        print(\"\\n📦 Generated Assets:\")\n",
+    "        print(\"   🤖 Ensemble models (EfficientNetB3 + ResNet152V2 + DenseNet201)\")\n",
+    "        print(\"   📊 Performance analysis and visualizations\")\n",
+    "        print(\"   📋 Metadata for deployment\")\n",
+    "        \n",
+    "    else:\n",
+    "        print(\"\\n❌ TRAINING FAILED\")\n",
+    "        print(\"Please check the error messages above.\")\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    main()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

dataset/.ipynb_checkpoints/training-checkpoint.ipynb

@@ -0,0 +1,446 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "039f2cb9",
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "from torchvision import transforms\n",
+    "from torchvision.models import resnet101\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import f1_score, precision_score, recall_score\n",
+    "import pandas as pd\n",
+    "import os\n",
+    "import cv2\n",
+    "import json\n",
+    "from PIL import Image\n",
+    "import glob\n",
+    "\n",
+    "# Define the G1020 Dataset class\n",
+    "class G1020Dataset(Dataset):\n",
+    "    def __init__(self, img_paths, cdr_values, transform=None):\n",
+    "        self.img_paths = img_paths\n",
+    "        self.cdr_values = cdr_values\n",
+    "        self.transform = transform\n",
+    "        \n",
+    "    def __len__(self):\n",
+    "        return len(self.img_paths)\n",
+    "    \n",
+    "    def __getitem__(self, idx):\n",
+    "        # Load image\n",
+    "        img_path = self.img_paths[idx]\n",
+    "        img = cv2.imread(img_path)\n",
+    "        \n",
+    "        # Check if the image was loaded successfully\n",
+    "        if img is None:\n",
+    "            raise FileNotFoundError(f\"Image not found or unable to load: {img_path}\")\n",
+    "        \n",
+    "        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
+    "        ls Images\n",
+    "image_0.jpg\timage_1248.jpg   image_1495.jpg   image_1748.jpg   image_2002.jpg   image_2223.jpg   image_2430.jpg   image_2623.jpg\timage_2861.jpg\timage_3117.jpg   image_489.jpg   image_704.jpg\n",
+    "image_0.json\timage_1248.json  image_1495.json  image_1748.json  image_2002.json  image_2223.json  image_2430.json  image_2623.json\timage_2861.json  image_3117.json  image_489.json  image_704.json\n",
+    "image_1000.jpg\timage_124.jpg\t image_1496.jpg   image_1759.jpg   image_200.jpg    image_2225.jpg   image_2431.jpg   image_262.jpg\timage_2880.jpg\timage_3120.jpg   image_48.jpg\t image_708.jpg\n",
+    "image_1000.json  image_124.json   image_1496.json  image_1759.json  image_200.json   image_2225.json  image_2431.json  image_262.json\timage_2880.json  image_3120.json  image_48.json   image_708.json\n",
+    "image_1001.jpg\timage_1250.jpg   image_1497.jpg   image_1760.jpg   image_2019.jpg   image_2226.jpg   image_2434.jpg   image_264.jpg\timage_2881.jpg\timage_3121.jpg   image_490.jpg   image_709.jpg\n",
+    "image_1001.json  image_1250.json  image_1497.json  image_1760.json  image_2019.json  image_2226.json  image_2434.json  image_264.json\timage_2881.json  image_3121.json  image_490.json  image_709.json\n",
+    "image_1002.jpg\timage_1254.jpg   image_1498.jpg   image_1765.jpg   image_201.jpg    image_2229.jpg   image_2435.jpg   image_2651.jpg\timage_2885.jpg\timage_3122.jpg   image_491.jpg   image_726.jpg\n",
+    "image_1002.json  image_1254.json  image_1498.json  image_1765.json  image_201.json   image_2229.json  image_2435.json  image_2651.json\timage_2885.json  image_3122.json  image_491.json  image_726.json\n",
+    "image_1003.jpg\timage_1255.jpg   image_1504.jpg   image_1766.jpg   image_2020.jpg   image_222.jpg    image_2436.jpg   image_2652.jpg\timage_2886.jpg\timage_3123.jpg   image_492.jpg   image_727.jpg\n",
+    "image_1003.json  image_1255.json  image_1504.json  image_1766.json  image_2020.json  image_222.json   image_2436.json  image_2652.json\timage_2886.json  image_3123.json  image_492.json  image_727.json\n",
+    "image_1004.jpg\timage_125.jpg\t image_1507.jpg   image_1767.jpg   image_2022.jpg   image_2230.jpg   image_2437.jpg   image_2654.jpg\timage_2887.jpg\timage_3124.jpg   image_493.jpg   image_745.jpg\n",
+    "image_1004.json  image_125.json   image_1507.json  image_1767.json  image_2022.json  image_2230.json  image_2437.json  image_2654.json\timage_2887.json  image_3124.json  image_493.json  image_745.json\n",
+    "image_1032.jpg\timage_1260.jpg   image_1508.jpg   image_1768.jpg   image_2028.jpg   image_2231.jpg   image_244.jpg    image_2655.jpg\timage_2888.jpg\timage_3129.jpg   image_494.jpg   image_746.jpg\n",
+    "image_1032.json  image_1260.json  image_1508.json  image_1768.json  image_2028.json  image_2231.json  image_244.json   image_2655.json\timage_2888.json  image_3129.json  image_494.json  image_746.json\n",
+    "image_1033.jpg\timage_1261.jpg   image_150.jpg    image_1786.jpg   image_202.jpg    image_2232.jpg   image_2455.jpg   image_2656.jpg\timage_2891.jpg\timage_3130.jpg   image_496.jpg   image_747.jpg\n",
+    "image_1033.json  image_1261.json  image_150.json   image_1786.json  image_202.json   image_2232.json  image_2455.json  image_2656.json\timage_2891.json  image_3130.json  image_496.json  image_747.json\n",
+    "image_1034.jpg\timage_126.jpg\t image_1515.jpg   image_1787.jpg   image_2030.jpg   image_2234.jpg   image_2456.jpg   image_2658.jpg\timage_2892.jpg\timage_3131.jpg   image_498.jpg   image_748.jpg\n",
+    "image_1034.json  image_126.json   image_1515.json  image_1787.json  image_2030.json  image_2234.json  image_2456.json  image_2658.json\timage_2892.json  image_3131.json  image_498.json  image_748.json\n",
+    "image_1035.jpg\timage_1270.jpg   image_1516.jpg   image_1788.jpg   image_2031.jpg   image_223.jpg    image_2457.jpg   image_265.jpg\timage_2897.jpg\timage_3132.jpg   image_49.jpg\t image_756.jpg\n",
+    "image_1035.json  image_1270.json  image_1516.json  image_1788.json  image_2031.json  image_223.json   image_2457.json  image_265.json\timage_2897.json  image_3132.json  image_49.json   image_756.json\n",
+    "image_103.jpg\timage_1271.jpg   image_1519.jpg   image_1789.jpg   image_2032.jpg   image_2244.jpg   image_2458.jpg   image_2661.jpg\timage_2898.jpg\timage_3137.jpg   image_4.jpg\t image_757.jpg\n",
+    "image_103.json\timage_1271.json  image_1519.json  image_1789.json  image_2032.json  image_2244.json  image_2458.json  image_2661.json\timage_2898.json  image_3137.json  image_4.json\t image_757.json\n",
+    "image_104.jpg\timage_1285.jpg   image_151.jpg    image_1790.jpg   image_2033.jpg   image_2245.jpg   image_2459.jpg   image_2662.jpg\timage_2899.jpg\timage_3138.jpg   image_505.jpg   image_764.jpg\n",
+    "image_104.json\timage_1285.json  image_151.json   image_1790.json  image_2033.json  image_2245.json  image_2459.json  image_2662.json\timage_2899.json  image_3138.json  image_505.json  image_764.json\n",
+    "image_105.jpg\timage_12.jpg\t image_1520.jpg   image_1791.jpg   image_2034.jpg   image_2246.jpg   image_245.jpg    image_2668.jpg\timage_2900.jpg\timage_3143.jpg   image_50.jpg\t image_765.jpg\n",
+    "image_105.json\timage_12.json\t image_1520.json  image_1791.json  image_2034.json  image_2246.json  image_245.json   image_2668.json\timage_2900.json  image_3143.json  image_50.json   image_765.json\n",
+    "image_106.jpg\timage_1303.jpg   image_1521.jpg   image_1796.jpg   image_2035.jpg   image_2247.jpg   image_246.jpg    image_2669.jpg\timage_2901.jpg\timage_3144.jpg   image_512.jpg   image_768.jpg\n",
+    "image_106.json\timage_1303.json  image_1521.json  image_1796.json  image_2035.json  image_2247.json  image_246.json   image_2669.json\timage_2901.json  image_3144.json  image_512.json  image_768.json\n",
+    "image_1076.jpg\timage_1304.jpg   image_1522.jpg   image_1797.jpg   image_2036.jpg   image_2248.jpg   image_2470.jpg   image_266.jpg\timage_2902.jpg\timage_3159.jpg   image_513.jpg   image_769.jpg\n",
+    "image_1076.json  image_1304.json  image_1522.json  image_1797.json  image_2036.json  image_2248.json  image_2470.json  image_266.\n",
+    "        # Get CDR and severity\n",
+    "        cdr = self.cdr_values[idx]\n",
+    "        severity = cdr_to_severity(cdr)\n",
+    "        \n",
+    "        # Apply transforms\n",
+    "        if self.transform:\n",
+    "            img = self.transform(img)\n",
+    "            \n",
+    "        return img, torch.tensor(cdr, dtype=torch.float32), torch.tensor(severity, dtype=torch.long)\n",
+    "\n",
+    "# Define the severity classification function\n",
+    "def cdr_to_severity(cdr):\n",
+    "    if cdr < 0.7:\n",
+    "        return 0  # Mild\n",
+    "    elif cdr < 0.9:\n",
+    "        return 1  # Moderate\n",
+    "    else:\n",
+    "        return 2  # Severe\n",
+    "\n",
+    "# Define the Squeeze-and-Excitation (SE) Block\n",
+    "class SEBlock(nn.Module):\n",
+    "    def __init__(self, channel, reduction=16):\n",
+    "        super().__init__()\n",
+    "        self.avg_pool = nn.AdaptiveAvgPool2d(1)\n",
+    "        self.fc = nn.Sequential(\n",
+    "            nn.Linear(channel, channel // reduction),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(channel // reduction, channel),\n",
+    "            nn.Sigmoid())\n",
+    "    \n",
+    "    def forward(self, x):\n",
+    "        b, c, _, _ = x.size()\n",
+    "        y = self.avg_pool(x).view(b, c)\n",
+    "        y = self.fc(y).view(b, c, 1, 1)\n",
+    "        return x * y\n",
+    "\n",
+    "# Define the Glaucoma Severity Model with SE Blocks\n",
+    "class GlaucomaSeverityModel(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "        self.backbone = resnet101(pretrained=True)\n",
+    "        self.backbone.fc = nn.Identity()  # Remove the original FC layer\n",
+    "        \n",
+    "        # Add SE Blocks to the backbone\n",
+    "        self.backbone.layer1 = nn.Sequential(self.backbone.layer1, SEBlock(256))\n",
+    "        self.backbone.layer2 = nn.Sequential(self.backbone.layer2, SEBlock(512))\n",
+    "        self.backbone.layer3 = nn.Sequential(self.backbone.layer3, SEBlock(1024))\n",
+    "        self.backbone.layer4 = nn.Sequential(self.backbone.layer4, SEBlock(2048))\n",
+    "        \n",
+    "        # Regression head for CDR prediction\n",
+    "        self.regressor = nn.Sequential(\n",
+    "            nn.Linear(2048, 512),\n",
+    "            nn.BatchNorm1d(512),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Dropout(0.5),\n",
+    "            nn.Linear(512, 1))\n",
+    "        \n",
+    "        # Classification head for severity\n",
+    "        self.classifier = nn.Sequential(\n",
+    "            nn.Linear(2048, 512),\n",
+    "            nn.BatchNorm1d(512),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Dropout(0.5),\n",
+    "            nn.Linear(512, 3))  # 3 classes: Mild, Moderate, Severe\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        features = self.backbone(x)\n",
+    "        cdr = self.regressor(features)\n",
+    "        severity = self.classifier(features)\n",
+    "        return cdr, severity\n",
+    "\n",
+    "# Define Focal Loss\n",
+    "class FocalLoss(nn.Module):\n",
+    "    def __init__(self, alpha=1, gamma=2):\n",
+    "        super().__init__()\n",
+    "        self.alpha = alpha\n",
+    "        self.gamma = gamma\n",
+    "\n",
+    "    def forward(self, inputs, targets):\n",
+    "        ce_loss = nn.CrossEntropyLoss(reduction='none')(inputs, targets)\n",
+    "        pt = torch.exp(-ce_loss)\n",
+    "        focal_loss = self.alpha * (1 - pt) ** self.gamma * ce_loss\n",
+    "        return focal_loss.mean()\n",
+    "\n",
+    "# Define the training and validation transforms with advanced augmentation\n",
+    "train_transform = transforms.Compose([\n",
+    "    transforms.ToPILImage(),\n",
+    "    transforms.Resize((256, 256)),\n",
+    "    transforms.RandomHorizontalFlip(),\n",
+    "    transforms.RandomRotation(15),\n",
+    "    transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),\n",
+    "    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),\n",
+    "    transforms.GaussianBlur(kernel_size=3),\n",
+    "    transforms.ToTensor(),\n",
+    "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n",
+    "])\n",
+    "\n",
+    "val_transform = transforms.Compose([\n",
+    "    transforms.ToPILImage(),\n",
+    "    transforms.Resize((256, 256)),\n",
+    "    transforms.ToTensor(),\n",
+    "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n",
+    "])\n",
+    "\n",
+    "# Function to load G1020 dataset\n",
+    "def load_g1020_dataset(base_dir):\n",
+    "    \"\"\"\n",
+    "    Load G1020 dataset from the specified directory structure.\n",
+    "    \n",
+    "    Args:\n",
+    "        base_dir: Path to G1020 directory\n",
+    "        \n",
+    "    Returns:\n",
+    "        img_paths: List of image file paths\n",
+    "        cdr_values: List of CDR values\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # Try to find the CSV file with annotations\n",
+    "    csv_files = glob.glob(os.path.join(base_dir, \"*.csv\"))\n",
+    "    \n",
+    "    if not csv_files:\n",
+    "        raise FileNotFoundError(f\"No CSV files found in {base_dir}\")\n",
+    "    \n",
+    "    # Use the first CSV file found (typically G1020.csv)\n",
+    "    csv_file = csv_files[0]\n",
+    "    print(f\"Loading metadata from: {csv_file}\")\n",
+    "    \n",
+    "    # Load the metadata\n",
+    "    try:\n",
+    "        metadata = pd.read_csv(csv_file)\n",
+    "        print(f\"CSV columns: {metadata.columns.tolist()}\")\n",
+    "        print(f\"First few rows:\\n{metadata.head()}\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error reading CSV: {e}\")\n",
+    "        raise\n",
+    "    \n",
+    "    # Define possible image directories in order of preference\n",
+    "    image_dirs = [\"Images_Cropped\", \"Images_Square\", \"Images\"]\n",
+    "    \n",
+    "    selected_img_dir = None\n",
+    "    for img_dir in image_dirs:\n",
+    "        full_img_dir = os.path.join(base_dir, img_dir)\n",
+    "        if os.path.exists(full_img_dir):\n",
+    "            selected_img_dir = full_img_dir\n",
+    "            print(f\"Using image directory: {selected_img_dir}\")\n",
+    "            break\n",
+    "    \n",
+    "    if selected_img_dir is None:\n",
+    "        raise FileNotFoundError(f\"No valid image directory found in {base_dir}\")\n",
+    "    \n",
+    "    # Get list of image files\n",
+    "    image_extensions = ['*.jpg', '*.jpeg', '*.png', '*.bmp', '*.tiff', '*.tif']\n",
+    "    all_images = []\n",
+    "    for ext in image_extensions:\n",
+    "        all_images.extend(glob.glob(os.path.join(selected_img_dir, ext)))\n",
+    "        all_images.extend(glob.glob(os.path.join(selected_img_dir, ext.upper())))\n",
+    "    \n",
+    "    print(f\"Found {len(all_images)} images in {selected_img_dir}\")\n",
+    "    \n",
+    "    # Try to match images with metadata\n",
+    "    img_paths = []\n",
+    "    cdr_values = []\n",
+    "    \n",
+    "    # Common column names for CDR in G1020 dataset\n",
+    "    cdr_columns = ['CDR', 'cdr', 'vertical_cdr', 'Vertical_CDR', 'ExpCDR', 'cup_disc_ratio']\n",
+    "    filename_columns = ['filename', 'Filename', 'image', 'Image', 'image_name', 'ImageName']\n",
+    "    \n",
+    "    # Find the correct CDR column\n",
+    "    cdr_col = None\n",
+    "    for col in cdr_columns:\n",
+    "        if col in metadata.columns:\n",
+    "            cdr_col = col\n",
+    "            break\n",
+    "    \n",
+    "    if cdr_col is None:\n",
+    "        print(f\"Available columns: {metadata.columns.tolist()}\")\n",
+    "        raise ValueError(\"Could not find CDR column in metadata. Please check the CSV structure.\")\n",
+    "    \n",
+    "    # Find the correct filename column\n",
+    "    filename_col = None\n",
+    "    for col in filename_columns:\n",
+    "        if col in metadata.columns:\n",
+    "            filename_col = col\n",
+    "            break\n",
+    "    \n",
+    "    print(f\"Using CDR column: {cdr_col}\")\n",
+    "    print(f\"Using filename column: {filename_col}\")\n",
+    "    \n",
+    "    if filename_col is not None:\n",
+    "        # Match using filenames from CSV\n",
+    "        for _, row in metadata.iterrows():\n",
+    "            filename = row[filename_col]\n",
+    "            cdr = row[cdr_col]\n",
+    "            \n",
+    "            # Skip if CDR is NaN\n",
+    "            if pd.isna(cdr):\n",
+    "                continue\n",
+    "            \n",
+    "            # Find matching image file\n",
+    "            matching_files = [img for img in all_images if os.path.basename(img) == filename or \n",
+    "                             os.path.splitext(os.path.basename(img))[0] == os.path.splitext(filename)[0]]\n",
+    "            \n",
+    "            if matching_files:\n",
+    "                img_paths.append(matching_files[0])\n",
+    "                cdr_values.append(float(cdr))\n",
+    "    else:\n",
+    "        # If no filename column, try to match by order or use all images with default CDR\n",
+    "        print(\"No filename column found. Using all images with metadata in order.\")\n",
+    "        for i, (img_path, (_, row)) in enumerate(zip(all_images[:len(metadata)], metadata.iterrows())):\n",
+    "            cdr = row[cdr_col]\n",
+    "            if not pd.isna(cdr):\n",
+    "                img_paths.append(img_path)\n",
+    "                cdr_values.append(float(cdr))\n",
+    "    \n",
+    "    print(f\"Successfully matched {len(img_paths)} images with CDR values\")\n",
+    "    \n",
+    "    if len(img_paths) == 0:\n",
+    "        raise ValueError(\"No images could be matched with CDR values\")\n",
+    "    \n",
+    "    return img_paths, cdr_values\n",
+    "\n",
+    "# Load the G1020 dataset\n",
+    "base_dir = \"/home/stalin/Projects/ai-eye-disease-detection/dataset/G1020\"\n",
+    "\n",
+    "try:\n",
+    "    img_paths, cdr_values = load_g1020_dataset(base_dir)\n",
+    "    print(f\"Dataset loaded successfully!\")\n",
+    "    print(f\"Number of images: {len(img_paths)}\")\n",
+    "    print(f\"CDR value range: {min(cdr_values):.3f} - {max(cdr_values):.3f}\")\n",
+    "    print(f\"Sample image paths: {img_paths[:3]}\")\n",
+    "    print(f\"Sample CDR values: {cdr_values[:3]}\")\n",
+    "    \n",
+    "except Exception as e:\n",
+    "    print(f\"Error loading dataset: {e}\")\n",
+    "    raise\n",
+    "\n",
+    "# Split the data into training and validation sets\n",
+    "train_img_paths, val_img_paths, train_cdr_values, val_cdr_values = train_test_split(\n",
+    "    img_paths, cdr_values, test_size=0.2, random_state=42, stratify=[cdr_to_severity(cdr) for cdr in cdr_values]\n",
+    ")\n",
+    "\n",
+    "print(f\"Training samples: {len(train_img_paths)}\")\n",
+    "print(f\"Validation samples: {len(val_img_paths)}\")\n",
+    "\n",
+    "# Create datasets\n",
+    "train_dataset = G1020Dataset(train_img_paths, train_cdr_values, transform=train_transform)\n",
+    "val_dataset = G1020Dataset(val_img_paths, val_cdr_values, transform=val_transform)\n",
+    "\n",
+    "# Create DataLoader objects\n",
+    "batch_size = 32\n",
+    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4)\n",
+    "val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=4)\n",
+    "\n",
+    "# Define the device\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "print(f\"Using device: {device}\")\n",
+    "\n",
+    "# Initialize the model\n",
+    "model = GlaucomaSeverityModel().to(device)\n",
+    "\n",
+    "# Loss functions\n",
+    "regression_loss = nn.MSELoss()\n",
+    "classification_loss = FocalLoss()  # Use Focal Loss for classification\n",
+    "\n",
+    "# Optimizer\n",
+    "optimizer = optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-5)\n",
+    "\n",
+    "# Learning rate scheduler with warmup\n",
+    "from torch.optim.lr_scheduler import LambdaLR\n",
+    "\n",
+    "def lr_lambda(epoch):\n",
+    "    if epoch < 5:  # Warmup for 5 epochs\n",
+    "        return (epoch + 1) / 5\n",
+    "    else:\n",
+    "        return 0.1 ** (epoch // 10)  # Reduce LR by 0.1 every 10 epochs\n",
+    "\n",
+    "scheduler = LambdaLR(optimizer, lr_lambda)\n",
+    "\n",
+    "# Training loop\n",
+    "def train_model(model, train_loader, val_loader, epochs=20):\n",
+    "    best_val_loss = float('inf')\n",
+    "    patience = 5\n",
+    "    early_stopping_counter = 0\n",
+    "\n",
+    "    for epoch in range(epochs):\n",
+    "        model.train()\n",
+    "        train_loss = 0.0\n",
+    "        for imgs, cdr_true, severity_true in train_loader:\n",
+    "            imgs, cdr_true, severity_true = imgs.to(device), cdr_true.to(device), severity_true.to(device)\n",
+    "            \n",
+    "            optimizer.zero_grad()\n",
+    "            cdr_pred, severity_pred = model(imgs)\n",
+    "            \n",
+    "            # Combined loss\n",
+    "            loss = 0.5 * regression_loss(cdr_pred.squeeze(), cdr_true) + \\\n",
+    "                   0.5 * classification_loss(severity_pred, severity_true)\n",
+    "            \n",
+    "            loss.backward()\n",
+    "            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)  # Gradient clipping\n",
+    "            optimizer.step()\n",
+    "            train_loss += loss.item()\n",
+    "        \n",
+    "        # Validation\n",
+    "        model.eval()\n",
+    "        val_loss = 0.0\n",
+    "        cdr_mae, severity_acc = 0.0, 0.0\n",
+    "        all_severity_true = []\n",
+    "        all_severity_pred = []\n",
+    "        with torch.no_grad():\n",
+    "            for imgs, cdr_true, severity_true in val_loader:\n",
+    "                imgs, cdr_true, severity_true = imgs.to(device), cdr_true.to(device), severity_true.to(device)\n",
+    "                cdr_pred, severity_pred = model(imgs)\n",
+    "                \n",
+    "                val_loss += 0.5 * regression_loss(cdr_pred.squeeze(), cdr_true) + \\\n",
+    "                             0.5 * classification_loss(severity_pred, severity_true)\n",
+    "                \n",
+    "                # Metrics\n",
+    "                cdr_mae += torch.abs(cdr_pred.squeeze() - cdr_true).sum().item()\n",
+    "                severity_acc += (severity_pred.argmax(dim=1) == severity_true).sum().item()\n",
+    "                all_severity_true.extend(severity_true.cpu().numpy())\n",
+    "                all_severity_pred.extend(severity_pred.argmax(dim=1).cpu().numpy())\n",
+    "        \n",
+    "        # Calculate additional metrics\n",
+    "        f1 = f1_score(all_severity_true, all_severity_pred, average='weighted')\n",
+    "        precision = precision_score(all_severity_true, all_severity_pred, average='weighted')\n",
+    "        recall = recall_score(all_severity_true, all_severity_pred, average='weighted')\n",
+    "        \n",
+    "        print(f\"Epoch {epoch+1}/{epochs}\")\n",
+    "        print(f\"Train Loss: {train_loss/len(train_loader):.4f}\")\n",
+    "        print(f\"Val Loss: {val_loss/len(val_loader):.4f}\")\n",
+    "        print(f\"CDR MAE: {cdr_mae/len(val_dataset):.4f}\")\n",
+    "        print(f\"Severity Acc: {severity_acc/len(val_dataset):.4f}\")\n",
+    "        print(f\"F1 Score: {f1:.4f}\")\n",
+    "        print(f\"Precision: {precision:.4f}\")\n",
+    "        print(f\"Recall: {recall:.4f}\\n\")\n",
+    "\n",
+    "        # Early stopping\n",
+    "        if val_loss < best_val_loss:\n",
+    "            best_val_loss = val_loss\n",
+    "            early_stopping_counter = 0\n",
+    "            # Save the best model\n",
+    "            torch.save(model.state_dict(), \"best_g1020_model.pth\")\n",
+    "        else:\n",
+    "            early_stopping_counter += 1\n",
+    "            if early_stopping_counter >= patience:\n",
+    "                print(\"Early stopping triggered!\")\n",
+    "                break\n",
+    "\n",
+    "        # Learning rate scheduling\n",
+    "        scheduler.step()\n",
+    "\n",
+    "# Train the model\n",
+    "if __name__ == \"__main__\":\n",
+    "    print(\"Starting training...\")\n",
+    "    train_model(model, train_loader, val_loader, epochs=20)\n",
+    "    print(\"Training completed!\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

dataset/G1020/G1020.csv

@@ -0,0 +1,1021 @@
+imageID,binaryLabels
+image_0.jpg,0
+image_1.jpg,0
+image_3.jpg,0
+image_4.jpg,0
+image_5.jpg,0
+image_6.jpg,0
+image_9.jpg,0
+image_10.jpg,0
+image_11.jpg,0
+image_12.jpg,0
+image_13.jpg,0
+image_18.jpg,1
+image_19.jpg,1
+image_20.jpg,1
+image_21.jpg,0
+image_22.jpg,0
+image_31.jpg,0
+image_32.jpg,0
+image_46.jpg,0
+image_47.jpg,0
+image_48.jpg,0
+image_49.jpg,0
+image_50.jpg,0
+image_53.jpg,0
+image_54.jpg,0
+image_55.jpg,0
+image_56.jpg,0
+image_63.jpg,0
+image_64.jpg,0
+image_65.jpg,1
+image_66.jpg,1
+image_77.jpg,0
+image_78.jpg,0
+image_103.jpg,0
+image_104.jpg,0
+image_105.jpg,0
+image_106.jpg,0
+image_107.jpg,0
+image_110.jpg,1
+image_111.jpg,1
+image_112.jpg,1
+image_113.jpg,1
+image_114.jpg,1
+image_115.jpg,1
+image_120.jpg,0
+image_121.jpg,0
+image_122.jpg,0
+image_123.jpg,0
+image_124.jpg,0
+image_125.jpg,0
+image_126.jpg,0
+image_143.jpg,0
+image_144.jpg,0
+image_150.jpg,0
+image_151.jpg,0
+image_152.jpg,0
+image_153.jpg,0
+image_154.jpg,0
+image_163.jpg,0
+image_164.jpg,0
+image_170.jpg,0
+image_171.jpg,0
+image_193.jpg,0
+image_194.jpg,0
+image_199.jpg,1
+image_200.jpg,1
+image_201.jpg,1
+image_202.jpg,1
+image_214.jpg,0
+image_215.jpg,0
+image_216.jpg,0
+image_217.jpg,0
+image_218.jpg,0
+image_219.jpg,0
+image_222.jpg,0
+image_223.jpg,0
+image_226.jpg,0
+image_227.jpg,0
+image_230.jpg,0
+image_231.jpg,0
+image_232.jpg,1
+image_233.jpg,1
+image_234.jpg,0
+image_235.jpg,0
+image_236.jpg,0
+image_237.jpg,0
+image_244.jpg,0
+image_245.jpg,0
+image_246.jpg,0
+image_247.jpg,0
+image_248.jpg,0
+image_249.jpg,0
+image_250.jpg,0
+image_255.jpg,0
+image_256.jpg,0
+image_261.jpg,0
+image_262.jpg,0
+image_264.jpg,0
+image_265.jpg,0
+image_266.jpg,0
+image_292.jpg,0
+image_293.jpg,0
+image_295.jpg,0
+image_304.jpg,0
+image_305.jpg,0
+image_315.jpg,1
+image_316.jpg,1
+image_327.jpg,0
+image_328.jpg,0
+image_334.jpg,1
+image_335.jpg,1
+image_336.jpg,0
+image_337.jpg,0
+image_338.jpg,0
+image_339.jpg,0
+image_353.jpg,0
+image_354.jpg,0
+image_356.jpg,0
+image_360.jpg,1
+image_361.jpg,1
+image_363.jpg,0
+image_366.jpg,0
+image_367.jpg,0
+image_372.jpg,0
+image_373.jpg,0
+image_384.jpg,1
+image_385.jpg,1
+image_386.jpg,1
+image_387.jpg,1
+image_420.jpg,1
+image_421.jpg,1
+image_436.jpg,0
+image_437.jpg,0
+image_444.jpg,0
+image_445.jpg,0
+image_446.jpg,0
+image_453.jpg,0
+image_454.jpg,0
+image_457.jpg,0
+image_458.jpg,0
+image_459.jpg,0
+image_460.jpg,0
+image_467.jpg,0
+image_468.jpg,0
+image_469.jpg,0
+image_470.jpg,0
+image_482.jpg,0
+image_483.jpg,0
+image_484.jpg,0
+image_485.jpg,0
+image_486.jpg,0
+image_487.jpg,0
+image_488.jpg,0
+image_489.jpg,0
+image_490.jpg,0
+image_491.jpg,0
+image_492.jpg,0
+image_493.jpg,0
+image_494.jpg,0
+image_496.jpg,0
+image_498.jpg,0
+image_505.jpg,0
+image_512.jpg,0
+image_513.jpg,0
+image_518.jpg,0
+image_519.jpg,0
+image_526.jpg,0
+image_527.jpg,0
+image_532.jpg,0
+image_533.jpg,0
+image_534.jpg,0
+image_535.jpg,0
+image_536.jpg,0
+image_537.jpg,0
+image_542.jpg,0
+image_543.jpg,0
+image_545.jpg,1
+image_550.jpg,0
+image_551.jpg,0
+image_560.jpg,0
+image_561.jpg,0
+image_562.jpg,0
+image_563.jpg,0
+image_566.jpg,0
+image_567.jpg,0
+image_570.jpg,0
+image_571.jpg,0
+image_580.jpg,0
+image_581.jpg,0
+image_583.jpg,1
+image_584.jpg,1
+image_585.jpg,0
+image_595.jpg,0
+image_596.jpg,0
+image_597.jpg,0
+image_598.jpg,0
+image_599.jpg,0
+image_600.jpg,0
+image_601.jpg,0
+image_602.jpg,0
+image_607.jpg,1
+image_608.jpg,1
+image_609.jpg,0
+image_610.jpg,0
+image_613.jpg,0
+image_614.jpg,0
+image_626.jpg,0
+image_627.jpg,0
+image_628.jpg,0
+image_630.jpg,0
+image_631.jpg,0
+image_642.jpg,0
+image_643.jpg,0
+image_646.jpg,0
+image_647.jpg,0
+image_654.jpg,0
+image_655.jpg,0
+image_657.jpg,1
+image_658.jpg,1
+image_659.jpg,1
+image_698.jpg,0
+image_699.jpg,0
+image_700.jpg,0
+image_703.jpg,0
+image_704.jpg,0
+image_708.jpg,0
+image_709.jpg,0
+image_726.jpg,1
+image_727.jpg,1
+image_745.jpg,0
+image_746.jpg,0
+image_747.jpg,1
+image_748.jpg,1
+image_756.jpg,0
+image_757.jpg,0
+image_764.jpg,0
+image_765.jpg,0
+image_768.jpg,0
+image_769.jpg,0
+image_772.jpg,1
+image_773.jpg,1
+image_774.jpg,0
+image_775.jpg,0
+image_776.jpg,1
+image_777.jpg,1
+image_778.jpg,0
+image_779.jpg,0
+image_780.jpg,1
+image_781.jpg,1
+image_791.jpg,0
+image_805.jpg,0
+image_806.jpg,0
+image_807.jpg,1
+image_808.jpg,1
+image_815.jpg,0
+image_816.jpg,0
+image_819.jpg,0
+image_820.jpg,0
+image_821.jpg,0
+image_840.jpg,1
+image_841.jpg,1
+image_856.jpg,1
+image_857.jpg,1
+image_860.jpg,0
+image_861.jpg,0
+image_868.jpg,0
+image_869.jpg,0
+image_874.jpg,0
+image_875.jpg,0
+image_878.jpg,0
+image_879.jpg,0
+image_880.jpg,0
+image_881.jpg,0
+image_882.jpg,0
+image_883.jpg,0
+image_896.jpg,0
+image_897.jpg,0
+image_903.jpg,1
+image_904.jpg,1
+image_910.jpg,0
+image_911.jpg,0
+image_912.jpg,0
+image_915.jpg,1
+image_916.jpg,1
+image_924.jpg,0
+image_930.jpg,0
+image_931.jpg,0
+image_936.jpg,0
+image_940.jpg,1
+image_941.jpg,1
+image_942.jpg,0
+image_943.jpg,0
+image_944.jpg,0
+image_945.jpg,0
+image_952.jpg,0
+image_953.jpg,0
+image_954.jpg,0
+image_955.jpg,0
+image_956.jpg,0
+image_957.jpg,0
+image_958.jpg,0
+image_959.jpg,0
+image_964.jpg,0
+image_965.jpg,0
+image_980.jpg,0
+image_981.jpg,0
+image_1000.jpg,1
+image_1001.jpg,1
+image_1002.jpg,1
+image_1003.jpg,1
+image_1004.jpg,1
+image_1032.jpg,1
+image_1033.jpg,1
+image_1034.jpg,0
+image_1035.jpg,0
+image_1076.jpg,0
+image_1077.jpg,0
+image_1080.jpg,1
+image_1081.jpg,1
+image_1087.jpg,0
+image_1088.jpg,0
+image_1092.jpg,0
+image_1093.jpg,0
+image_1094.jpg,0
+image_1095.jpg,0
+image_1096.jpg,0
+image_1112.jpg,1
+image_1113.jpg,1
+image_1136.jpg,0
+image_1137.jpg,0
+image_1138.jpg,0
+image_1139.jpg,0
+image_1140.jpg,0
+image_1141.jpg,0
+image_1142.jpg,0
+image_1143.jpg,0
+image_1144.jpg,0
+image_1160.jpg,0
+image_1161.jpg,0
+image_1164.jpg,0
+image_1165.jpg,0
+image_1187.jpg,0
+image_1188.jpg,0
+image_1189.jpg,0
+image_1190.jpg,0
+image_1197.jpg,0
+image_1198.jpg,0
+image_1199.jpg,0
+image_1201.jpg,1
+image_1202.jpg,1
+image_1203.jpg,0
+image_1204.jpg,0
+image_1213.jpg,0
+image_1214.jpg,0
+image_1215.jpg,0
+image_1216.jpg,0
+image_1217.jpg,0
+image_1218.jpg,0
+image_1225.jpg,0
+image_1226.jpg,1
+image_1227.jpg,1
+image_1230.jpg,1
+image_1231.jpg,1
+image_1232.jpg,1
+image_1233.jpg,1
+image_1234.jpg,1
+image_1238.jpg,0
+image_1240.jpg,0
+image_1241.jpg,0
+image_1242.jpg,0
+image_1243.jpg,0
+image_1246.jpg,1
+image_1247.jpg,1
+image_1248.jpg,0
+image_1250.jpg,0
+image_1254.jpg,0
+image_1255.jpg,0
+image_1260.jpg,0
+image_1261.jpg,0
+image_1270.jpg,1
+image_1271.jpg,1
+image_1285.jpg,0
+image_1303.jpg,0
+image_1304.jpg,0
+image_1317.jpg,1
+image_1318.jpg,1
+image_1319.jpg,1
+image_1321.jpg,0
+image_1322.jpg,0
+image_1325.jpg,0
+image_1326.jpg,0
+image_1327.jpg,0
+image_1328.jpg,0
+image_1329.jpg,0
+image_1330.jpg,0
+image_1331.jpg,0
+image_1332.jpg,0
+image_1333.jpg,0
+image_1334.jpg,1
+image_1335.jpg,1
+image_1336.jpg,1
+image_1337.jpg,1
+image_1338.jpg,1
+image_1339.jpg,1
+image_1344.jpg,0
+image_1348.jpg,0
+image_1349.jpg,0
+image_1350.jpg,0
+image_1351.jpg,0
+image_1352.jpg,0
+image_1355.jpg,1
+image_1356.jpg,1
+image_1359.jpg,0
+image_1360.jpg,0
+image_1361.jpg,0
+image_1362.jpg,0
+image_1366.jpg,0
+image_1367.jpg,0
+image_1368.jpg,0
+image_1377.jpg,1
+image_1378.jpg,1
+image_1384.jpg,0
+image_1386.jpg,0
+image_1387.jpg,0
+image_1388.jpg,0
+image_1389.jpg,0
+image_1391.jpg,0
+image_1392.jpg,0
+image_1401.jpg,0
+image_1402.jpg,0
+image_1403.jpg,0
+image_1404.jpg,0
+image_1413.jpg,0
+image_1414.jpg,0
+image_1415.jpg,0
+image_1416.jpg,0
+image_1421.jpg,1
+image_1422.jpg,1
+image_1426.jpg,0
+image_1431.jpg,0
+image_1432.jpg,0
+image_1452.jpg,0
+image_1453.jpg,0
+image_1462.jpg,0
+image_1463.jpg,0
+image_1470.jpg,0
+image_1471.jpg,0
+image_1478.jpg,0
+image_1479.jpg,0
+image_1480.jpg,0
+image_1481.jpg,0
+image_1495.jpg,1
+image_1496.jpg,1
+image_1497.jpg,1
+image_1498.jpg,1
+image_1504.jpg,0
+image_1507.jpg,0
+image_1508.jpg,0
+image_1515.jpg,1
+image_1516.jpg,1
+image_1519.jpg,0
+image_1520.jpg,0
+image_1521.jpg,1
+image_1522.jpg,1
+image_1524.jpg,1
+image_1525.jpg,1
+image_1526.jpg,1
+image_1543.jpg,0
+image_1544.jpg,0
+image_1553.jpg,0
+image_1554.jpg,0
+image_1575.jpg,0
+image_1576.jpg,0
+image_1579.jpg,1
+image_1580.jpg,1
+image_1589.jpg,0
+image_1590.jpg,0
+image_1591.jpg,1
+image_1592.jpg,1
+image_1594.jpg,1
+image_1595.jpg,1
+image_1598.jpg,0
+image_1599.jpg,0
+image_1607.jpg,1
+image_1608.jpg,1
+image_1609.jpg,1
+image_1610.jpg,1
+image_1616.jpg,0
+image_1623.jpg,0
+image_1624.jpg,0
+image_1625.jpg,0
+image_1626.jpg,0
+image_1644.jpg,0
+image_1645.jpg,0
+image_1652.jpg,0
+image_1653.jpg,0
+image_1686.jpg,0
+image_1687.jpg,0
+image_1691.jpg,0
+image_1692.jpg,0
+image_1693.jpg,0
+image_1694.jpg,0
+image_1695.jpg,0
+image_1696.jpg,0
+image_1697.jpg,1
+image_1698.jpg,1
+image_1699.jpg,1
+image_1700.jpg,1
+image_1701.jpg,1
+image_1702.jpg,1
+image_1703.jpg,0
+image_1704.jpg,0
+image_1710.jpg,1
+image_1711.jpg,1
+image_1712.jpg,1
+image_1713.jpg,1
+image_1714.jpg,1
+image_1715.jpg,1
+image_1716.jpg,0
+image_1717.jpg,0
+image_1722.jpg,0
+image_1723.jpg,0
+image_1724.jpg,0
+image_1742.jpg,1
+image_1745.jpg,0
+image_1746.jpg,0
+image_1747.jpg,1
+image_1748.jpg,1
+image_1759.jpg,0
+image_1760.jpg,0
+image_1765.jpg,0
+image_1766.jpg,0
+image_1767.jpg,0
+image_1768.jpg,0
+image_1786.jpg,1
+image_1787.jpg,1
+image_1788.jpg,1
+image_1789.jpg,0
+image_1790.jpg,0
+image_1791.jpg,0
+image_1796.jpg,1
+image_1797.jpg,1
+image_1798.jpg,1
+image_1799.jpg,1
+image_1824.jpg,0
+image_1825.jpg,0
+image_1842.jpg,0
+image_1843.jpg,0
+image_1844.jpg,0
+image_1845.jpg,0
+image_1847.jpg,0
+image_1860.jpg,1
+image_1861.jpg,1
+image_1862.jpg,1
+image_1865.jpg,0
+image_1866.jpg,0
+image_1874.jpg,1
+image_1875.jpg,1
+image_1876.jpg,1
+image_1877.jpg,1
+image_1892.jpg,1
+image_1893.jpg,1
+image_1894.jpg,1
+image_1895.jpg,1
+image_1896.jpg,1
+image_1897.jpg,1
+image_1898.jpg,1
+image_1899.jpg,1
+image_1901.jpg,1
+image_1902.jpg,1
+image_1903.jpg,0
+image_1904.jpg,0
+image_1912.jpg,0
+image_1913.jpg,0
+image_1914.jpg,0
+image_1915.jpg,0
+image_1916.jpg,0
+image_1917.jpg,0
+image_1922.jpg,0
+image_1923.jpg,0
+image_1924.jpg,0
+image_1925.jpg,0
+image_1926.jpg,0
+image_1927.jpg,0
+image_1931.jpg,1
+image_1932.jpg,1
+image_1933.jpg,1
+image_1934.jpg,1
+image_1935.jpg,1
+image_1938.jpg,0
+image_1939.jpg,0
+image_1940.jpg,0
+image_1941.jpg,0
+image_1956.jpg,1
+image_1957.jpg,1
+image_1958.jpg,0
+image_1959.jpg,0
+image_1960.jpg,0
+image_1961.jpg,0
+image_1977.jpg,0
+image_1978.jpg,0
+image_1981.jpg,0
+image_1982.jpg,0
+image_1999.jpg,1
+image_2000.jpg,1
+image_2001.jpg,1
+image_2002.jpg,1
+image_2019.jpg,1
+image_2020.jpg,1
+image_2022.jpg,0
+image_2028.jpg,0
+image_2030.jpg,0
+image_2031.jpg,0
+image_2032.jpg,1
+image_2033.jpg,1
+image_2034.jpg,1
+image_2035.jpg,1
+image_2036.jpg,1
+image_2037.jpg,1
+image_2039.jpg,0
+image_2041.jpg,1
+image_2042.jpg,1
+image_2045.jpg,0
+image_2046.jpg,0
+image_2047.jpg,1
+image_2048.jpg,1
+image_2049.jpg,1
+image_2050.jpg,1
+image_2064.jpg,0
+image_2065.jpg,0
+image_2078.jpg,0
+image_2084.jpg,0
+image_2085.jpg,0
+image_2097.jpg,0
+image_2101.jpg,0
+image_2102.jpg,0
+image_2110.jpg,0
+image_2111.jpg,0
+image_2116.jpg,0
+image_2117.jpg,0
+image_2124.jpg,0
+image_2125.jpg,0
+image_2139.jpg,0
+image_2140.jpg,1
+image_2141.jpg,1
+image_2142.jpg,1
+image_2143.jpg,1
+image_2144.jpg,1
+image_2146.jpg,1
+image_2147.jpg,1
+image_2148.jpg,1
+image_2149.jpg,1
+image_2151.jpg,0
+image_2152.jpg,0
+image_2154.jpg,0
+image_2155.jpg,0
+image_2156.jpg,0
+image_2162.jpg,0
+image_2163.jpg,0
+image_2164.jpg,0
+image_2170.jpg,0
+image_2171.jpg,0
+image_2172.jpg,0
+image_2173.jpg,0
+image_2188.jpg,0
+image_2189.jpg,0
+image_2199.jpg,0
+image_2200.jpg,0
+image_2201.jpg,1
+image_2202.jpg,1
+image_2209.jpg,0
+image_2210.jpg,0
+image_2211.jpg,0
+image_2212.jpg,0
+image_2215.jpg,0
+image_2216.jpg,0
+image_2217.jpg,0
+image_2218.jpg,0
+image_2219.jpg,0
+image_2220.jpg,0
+image_2223.jpg,0
+image_2225.jpg,0
+image_2226.jpg,0
+image_2229.jpg,1
+image_2230.jpg,1
+image_2231.jpg,1
+image_2232.jpg,1
+image_2234.jpg,0
+image_2244.jpg,0
+image_2245.jpg,0
+image_2246.jpg,0
+image_2247.jpg,0
+image_2248.jpg,0
+image_2249.jpg,0
+image_2276.jpg,1
+image_2277.jpg,1
+image_2278.jpg,0
+image_2279.jpg,0
+image_2289.jpg,0
+image_2290.jpg,0
+image_2291.jpg,0
+image_2292.jpg,0
+image_2299.jpg,0
+image_2300.jpg,0
+image_2303.jpg,0
+image_2304.jpg,0
+image_2307.jpg,1
+image_2308.jpg,1
+image_2309.jpg,0
+image_2310.jpg,0
+image_2313.jpg,1
+image_2314.jpg,1
+image_2315.jpg,0
+image_2316.jpg,0
+image_2319.jpg,0
+image_2320.jpg,0
+image_2321.jpg,1
+image_2322.jpg,1
+image_2326.jpg,0
+image_2327.jpg,0
+image_2345.jpg,1
+image_2346.jpg,1
+image_2354.jpg,0
+image_2355.jpg,0
+image_2359.jpg,0
+image_2360.jpg,0
+image_2361.jpg,0
+image_2362.jpg,0
+image_2363.jpg,0
+image_2364.jpg,0
+image_2365.jpg,0
+image_2366.jpg,0
+image_2367.jpg,1
+image_2368.jpg,1
+image_2375.jpg,0
+image_2376.jpg,0
+image_2402.jpg,1
+image_2403.jpg,1
+image_2404.jpg,1
+image_2407.jpg,0
+image_2408.jpg,0
+image_2411.jpg,1
+image_2412.jpg,1
+image_2413.jpg,0
+image_2414.jpg,0
+image_2417.jpg,0
+image_2418.jpg,0
+image_2421.jpg,0
+image_2423.jpg,0
+image_2424.jpg,0
+image_2425.jpg,0
+image_2426.jpg,1
+image_2430.jpg,0
+image_2431.jpg,0
+image_2434.jpg,0
+image_2435.jpg,0
+image_2436.jpg,0
+image_2437.jpg,0
+image_2455.jpg,1
+image_2456.jpg,1
+image_2457.jpg,1
+image_2458.jpg,1
+image_2459.jpg,1
+image_2470.jpg,1
+image_2471.jpg,1
+image_2473.jpg,1
+image_2474.jpg,0
+image_2475.jpg,0
+image_2482.jpg,0
+image_2483.jpg,0
+image_2503.jpg,0
+image_2504.jpg,0
+image_2505.jpg,1
+image_2507.jpg,0
+image_2512.jpg,1
+image_2513.jpg,0
+image_2514.jpg,0
+image_2515.jpg,0
+image_2516.jpg,0
+image_2523.jpg,0
+image_2524.jpg,0
+image_2525.jpg,0
+image_2526.jpg,0
+image_2527.jpg,0
+image_2528.jpg,0
+image_2529.jpg,1
+image_2530.jpg,1
+image_2531.jpg,1
+image_2532.jpg,1
+image_2533.jpg,1
+image_2534.jpg,1
+image_2550.jpg,0
+image_2551.jpg,0
+image_2552.jpg,0
+image_2553.jpg,0
+image_2554.jpg,0
+image_2555.jpg,0
+image_2558.jpg,0
+image_2559.jpg,0
+image_2562.jpg,1
+image_2563.jpg,1
+image_2564.jpg,1
+image_2565.jpg,1
+image_2566.jpg,1
+image_2567.jpg,1
+image_2569.jpg,0
+image_2570.jpg,0
+image_2571.jpg,0
+image_2572.jpg,0
+image_2573.jpg,0
+image_2574.jpg,0
+image_2575.jpg,0
+image_2576.jpg,0
+image_2577.jpg,0
+image_2578.jpg,0
+image_2579.jpg,0
+image_2588.jpg,0
+image_2589.jpg,0
+image_2602.jpg,1
+image_2605.jpg,1
+image_2606.jpg,1
+image_2607.jpg,0
+image_2608.jpg,0
+image_2611.jpg,0
+image_2612.jpg,0
+image_2622.jpg,0
+image_2623.jpg,0
+image_2651.jpg,0
+image_2652.jpg,0
+image_2654.jpg,0
+image_2655.jpg,1
+image_2656.jpg,1
+image_2658.jpg,1
+image_2661.jpg,1
+image_2662.jpg,1
+image_2668.jpg,0
+image_2669.jpg,0
+image_2676.jpg,0
+image_2677.jpg,0
+image_2685.jpg,0
+image_2686.jpg,0
+image_2687.jpg,0
+image_2688.jpg,0
+image_2689.jpg,0
+image_2690.jpg,0
+image_2691.jpg,0
+image_2692.jpg,0
+image_2693.jpg,0
+image_2694.jpg,0
+image_2695.jpg,0
+image_2698.jpg,0
+image_2699.jpg,0
+image_2700.jpg,0
+image_2701.jpg,0
+image_2702.jpg,0
+image_2703.jpg,0
+image_2707.jpg,0
+image_2708.jpg,0
+image_2709.jpg,0
+image_2710.jpg,0
+image_2711.jpg,0
+image_2712.jpg,0
+image_2713.jpg,0
+image_2714.jpg,0
+image_2728.jpg,0
+image_2729.jpg,0
+image_2730.jpg,1
+image_2731.jpg,1
+image_2732.jpg,1
+image_2733.jpg,1
+image_2734.jpg,1
+image_2735.jpg,1
+image_2736.jpg,0
+image_2737.jpg,0
+image_2738.jpg,1
+image_2739.jpg,1
+image_2765.jpg,0
+image_2766.jpg,0
+image_2767.jpg,0
+image_2768.jpg,0
+image_2781.jpg,1
+image_2782.jpg,1
+image_2783.jpg,1
+image_2784.jpg,1
+image_2785.jpg,0
+image_2786.jpg,0
+image_2787.jpg,0
+image_2788.jpg,0
+image_2795.jpg,0
+image_2796.jpg,0
+image_2805.jpg,0
+image_2806.jpg,0
+image_2807.jpg,0
+image_2808.jpg,0
+image_2809.jpg,1
+image_2810.jpg,1
+image_2823.jpg,0
+image_2824.jpg,0
+image_2825.jpg,0
+image_2826.jpg,0
+image_2827.jpg,0
+image_2828.jpg,0
+image_2839.jpg,0
+image_2840.jpg,0
+image_2856.jpg,0
+image_2857.jpg,0
+image_2860.jpg,1
+image_2861.jpg,1
+image_2880.jpg,0
+image_2881.jpg,0
+image_2885.jpg,0
+image_2886.jpg,0
+image_2887.jpg,0
+image_2888.jpg,0
+image_2891.jpg,0
+image_2892.jpg,0
+image_2897.jpg,0
+image_2898.jpg,0
+image_2899.jpg,0
+image_2900.jpg,0
+image_2901.jpg,0
+image_2902.jpg,0
+image_2906.jpg,0
+image_2912.jpg,0
+image_2913.jpg,0
+image_2914.jpg,0
+image_2915.jpg,0
+image_2916.jpg,0
+image_2917.jpg,0
+image_2935.jpg,0
+image_2936.jpg,0
+image_2941.jpg,0
+image_2942.jpg,0
+image_2945.jpg,0
+image_2946.jpg,0
+image_2947.jpg,0
+image_2949.jpg,0
+image_2950.jpg,0
+image_2956.jpg,0
+image_2957.jpg,0
+image_2970.jpg,0
+image_2971.jpg,0
+image_2972.jpg,1
+image_2973.jpg,1
+image_2974.jpg,0
+image_2975.jpg,0
+image_2980.jpg,0
+image_2981.jpg,0
+image_2984.jpg,0
+image_2985.jpg,0
+image_2991.jpg,0
+image_2992.jpg,0
+image_2998.jpg,0
+image_2999.jpg,0
+image_3000.jpg,0
+image_3017.jpg,0
+image_3018.jpg,0
+image_3019.jpg,0
+image_3020.jpg,0
+image_3021.jpg,0
+image_3022.jpg,0
+image_3023.jpg,1
+image_3024.jpg,1
+image_3025.jpg,1
+image_3026.jpg,1
+image_3029.jpg,0
+image_3038.jpg,1
+image_3039.jpg,1
+image_3040.jpg,0
+image_3041.jpg,0
+image_3044.jpg,0
+image_3045.jpg,0
+image_3058.jpg,0
+image_3059.jpg,0
+image_3064.jpg,1
+image_3065.jpg,1
+image_3066.jpg,1
+image_3067.jpg,1
+image_3076.jpg,0
+image_3080.jpg,1
+image_3081.jpg,1
+image_3082.jpg,0
+image_3084.jpg,1
+image_3085.jpg,1
+image_3090.jpg,1
+image_3091.jpg,1
+image_3116.jpg,0
+image_3117.jpg,0
+image_3120.jpg,0
+image_3121.jpg,0
+image_3122.jpg,1
+image_3123.jpg,1
+image_3124.jpg,0
+image_3129.jpg,0
+image_3130.jpg,0
+image_3131.jpg,0
+image_3132.jpg,0
+image_3137.jpg,0
+image_3138.jpg,0
+image_3143.jpg,1
+image_3144.jpg,1
+image_3159.jpg,0
+image_3160.jpg,0
+image_3163.jpg,1
+image_3164.jpg,1
+image_3165.jpg,1
+image_3166.jpg,1
+image_3167.jpg,1
+image_3168.jpg,1
+image_3169.jpg,0
+image_3170.jpg,0
+image_3182.jpg,1
+image_3183.jpg,1
+image_3184.jpg,1
+image_3185.jpg,1
+image_3198.jpg,0
+image_3199.jpg,0
+image_3201.jpg,1
+image_3202.jpg,1
+image_2568.jpg,0