{"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.10.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":14774,"databundleVersionId":875431,"sourceType":"competition"}],"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true},"papermill":{"default_parameters":{},"duration":7982.960704,"end_time":"2024-08-14T04:06:42.231674","environment_variables":{},"exception":null,"input_path":"__notebook__.ipynb","output_path":"__notebook__.ipynb","parameters":{},"start_time":"2024-08-14T01:53:39.270970","version":"2.5.0"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# import numpy as np\n# import pandas as pd\n# import tensorflow as tf\n# from tensorflow.keras.applications import EfficientNetV2S, DenseNet201\n# from tensorflow.keras.models import Model\n# from tensorflow.keras.layers import Dense, GlobalAveragePooling2D, Dropout, concatenate, Input, BatchNormalization\n# from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\n# from tensorflow.keras.optimizers import Adam\n# from sklearn.model_selection import StratifiedKFold\n# from sklearn.preprocessing import LabelEncoder\n# import cv2\n# import albumentations as A\n\n# # Load and preprocess data\n# train_df = pd.read_csv('/kaggle/input/aptos2019-blindness-detection/train.csv')\n# train_df['diagnosis'] = train_df['diagnosis'].astype(str)\n# train_df['id_code'] = train_df['id_code'].apply(lambda x: f\"{x}.png\")\n\n# # Label encoding\n# le = LabelEncoder()\n# train_df['diagnosis'] = le.fit_transform(train_df['diagnosis'])\n\n# def preprocess_image(image_path, target_size=(380, 380)):\n#     img = cv2.imread(image_path)\n#     img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n    \n#     # Apply CLAHE\n#     lab = cv2.cvtColor(img, cv2.COLOR_RGB2LAB)\n#     l, a, b = cv2.split(lab)\n#     clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))\n#     cl = clahe.apply(l)\n#     limg = cv2.merge((cl,a,b))\n#     img = cv2.cvtColor(limg, cv2.COLOR_LAB2RGB)\n    \n#     # Resize\n#     img = cv2.resize(img, target_size)\n    \n#     return img  # Return uint8 image\n\n# # Augmentation pipeline\n# aug_pipeline = A.Compose([\n#     A.RandomRotate90(),\n#     A.Flip(),\n#     A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=45),\n#     A.OneOf([\n#         A.OpticalDistortion(p=0.3),\n#         A.GridDistortion(p=0.1),\n#         A.ElasticTransform(p=0.3),\n#     ], p=0.2),\n#     A.OneOf([\n#         A.GaussNoise(),\n#         A.ISONoise(),\n#         A.MultiplicativeNoise(),\n#     ], p=0.2),\n#     A.OneOf([\n#         A.MotionBlur(p=0.2),\n#         A.MedianBlur(blur_limit=3, p=0.1),\n#         A.Blur(blur_limit=3, p=0.1),\n#     ], p=0.2),\n#     A.OneOf([\n#         A.Sharpen(),\n#         A.Emboss(),\n#         A.RandomBrightnessContrast(),\n#     ], p=0.3),\n#     A.HueSaturationValue(p=0.3),\n#     A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n# ])\n\n# def custom_generator(dataframe, batch_size, augment=True, shuffle=True):\n#     while True:\n#         if shuffle:\n#             dataframe = dataframe.sample(frac=1).reset_index(drop=True)\n        \n#         for start in range(0, len(dataframe), batch_size):\n#             end = min(start + batch_size, len(dataframe))\n#             batch_df = dataframe.iloc[start:end]\n            \n#             batch_images = []\n#             batch_labels = []\n            \n#             for _, row in batch_df.iterrows():\n#                 img_path = f\"/kaggle/input/aptos2019-blindness-detection/train_images/{row['id_code']}\"\n#                 img = preprocess_image(img_path)\n                \n#                 if augment:\n#                     augmented = aug_pipeline(image=img)\n#                     img = augmented['image']\n#                 else:\n#                     img = aug_pipeline(image=img)['image']  # Only normalize\n                \n#                 batch_images.append(img)\n#                 batch_labels.append(row['diagnosis'])\n            \n#             yield np.array(batch_images), np.array(batch_labels)\n\n# # Create model\n# def create_model(input_shape=(380, 380, 3), num_classes=5):\n#     input_tensor = Input(shape=input_shape)\n    \n#     # EfficientNetV2S\n#     base_model_1 = EfficientNetV2S(weights='imagenet', include_top=False, input_tensor=input_tensor)\n#     x1 = base_model_1.output\n#     x1 = GlobalAveragePooling2D()(x1)\n#     x1 = BatchNormalization()(x1)\n#     x1 = Dropout(0.5)(x1)\n#     x1 = Dense(512, activation='relu')(x1)\n#     x1 = BatchNormalization()(x1)\n#     x1 = Dropout(0.3)(x1)\n    \n#     # DenseNet201\n#     base_model_2 = DenseNet201(weights='imagenet', include_top=False, input_tensor=input_tensor)\n#     x2 = base_model_2.output\n#     x2 = GlobalAveragePooling2D()(x2)\n#     x2 = BatchNormalization()(x2)\n#     x2 = Dropout(0.5)(x2)\n#     x2 = Dense(512, activation='relu')(x2)\n#     x2 = BatchNormalization()(x2)\n#     x2 = Dropout(0.3)(x2)\n    \n#     # Combine outputs\n#     combined = concatenate([x1, x2])\n#     combined = Dense(256, activation='relu')(combined)\n#     combined = BatchNormalization()(combined)\n#     combined = Dropout(0.3)(combined)\n#     output = Dense(num_classes, activation='softmax')(combined)\n    \n#     model = Model(inputs=input_tensor, outputs=output)\n#     return model\n\n# # Implement k-fold cross-validation\n# n_splits = 2\n# skf = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=42)\n\n# for fold, (train_idx, val_idx) in enumerate(skf.split(train_df, train_df['diagnosis']), 1):\n#     print(f\"Training Fold {fold}\")\n    \n#     train_fold = train_df.iloc[train_idx]\n#     val_fold = train_df.iloc[val_idx]\n    \n#     model = create_model()\n    \n#     # Compile model\n#     optimizer = Adam(learning_rate=0.0001)\n#     model.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy'])\n    \n#     # Callbacks\n#     callbacks = [\n#         EarlyStopping(patience=10, restore_best_weights=True),\n#         ModelCheckpoint(f'best_model_fold_{fold}.keras', save_best_only=True),\n#         ReduceLROnPlateau(factor=0.5, patience=5, min_lr=1e-6)\n#     ]\n    \n#     # Train model\n#     batch_size = 16\n#     train_generator = custom_generator(train_fold, batch_size)\n#     val_generator = custom_generator(val_fold, batch_size, augment=False, shuffle=False)\n    \n#     history = model.fit(\n#         train_generator,\n#         steps_per_epoch=len(train_fold) // batch_size,\n#         validation_data=val_generator,\n#         validation_steps=len(val_fold) // batch_size,\n#         epochs=100,\n#         callbacks=callbacks,\n#         verbose=2\n#     )\n    \n#     # Print fold results\n#     print(f\"Fold {fold} - Best validation accuracy: {max(history.history['val_accuracy'])}\")\n\n# # After all folds, you can ensemble the models for final predictions\n# print(\"Training completed for all folds.\")","metadata":{"execution":{"iopub.status.busy":"2024-09-03T02:56:04.553079Z","iopub.execute_input":"2024-09-03T02:56:04.553414Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport tensorflow as tf\nfrom tensorflow.keras.applications import EfficientNetV2S, DenseNet201\nfrom tensorflow.keras.models import Model\nfrom tensorflow.keras.layers import Dense, GlobalAveragePooling2D, Dropout, concatenate, Input, BatchNormalization\nfrom tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\nfrom tensorflow.keras.optimizers import Adam\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.preprocessing import LabelEncoder\nimport os\nimport pickle\n\n# Use GPU if available, otherwise use CPU\ngpus = tf.config.experimental.list_physical_devices('GPU')\nif gpus:\n    try:\n        for gpu in gpus:\n            tf.config.experimental.set_memory_growth(gpu, True)\n        print(\"Using GPU\")\n    except RuntimeError as e:\n        print(e)\nelse:\n    print(\"Using CPU\")\n\n# Load and preprocess data\ntrain_df = pd.read_csv('/kaggle/input/aptos2019-blindness-detection/train.csv')\ntrain_df['diagnosis'] = train_df['diagnosis'].astype(str)\ntrain_df['id_code'] = train_df['id_code'].apply(lambda x: f\"{x}.png\")\n\n# Label encoding\nle = LabelEncoder()\ntrain_df['diagnosis'] = le.fit_transform(train_df['diagnosis'])\n\ndef preprocess_image(image_path, label):\n    img = tf.io.read_file(image_path)\n    img = tf.image.decode_png(img, channels=3)\n    img = tf.image.resize(img, (380, 380))\n    img = tf.cast(img, tf.float32) / 255.0\n    return img, label\n\ndef augment(image, label):\n    image = tf.image.random_flip_left_right(image)\n    image = tf.image.random_flip_up_down(image)\n    image = tf.image.random_brightness(image, max_delta=0.2)\n    image = tf.image.random_contrast(image, lower=0.8, upper=1.2)\n    image = tf.image.random_saturation(image, lower=0.8, upper=1.2)\n    image = tf.image.random_hue(image, max_delta=0.2)\n    return image, label\n\ndef create_dataset(dataframe, batch_size, is_training=True):\n    image_paths = tf.constant([f\"/kaggle/input/aptos2019-blindness-detection/train_images/{filename}\" for filename in dataframe['id_code']])\n    labels = tf.constant(dataframe['diagnosis'].values, dtype=tf.int32)\n\n    dataset = tf.data.Dataset.from_tensor_slices((image_paths, labels))\n    dataset = dataset.map(preprocess_image, num_parallel_calls=tf.data.AUTOTUNE)\n\n    if is_training:\n        dataset = dataset.map(augment, num_parallel_calls=tf.data.AUTOTUNE)\n        dataset = dataset.shuffle(buffer_size=len(dataframe))\n\n    dataset = dataset.batch(batch_size)\n    dataset = dataset.prefetch(tf.data.AUTOTUNE)\n    return dataset\n\ndef create_model(input_shape=(380, 380, 3), num_classes=5):\n    input_tensor = Input(shape=input_shape)\n\n    base_model_1 = EfficientNetV2S(weights='imagenet', include_top=False, input_tensor=input_tensor)\n    x1 = GlobalAveragePooling2D()(base_model_1.output)\n    x1 = BatchNormalization()(x1)\n    x1 = Dropout(0.5)(x1)\n    x1 = Dense(512, activation='relu')(x1)\n    x1 = BatchNormalization()(x1)\n    x1 = Dropout(0.3)(x1)\n\n    base_model_2 = DenseNet201(weights='imagenet', include_top=False, input_tensor=input_tensor)\n    x2 = GlobalAveragePooling2D()(base_model_2.output)\n    x2 = BatchNormalization()(x2)\n    x2 = Dropout(0.5)(x2)\n    x2 = Dense(512, activation='relu')(x2)\n    x2 = BatchNormalization()(x2)\n    x2 = Dropout(0.3)(x2)\n\n    combined = concatenate([x1, x2])\n    combined = Dense(256, activation='relu')(combined)\n    combined = BatchNormalization()(combined)\n    combined = Dropout(0.3)(combined)\n    output = Dense(num_classes, activation='softmax')(combined)\n\n    model = Model(inputs=input_tensor, outputs=output)\n    return model\n\n# Implement k-fold cross-validation\nn_splits = 2\nskf = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=42)\n\nfor fold, (train_idx, val_idx) in enumerate(skf.split(train_df, train_df['diagnosis']), 1):\n    print(f\"Training Fold {fold}\")\n\n    train_fold = train_df.iloc[train_idx].reset_index(drop=True)\n    val_fold = train_df.iloc[val_idx].reset_index(drop=True)\n\n    model = create_model()\n    optimizer = Adam(learning_rate=0.0001)\n    model.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy'])\n\n    # Callbacks\n    callbacks = [\n        EarlyStopping(patience=15, restore_best_weights=True),\n        ModelCheckpoint(f'best_model_fold_{fold}.keras', save_best_only=True),\n        ReduceLROnPlateau(factor=0.5, patience=7, min_lr=1e-6)\n    ]\n\n    # Create datasets\n    batch_size = 16  # Adjust based on your GPU memory\n    train_dataset = create_dataset(train_fold, batch_size)\n    val_dataset = create_dataset(val_fold, batch_size, is_training=False)\n\n    # Train model\n    try:\n        history = model.fit(\n            train_dataset,\n            validation_data=val_dataset,\n            epochs=20,\n            callbacks=callbacks,\n            steps_per_epoch=len(train_fold) // batch_size,\n            validation_steps=len(val_fold) // batch_size,\n            verbose=2\n        )\n\n        # Print fold results\n        print(f\"Fold {fold} - Best validation accuracy: {max(history.history['val_accuracy'])}\")\n\n        # Save the model using Keras's save method\n        model.save(f'best_model_fold_{fold}.keras')\n\n        # Serialize the saved model using pickle\n        with open(f'best_model_fold_{fold}.pkl', 'wb') as f:\n            pickle.dump(model, f)\n\n    except Exception as e:\n        print(f\"An error occurred during training fold {fold}: {str(e)}\")\n        continue\n\nprint(\"Training completed for all folds.\")\n","metadata":{"execution":{"iopub.status.busy":"2025-03-11T20:36:32.552318Z","iopub.execute_input":"2025-03-11T20:36:32.552625Z","execution_failed":"2025-03-11T20:51:12.577Z"},"trusted":true,"scrolled":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"pip install ","metadata":{},"outputs":[],"execution_count":null}]}