{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":13836,"databundleVersionId":1718836,"sourceType":"competition"},{"sourceId":778,"sourceType":"modelInstanceVersion","modelInstanceId":645,"modelId":55},{"sourceId":779,"sourceType":"modelInstanceVersion","isSourceIdPinned":true,"modelInstanceId":646,"modelId":55},{"sourceId":159893,"sourceType":"modelInstanceVersion","modelInstanceId":135937,"modelId":158661},{"sourceId":160164,"sourceType":"modelInstanceVersion","modelInstanceId":136177,"modelId":158894},{"sourceId":160168,"sourceType":"modelInstanceVersion","modelInstanceId":136181,"modelId":158898},{"sourceId":160170,"sourceType":"modelInstanceVersion","modelInstanceId":136183,"modelId":158900},{"sourceId":160733,"sourceType":"modelInstanceVersion","modelInstanceId":136673,"modelId":159399},{"sourceId":170146,"sourceType":"modelInstanceVersion","isSourceIdPinned":true,"modelInstanceId":144763,"modelId":167320}],"dockerImageVersionId":30787,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# # This Python 3 environment comes with many helpful analytics libraries installed\n# # It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# # For example, here's several helpful packages to load\n\n# import numpy as np # linear algebra\n# import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# # Input data files are available in the read-only \"../input/\" directory\n# # For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\n# import os\n# for dirname, _, filenames in os.walk('/kaggle/input'):\n#     for filename in filenames:\n#         print(os.path.join(dirname, filename))\n\n# # You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# # You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:43:39.345715Z","iopub.execute_input":"2024-11-16T08:43:39.347108Z","iopub.status.idle":"2024-11-16T08:43:39.353534Z","shell.execute_reply.started":"2024-11-16T08:43:39.347038Z","shell.execute_reply":"2024-11-16T08:43:39.351999Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import os\nimport re\nfrom datetime import datetime\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nimport tensorflow as tf\nimport tensorflow_hub as hub","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-18T02:16:31.441257Z","iopub.execute_input":"2024-11-18T02:16:31.441899Z","iopub.status.idle":"2024-11-18T02:16:46.769920Z","shell.execute_reply.started":"2024-11-18T02:16:31.441852Z","shell.execute_reply":"2024-11-18T02:16:46.769099Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from sklearn.model_selection import train_test_split\nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator\nimport matplotlib.pyplot as plt\nfrom tensorflow.keras.applications.efficientnet import preprocess_input\nfrom tensorflow.keras.applications import EfficientNetB0\nfrom tensorflow.keras.layers import Dense, GlobalAveragePooling2D\nfrom tensorflow.keras.models import Model\nfrom sklearn.preprocessing import LabelEncoder\n\nlabel_to_disease = pd.read_json('/kaggle/input/cassava-leaf-disease-classification/label_num_to_disease_map.json', typ='series')\ntrain_csv = pd.read_csv('/kaggle/input/cassava-leaf-disease-classification/train.csv')\n\ntrain_csv['disease'] = train_csv['label'].map(label_to_disease)\ntrain_csv['path'] = '/kaggle/input/cassava-leaf-disease-classification/train_images/' + train_csv['image_id']\n\ntrain_csv['label_encoded'] = LabelEncoder().fit_transform(train_csv['disease'])\n\n# Convert 'disease' and 'label' columns to string type\ntrain_csv['disease'] = train_csv['disease'].astype(str)\ntrain_csv['label'] = train_csv['label'].astype(str)\n\n# Split the data into train and validation sets with stratified sampling\ntrain, valid = train_test_split(train_csv, test_size=0.2, stratify=train_csv['label'])\n\n\n# Data augmentation and preprocessing for training\ndatagen_aug = ImageDataGenerator(\n    preprocessing_function=preprocess_input,\n    rotation_range=45,\n    width_shift_range=0.2,\n    height_shift_range=0.2,\n    shear_range=0.2,\n    zoom_range=0.2,\n    horizontal_flip=True,\n    vertical_flip=True,\n    fill_mode='nearest'\n)\n\n# Generator for the training set\ntrain_generator = datagen_aug.flow_from_dataframe(\n    dataframe=train,\n    x_col='path',\n    y_col='disease',\n    target_size=(224, 224),\n    batch_size=32,\n    class_mode='categorical',\n    shuffle=True\n)\n\n# Generator for the validation set without augmentation\ndatagen_valid = ImageDataGenerator(preprocessing_function=preprocess_input)\n\nvalid_generator = datagen_valid.flow_from_dataframe(\n    dataframe=valid,\n    x_col='path',\n    y_col='disease',\n    target_size=(224, 224),\n    batch_size=32,\n    class_mode='categorical',\n    shuffle=False\n)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-18T02:17:53.790221Z","iopub.execute_input":"2024-11-18T02:17:53.790533Z","iopub.status.idle":"2024-11-18T02:18:03.044474Z","shell.execute_reply.started":"2024-11-18T02:17:53.790500Z","shell.execute_reply":"2024-11-18T02:18:03.043724Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def load_and_preprocess_image(path, label):\n    image = tf.io.read_file(path)\n    image = tf.image.decode_jpeg(image, channels=3)  # Assuming the images are JPEGs\n    image = tf.image.resize(image, [224, 224])  # Resize to the expected input size\n    image = image / 255.0  # Normalize to [0, 1]\n    return image, label\n\n# Create datasets\ntrain_ds = tf.data.Dataset.from_tensor_slices((train['path'].values, train['label_encoded'].values))\nvalid_ds = tf.data.Dataset.from_tensor_slices((valid['path'].values, valid['label_encoded'].values))\n\n# Map the loading and preprocessing function to the datasets\ntrain_ds = train_ds.map(load_and_preprocess_image).batch(32).prefetch(buffer_size=tf.data.experimental.AUTOTUNE)\nvalid_ds = valid_ds.map(load_and_preprocess_image).batch(32).prefetch(buffer_size=tf.data.experimental.AUTOTUNE)\n\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-18T02:18:03.046441Z","iopub.execute_input":"2024-11-18T02:18:03.046779Z","iopub.status.idle":"2024-11-18T02:18:03.777750Z","shell.execute_reply.started":"2024-11-18T02:18:03.046745Z","shell.execute_reply":"2024-11-18T02:18:03.776983Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from tensorflow.keras.models import Model, load_model\nfrom tensorflow.keras.preprocessing.image import load_img, img_to_array\nfrom tensorflow.keras.layers import Dense\nfrom tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, Callback\nfrom tensorflow.keras.applications import DenseNet169, EfficientNetB4\nfrom tensorflow.keras.layers import Dense, Input, Lambda\nfrom tensorflow.keras.models import Model\n\nclass EarlyStoppingCallback(Callback):\n    def on_epoch_end(self, epoch, logs=None):\n        # Check if early stopping has been triggered by checking if patience has run out\n        if self.model.stop_training:\n            print(f\"Early stopping triggered at epoch {epoch + 1}.\")\n\nearly_stopping = EarlyStopping(\n    monitor='val_loss', \n    patience=3, \n    restore_best_weights=True\n)\n\nlearning_rate_reduction = tf.keras.callbacks.ReduceLROnPlateau(\n    monitor='val_loss', \n    patience=2, \n    factor=0.5, \n    min_lr=1e-6, \n    verbose=1\n)\n\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-18T02:18:03.779131Z","iopub.execute_input":"2024-11-18T02:18:03.779435Z","iopub.status.idle":"2024-11-18T02:18:03.788548Z","shell.execute_reply.started":"2024-11-18T02:18:03.779401Z","shell.execute_reply":"2024-11-18T02:18:03.787749Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# # # Define the URL for the pretrained feature extractor\n# # TF2 version\n# import tensorflow.compat.v2 as tf\n# import tensorflow_hub as hub\n\n# cropnet_classifier = hub.KerasLayer('/kaggle/input/cropnet/tensorflow1/classifier-cassava-disease-v1/1', output_key='image_classifier:logits')\n# # model_url = 'https://tfhub.dev/google/cropnet/classifier/cassava_disease_V1/2'\n# # cropnet_classifier = hub.KerasLayer(model_url, trainable=True)  # Enable fine-tuning for the entire layer\n\n# # Define the model architecture\n# input_layer = Input(shape=(224, 224, 3))\n# cropnet_features = Lambda(lambda x: cropnet_classifier(x), output_shape=(6,))(input_layer)\n\n# # Add classification layers\n# x = Dense(512, activation='relu')(cropnet_features)\n# x = Dense(256, activation='relu')(x)\n# x = Dense(128, activation='relu')(x)\n# output = Dense(5, activation='softmax')(x)\n\n# cropnet_model = Model(inputs=input_layer, outputs=output)\n\n# cropnet_model.compile(\n#         optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5), # Change1: Apply Lower LR\n#         loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),\n#         metrics=['accuracy']\n    \n# )\n\n# # # DenseNet169 Model\n# # densenet_model = DenseNet169(weights='imagenet', include_top=False, input_shape=(224, 224, 3))\n# # x = GlobalAveragePooling2D()(densenet_model.output)\n# # x = Dense(512, activation='relu')(x)\n# # output = Dense(5, activation='softmax')(x)\n# # densenet_model = Model(inputs=densenet_model.input, outputs=output)\n\n# # # EfficientNetB4 Model\n# # efficientnet_model = EfficientNetB4(weights='imagenet', include_top=False, input_shape=(224, 224, 3))\n# # x = GlobalAveragePooling2D()(efficientnet_model.output)\n# # x = Dense(512, activation='relu')(x)\n# # output = Dense(5, activation='softmax')(x)\n# # efficientnet_model = Model(inputs=efficientnet_model.input, outputs=output)\n\n\n# # # Compile models with a low learning rate for fine-tuning\n# # for model in [cropnet_model, densenet_model, efficientnet_model]:\n# #     model.compile(\n# #         optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5), # Change1: Apply Lower LR\n# #         loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),\n# #         metrics=['accuracy']\n# #     )","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-18T02:24:02.659182Z","iopub.execute_input":"2024-11-18T02:24:02.659560Z","iopub.status.idle":"2024-11-18T02:24:03.839536Z","shell.execute_reply.started":"2024-11-18T02:24:02.659527Z","shell.execute_reply":"2024-11-18T02:24:03.838732Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"# # Train each model separately with the ImageDataGenerator\n# history_cropnet = cropnet_model.fit(\n#     train_ds,\n#     validation_data=valid_ds,\n#     epochs=30,\n#     callbacks=[early_stopping, learning_rate_reduction]\n# )\n\n\n\n\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-18T02:24:05.964187Z","iopub.execute_input":"2024-11-18T02:24:05.964606Z","iopub.status.idle":"2024-11-18T02:40:13.745749Z","shell.execute_reply.started":"2024-11-18T02:24:05.964569Z","shell.execute_reply":"2024-11-18T02:40:13.744890Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# history_densenet = densenet_model.fit(\n#     train_ds,\n#     validation_data=valid_ds,\n#     epochs=10,\n#     callbacks=[early_stopping, learning_rate_reduction]\n# )","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:16.425254Z","iopub.execute_input":"2024-11-16T08:45:16.425627Z","iopub.status.idle":"2024-11-16T08:45:16.439264Z","shell.execute_reply.started":"2024-11-16T08:45:16.425590Z","shell.execute_reply":"2024-11-16T08:45:16.437871Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# history_efficientnet = efficientnet_model.fit(\n#     train_ds,\n#     validation_data=valid_ds,\n#     epochs=30,\n#     callbacks=[early_stopping, learning_rate_reduction]\n# )","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:16.441146Z","iopub.execute_input":"2024-11-16T08:45:16.441635Z","iopub.status.idle":"2024-11-16T08:45:16.456622Z","shell.execute_reply.started":"2024-11-16T08:45:16.441581Z","shell.execute_reply":"2024-11-16T08:45:16.455269Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"retrain efficientnet and densenet","metadata":{}},{"cell_type":"code","source":"# # # Define the URL for the pretrained feature extractor\n# from tensorflow.keras.layers import Dense, GlobalAveragePooling2D, Dropout, BatchNormalization\n# from tensorflow.keras.models import Model\n# model_url = 'https://tfhub.dev/google/cropnet/classifier/cassava_disease_V1/2'\n# cropnet_classifier = hub.KerasLayer(model_url, trainable=True)  # Enable fine-tuning for the entire layer\n\n# # Define the model architecture\n# input_layer = Input(shape=(224, 224, 3))\n# cropnet_features = Lambda(lambda x: cropnet_classifier(x), output_shape=(6,))(input_layer)\n\n# # Add classification layers\n# x = Dense(512, activation='relu')(cropnet_features)\n# x = Dense(256, activation='relu')(x)\n# x = Dense(128, activation='relu')(x)\n# output = Dense(5, activation='softmax')(x)\n\n# cropnet_model = Model(inputs=input_layer, outputs=output)\n\n# # Improved DenseNet169 Model\n# densenet_model_base = DenseNet169(weights='imagenet', include_top=False, input_shape=(224, 224, 3))\n# x = GlobalAveragePooling2D()(densenet_model_base.output)\n# x = BatchNormalization()(x)\n# x = Dense(1024, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.001))(x)\n# x = Dropout(0.5)(x)\n# x = Dense(512, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.001))(x)\n# x = Dropout(0.5)(x)\n# output = Dense(5, activation='softmax')(x)\n# densenet_model = Model(inputs=densenet_model_base.input, outputs=output)\n\n# # Improved EfficientNetB4 Model\n# efficientnet_model_base = EfficientNetB4(weights='imagenet', include_top=False, input_shape=(224, 224, 3))\n# x = GlobalAveragePooling2D()(efficientnet_model_base.output)\n# x = BatchNormalization()(x)\n# x = Dense(1024, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.001))(x)\n# x = Dropout(0.5)(x)\n# x = Dense(512, activation='relu', kernel_regularizer=tf.keras.regularizers.l2(0.001))(x)\n# x = Dropout(0.5)(x)\n# output = Dense(5, activation='softmax')(x)\n# efficientnet_model = Model(inputs=efficientnet_model_base.input, outputs=output)\n\n# # Unfreeze the last few layers for fine-tuning\n# for layer in densenet_model_base.layers[-20:]:  # Adjust the number of layers to unfreeze if needed\n#     layer.trainable = True\n\n# # Unfreeze the last few layers for fine-tuning\n# for layer in efficientnet_model_base.layers[-20:]:  # Adjust the number of layers to unfreeze if needed\n#     layer.trainable = True\n\n\n# # Compile models with a low learning rate for fine-tuning\n# for model in [cropnet_model, densenet_model, efficientnet_model]:\n#     model.compile(\n#         optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5), # Change1: Apply Lower LR\n#         loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),\n#         metrics=['accuracy']\n#     )","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:16.461891Z","iopub.execute_input":"2024-11-16T08:45:16.462427Z","iopub.status.idle":"2024-11-16T08:45:16.471555Z","shell.execute_reply.started":"2024-11-16T08:45:16.462385Z","shell.execute_reply":"2024-11-16T08:45:16.470204Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# history_densenet = densenet_model.fit(\n#     train_ds,\n#     validation_data=valid_ds,\n#     epochs=30,\n#     callbacks=[early_stopping, learning_rate_reduction]\n# )","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:16.474059Z","iopub.execute_input":"2024-11-16T08:45:16.474608Z","iopub.status.idle":"2024-11-16T08:45:16.492933Z","shell.execute_reply.started":"2024-11-16T08:45:16.474552Z","shell.execute_reply":"2024-11-16T08:45:16.491325Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# history_efficientnet = efficientnet_model.fit(\n#     train_ds,\n#     validation_data=valid_ds,\n#     epochs=100,\n#     callbacks=[early_stopping, learning_rate_reduction]\n# )","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:16.494754Z","iopub.execute_input":"2024-11-16T08:45:16.495312Z","iopub.status.idle":"2024-11-16T08:45:16.507158Z","shell.execute_reply.started":"2024-11-16T08:45:16.495256Z","shell.execute_reply":"2024-11-16T08:45:16.505868Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# # save models\n\n# cropnet_model.export('/kaggle/working/cropnet_model_tf')\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-18T02:40:13.747347Z","iopub.execute_input":"2024-11-18T02:40:13.747696Z","iopub.status.idle":"2024-11-18T02:40:15.049664Z","shell.execute_reply.started":"2024-11-18T02:40:13.747643Z","shell.execute_reply":"2024-11-18T02:40:15.048729Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# densenet_model.export('kaggle/working/densenet_model_tf')\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:16.521656Z","iopub.execute_input":"2024-11-16T08:45:16.522170Z","iopub.status.idle":"2024-11-16T08:45:16.533315Z","shell.execute_reply.started":"2024-11-16T08:45:16.522116Z","shell.execute_reply":"2024-11-16T08:45:16.532075Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# efficientnet_model.export('kaggle/working/efficientnet_model_tf')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:16.534814Z","iopub.execute_input":"2024-11-16T08:45:16.535464Z","iopub.status.idle":"2024-11-16T08:45:16.545054Z","shell.execute_reply.started":"2024-11-16T08:45:16.535418Z","shell.execute_reply":"2024-11-16T08:45:16.543836Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# !zip -r /kaggle/working/cropnet_model.zip /kaggle/working/cropnet_model_tf","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-18T02:43:31.683130Z","iopub.execute_input":"2024-11-18T02:43:31.683575Z","iopub.status.idle":"2024-11-18T02:43:33.698222Z","shell.execute_reply.started":"2024-11-18T02:43:31.683534Z","shell.execute_reply":"2024-11-18T02:43:33.697280Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# !zip -r /kaggle/working/densenet_model.zip /kaggle/working/kaggle/working/densenet_model_tf","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:16.560130Z","iopub.execute_input":"2024-11-16T08:45:16.560636Z","iopub.status.idle":"2024-11-16T08:45:16.570447Z","shell.execute_reply.started":"2024-11-16T08:45:16.560582Z","shell.execute_reply":"2024-11-16T08:45:16.569148Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# !zip -r /kaggle/working/efficientnet_model.zip /kaggle/working/kaggle/working/efficientnet_model_tf","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:16.571837Z","iopub.execute_input":"2024-11-16T08:45:16.572239Z","iopub.status.idle":"2024-11-16T08:45:16.583800Z","shell.execute_reply.started":"2024-11-16T08:45:16.572198Z","shell.execute_reply":"2024-11-16T08:45:16.582705Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Load the TFSMLayer as a layer\nimport tensorflow as tf\nfrom tensorflow.keras.layers import Input, TFSMLayer\nfrom tensorflow.keras.models import Model\nimport numpy as np\nimport pandas as pd\nfrom tensorflow.keras.preprocessing.image import load_img, img_to_array\nimport os\n\n# frozen path\n# frozen_cropnet_model_path = '/kaggle/input/cropnet_feature_selection_zip/tensorflow2/default/1/kaggle/working/model_feature_extraction_tf'\n\n\n#  unfrozen path\ncropnet_model_path = '/kaggle/input/cropnet_from_kaggle/tensorflow2/default/1/kaggle/working/cropnet_model_tf'\nlayer = TFSMLayer(cropnet_model_path, call_endpoint='serving_default')\n# Wrap TFSMLayer in a new model for prediction\ninput_layer = Input(shape=(224, 224, 3))\noutput_layer = layer(input_layer)\ncropnet_model = Model(inputs=input_layer, outputs=output_layer)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-18T04:18:23.444596Z","iopub.execute_input":"2024-11-18T04:18:23.445915Z","iopub.status.idle":"2024-11-18T04:18:39.144542Z","shell.execute_reply.started":"2024-11-18T04:18:23.445866Z","shell.execute_reply":"2024-11-18T04:18:39.143336Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# densenet_model_path = '/kaggle/input/densenet_model/tensorflow2/default/1/kaggle/working/kaggle/working/densenet_model_tf'\n\n# # Load DenseNet169 model using TFSMLayer\n# densenet_layer = TFSMLayer(densenet_model_path, call_endpoint='serving_default')\n# input_layer_densenet = Input(shape=(224, 224, 3))\n# output_layer_densenet = densenet_layer(input_layer_densenet)\n# densenet_model = Model(inputs=input_layer_densenet, outputs=output_layer_densenet)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:19.104503Z","iopub.execute_input":"2024-11-16T08:45:19.104867Z","iopub.status.idle":"2024-11-16T08:45:19.110317Z","shell.execute_reply.started":"2024-11-16T08:45:19.104830Z","shell.execute_reply":"2024-11-16T08:45:19.108966Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"old_densenet_model_path = '/kaggle/input/old_densenet/tensorflow2/default/1/kaggle/working/kaggle/working/densenet_model_tf'\nold_densenet_layer = TFSMLayer(old_densenet_model_path, call_endpoint='serving_default')\ninput_layer_densenet = Input(shape=(224, 224, 3))\noutput_layer_densenet = old_densenet_layer(input_layer_densenet)\nold_densenet_model = Model(inputs = input_layer_densenet, outputs = output_layer_densenet)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:19.112008Z","iopub.execute_input":"2024-11-16T08:45:19.112479Z","iopub.status.idle":"2024-11-16T08:45:29.551320Z","shell.execute_reply.started":"2024-11-16T08:45:19.112428Z","shell.execute_reply":"2024-11-16T08:45:29.550099Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# efficientnet_model_path = '/kaggle/input/efficientnet_model/tensorflow2/default/1/kaggle/working/kaggle/working/efficientnet_model_tf'\n# efficientnet_layer = TFSMLayer(efficientnet_model_path, call_endpoint='serving_default')\n# input_layer_efficientnet = Input(shape=(224, 224, 3))\n# output_layer_efficientnet = efficientnet_layer(input_layer_efficientnet)\n# efficientnet_model = Model(inputs=input_layer_efficientnet, outputs=output_layer_efficientnet)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:29.553140Z","iopub.execute_input":"2024-11-16T08:45:29.553556Z","iopub.status.idle":"2024-11-16T08:45:29.558855Z","shell.execute_reply.started":"2024-11-16T08:45:29.553503Z","shell.execute_reply":"2024-11-16T08:45:29.557477Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"old_efficientnet_model_path = '/kaggle/input/old_efficient_net/tensorflow2/default/1/kaggle/working/kaggle/working/efficientnet_model_tf'\nold_efficientnet_layer = TFSMLayer(old_efficientnet_model_path, call_endpoint='serving_default')\ninput_layer_efficientnet = Input(shape=(224, 224, 3))\noutput_layer_efficientnet = old_efficientnet_layer(input_layer_efficientnet)\nold_efficientnet_model = Model(inputs=input_layer_efficientnet, outputs=output_layer_efficientnet)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:29.560513Z","iopub.execute_input":"2024-11-16T08:45:29.560964Z","iopub.status.idle":"2024-11-16T08:45:38.729704Z","shell.execute_reply.started":"2024-11-16T08:45:29.560923Z","shell.execute_reply":"2024-11-16T08:45:38.728243Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"efficient net submission","metadata":{}},{"cell_type":"code","source":"# import os\n# import numpy as np\n# import pandas as pd\n# from tensorflow.keras.preprocessing.image import load_img, img_to_array\n\n# # Set image path and define empty lists to store data\n# image_dir = '/kaggle/input/cassava-leaf-disease-classification/test_images'\n# predictions = []\n# image_names = []\n\n# # Define image size as per model's expected input\n# img_size = (224, 224)\n\n# # Process each image in the folder\n# for filename in os.listdir(image_dir):\n#     if filename.endswith(\".jpg\"): \n#         # Load and preprocess image\n#         img_path = os.path.join(image_dir, filename)\n#         img = load_img(img_path, target_size=img_size)\n#         img_array = img_to_array(img) / 255.0  # Normalize image to [0, 1] range\n#         img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension\n        \n#         # Predict using the wrapped model\n#         pred = efficientnet_model(img_array)\n        \n#         # Inspect available keys in the prediction output\n#         print(f\"Keys in prediction dictionary for {filename}: {pred.keys()}\")\n        \n#         # Access the correct output using the first available key (adjust this if needed)\n#         pred_output = list(pred.values())[0]  # Get the first tensor in the dictionary\n        \n#         # Print the shape of the output tensor for debugging\n#         print(f\"Prediction shape for {filename}: {pred_output.shape}\")\n        \n#         # Determine the predicted class based on shape\n#         if len(pred_output.shape) == 1:  # 1D output\n#             predicted_class = np.argmax(pred_output)\n#         else:  # 2D output\n#             predicted_class = np.argmax(pred_output, axis=1)[0]\n        \n#         predictions.append(predicted_class)\n#         image_names.append(filename)\n\n# # Create DataFrame for submission\n# submission_df = pd.DataFrame({\n#     'image_id': image_names,\n#     'label': predictions\n# })\n\n# # Save to CSV\n# submission_df.to_csv('/kaggle/working/submission.csv', index=False)\n# print(\"Submission file created: submission.csv\")\n\n# # Display the first few rows to verify\n# print(submission_df.head())\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:38.731278Z","iopub.execute_input":"2024-11-16T08:45:38.731750Z","iopub.status.idle":"2024-11-16T08:45:38.739345Z","shell.execute_reply.started":"2024-11-16T08:45:38.731703Z","shell.execute_reply":"2024-11-16T08:45:38.737968Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# import os\n# import numpy as np\n# import pandas as pd\n# from tensorflow.keras.preprocessing.image import load_img, img_to_array\n\n# # Set image path and define empty lists to store data\n# image_dir = '/kaggle/input/cassava-leaf-disease-classification/test_images'\n# predictions = []\n# image_names = []\n\n# # Define image size as per model's expected input\n# img_size = (224, 224)\n\n# # Process each image in the folder\n# for filename in os.listdir(image_dir):\n#     if filename.endswith(\".jpg\"): \n#         # Load and preprocess image\n#         img_path = os.path.join(image_dir, filename)\n#         img = load_img(img_path, target_size=img_size)\n#         img_array = img_to_array(img) / 255.0  # Normalize image to [0, 1] range\n#         img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension\n        \n#         # Predict using the wrapped model\n#         pred = old_efficientnet_model(img_array)\n        \n#         # Inspect available keys in the prediction output\n#         print(f\"Keys in prediction dictionary for {filename}: {pred.keys()}\")\n        \n#         # Access the correct output using the first available key (adjust this if needed)\n#         pred_output = list(pred.values())[0]  # Get the first tensor in the dictionary\n        \n#         # Print the shape of the output tensor for debugging\n#         print(f\"Prediction shape for {filename}: {pred_output.shape}\")\n        \n#         # Determine the predicted class based on shape\n#         if len(pred_output.shape) == 1:  # 1D output\n#             predicted_class = np.argmax(pred_output)\n#         else:  # 2D output\n#             predicted_class = np.argmax(pred_output, axis=1)[0]\n        \n#         predictions.append(predicted_class)\n#         image_names.append(filename)\n\n# # Create DataFrame for submission\n# submission_df = pd.DataFrame({\n#     'image_id': image_names,\n#     'label': predictions\n# })\n\n# # Save to CSV\n# submission_df.to_csv('/kaggle/working/submission.csv', index=False)\n# print(\"Submission file created: submission.csv\")\n\n# # Display the first few rows to verify\n# print(submission_df.head())\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:38.741207Z","iopub.execute_input":"2024-11-16T08:45:38.742348Z","iopub.status.idle":"2024-11-16T08:45:38.760398Z","shell.execute_reply.started":"2024-11-16T08:45:38.742291Z","shell.execute_reply":"2024-11-16T08:45:38.758594Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Densenet169 submission","metadata":{}},{"cell_type":"markdown","source":"new","metadata":{}},{"cell_type":"code","source":"# import os\n# import numpy as np\n# import pandas as pd\n# from tensorflow.keras.preprocessing.image import load_img, img_to_array\n\n# # Set image path and define empty lists to store data\n# image_dir = '/kaggle/input/cassava-leaf-disease-classification/test_images'\n# predictions = []\n# image_names = []\n\n# # Define image size as per model's expected input\n# img_size = (224, 224)\n\n# # Process each image in the folder\n# for filename in os.listdir(image_dir):\n#     if filename.endswith(\".jpg\"): \n#         # Load and preprocess image\n#         img_path = os.path.join(image_dir, filename)\n#         img = load_img(img_path, target_size=img_size)\n#         img_array = img_to_array(img) / 255.0  # Normalize image to [0, 1] range\n#         img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension\n        \n#         # Predict using the wrapped model\n#         pred = densenet_model(img_array)\n        \n#         # Inspect available keys in the prediction output\n#         print(f\"Keys in prediction dictionary for {filename}: {pred.keys()}\")\n        \n#         # Access the correct output using the first available key (adjust this if needed)\n#         pred_output = list(pred.values())[0]  # Get the first tensor in the dictionary\n        \n#         # Print the shape of the output tensor for debugging\n#         print(f\"Prediction shape for {filename}: {pred_output.shape}\")\n        \n#         # Determine the predicted class based on shape\n#         if len(pred_output.shape) == 1:  # 1D output\n#             predicted_class = np.argmax(pred_output)\n#         else:  # 2D output\n#             predicted_class = np.argmax(pred_output, axis=1)[0]\n        \n#         predictions.append(predicted_class)\n#         image_names.append(filename)\n\n# # Create DataFrame for submission\n# submission_df = pd.DataFrame({\n#     'image_id': image_names,\n#     'label': predictions\n# })\n\n# # Save to CSV\n# submission_df.to_csv('/kaggle/working/submission.csv', index=False)\n# print(\"Submission file created: submission.csv\")\n\n# # Display the first few rows to verify\n# print(submission_df.head())\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:38.762304Z","iopub.execute_input":"2024-11-16T08:45:38.762819Z","iopub.status.idle":"2024-11-16T08:45:38.781406Z","shell.execute_reply.started":"2024-11-16T08:45:38.762764Z","shell.execute_reply":"2024-11-16T08:45:38.780068Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"old","metadata":{}},{"cell_type":"code","source":"# import os\n# import numpy as np\n# import pandas as pd\n# from tensorflow.keras.preprocessing.image import load_img, img_to_array\n\n# # Set image path and define empty lists to store data\n# image_dir = '/kaggle/input/cassava-leaf-disease-classification/test_images'\n# predictions = []\n# image_names = []\n\n# # Define image size as per model's expected input\n# img_size = (224, 224)\n\n# # Process each image in the folder\n# for filename in os.listdir(image_dir):\n#     if filename.endswith(\".jpg\"): \n#         # Load and preprocess image\n#         img_path = os.path.join(image_dir, filename)\n#         img = load_img(img_path, target_size=img_size)\n#         img_array = img_to_array(img) / 255.0  # Normalize image to [0, 1] range\n#         img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension\n        \n#         # Predict using the wrapped model\n#         pred = old_densenet_model(img_array)\n        \n#         # Inspect available keys in the prediction output\n#         print(f\"Keys in prediction dictionary for {filename}: {pred.keys()}\")\n        \n#         # Access the correct output using the first available key (adjust this if needed)\n#         pred_output = list(pred.values())[0]  # Get the first tensor in the dictionary\n        \n#         # Print the shape of the output tensor for debugging\n#         print(f\"Prediction shape for {filename}: {pred_output.shape}\")\n        \n#         # Determine the predicted class based on shape\n#         if len(pred_output.shape) == 1:  # 1D output\n#             predicted_class = np.argmax(pred_output)\n#         else:  # 2D output\n#             predicted_class = np.argmax(pred_output, axis=1)[0]\n        \n#         predictions.append(predicted_class)\n#         image_names.append(filename)\n\n# # Create DataFrame for submission\n# submission_df = pd.DataFrame({\n#     'image_id': image_names,\n#     'label': predictions\n# })\n\n# # Save to CSV\n# submission_df.to_csv('/kaggle/working/submission.csv', index=False)\n# print(\"Submission file created: submission.csv\")\n\n# # Display the first few rows to verify\n# print(submission_df.head())\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:38.783282Z","iopub.execute_input":"2024-11-16T08:45:38.784402Z","iopub.status.idle":"2024-11-16T08:45:38.799270Z","shell.execute_reply.started":"2024-11-16T08:45:38.784343Z","shell.execute_reply":"2024-11-16T08:45:38.798093Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"cropnet model","metadata":{}},{"cell_type":"code","source":"# import os\n# import numpy as np\n# import pandas as pd\n# from tensorflow.keras.preprocessing.image import load_img, img_to_array\n\n# # Set image path and define empty lists to store data\n# image_dir = '/kaggle/input/cassava-leaf-disease-classification/test_images'\n# predictions = []\n# image_names = []\n\n# # Define image size as per model's expected input\n# img_size = (224, 224)\n\n# # Process each image in the folder\n# for filename in os.listdir(image_dir):\n#     if filename.endswith(\".jpg\"): \n#         # Load and preprocess image\n#         img_path = os.path.join(image_dir, filename)\n#         img = load_img(img_path, target_size=img_size)\n#         img_array = img_to_array(img) / 255.0  # Normalize image to [0, 1] range\n#         img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension\n        \n#         # Predict using the wrapped model\n#         pred = cropnet_model(img_array)\n        \n#         # Inspect available keys in the prediction output\n#         print(f\"Keys in prediction dictionary for {filename}: {pred.keys()}\")\n        \n#         # Access the correct output using the first available key (adjust this if needed)\n#         pred_output = list(pred.values())[0]  # Get the first tensor in the dictionary\n        \n#         # Print the shape of the output tensor for debugging\n#         print(f\"Prediction shape for {filename}: {pred_output.shape}\")\n        \n#         # Determine the predicted class based on shape\n#         if len(pred_output.shape) == 1:  # 1D output\n#             predicted_class = np.argmax(pred_output)\n#         else:  # 2D output\n#             predicted_class = np.argmax(pred_output, axis=1)[0]\n        \n#         predictions.append(predicted_class)\n#         image_names.append(filename)\n\n# # Create DataFrame for submission\n# submission_df = pd.DataFrame({\n#     'image_id': image_names,\n#     'label': predictions\n# })\n\n# # Save to CSV\n# submission_df.to_csv('/kaggle/working/submission.csv', index=False)\n# print(\"Submission file created: submission.csv\")\n\n# # Display the first few rows to verify\n# print(submission_df.head())\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:38.805485Z","iopub.execute_input":"2024-11-16T08:45:38.805932Z","iopub.status.idle":"2024-11-16T08:45:38.815640Z","shell.execute_reply.started":"2024-11-16T08:45:38.805867Z","shell.execute_reply":"2024-11-16T08:45:38.814297Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"ensemble learning\n","metadata":{}},{"cell_type":"code","source":"# import os\n# import numpy as np\n# import pandas as pd\n# from tensorflow.keras.preprocessing.image import load_img, img_to_array\n\n# # Set image path and define empty lists to store data\n# image_dir = '/kaggle/input/cassava-leaf-disease-classification/test_images'\n# predictions = []\n# image_names = []\n\n# # Define image size as per model's expected input\n# img_size = (224, 224)\n\n# # Process each image in the folder\n# for filename in os.listdir(image_dir):\n#     if filename.endswith(\".jpg\"): \n#         # Load and preprocess image\n#         img_path = os.path.join(image_dir, filename)\n#         img = load_img(img_path, target_size=img_size)\n#         img_array = img_to_array(img) / 255.0  # Normalize image to [0, 1] range\n#         img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension\n        \n#         # Get predictions from each model\n#         cropnet_pred = cropnet_model(img_array)\n#         densenet_pred = densenet_model(img_array)\n#         efficientnet_pred = efficientnet_model(img_array)\n        \n#         # Handle dictionary outputs by extracting the main tensor\n#         cropnet_pred = list(cropnet_pred.values())[0] if isinstance(cropnet_pred, dict) else cropnet_pred\n#         densenet_pred = list(densenet_pred.values())[0] if isinstance(densenet_pred, dict) else densenet_pred\n#         efficientnet_pred = list(efficientnet_pred.values())[0] if isinstance(efficientnet_pred, dict) else efficientnet_pred\n\n#         # Convert predictions to numpy if necessary\n#         cropnet_pred = cropnet_pred.numpy() if hasattr(cropnet_pred, 'numpy') else cropnet_pred\n#         densenet_pred = densenet_pred.numpy() if hasattr(densenet_pred, 'numpy') else densenet_pred\n#         efficientnet_pred = efficientnet_pred.numpy() if hasattr(efficientnet_pred, 'numpy') else efficientnet_pred\n\n#         # Average the predictions across the models\n#         avg_pred = (cropnet_pred + densenet_pred + efficientnet_pred) / 3\n\n#         # Determine the predicted class\n#         predicted_class = np.argmax(avg_pred)\n        \n#         # Append to lists for submission\n#         predictions.append(predicted_class)\n#         image_names.append(filename)\n\n# # Create DataFrame for submission\n# submission_df = pd.DataFrame({\n#     'image_id': image_names,\n#     'label': predictions\n# })\n\n# # Save to CSV\n# submission_df.to_csv('/kaggle/working/submission.csv', index=False)\n# print(\"Submission file created: submission.csv\")\n\n# # Display the first few rows to verify\n# print(submission_df.head())\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:38.818365Z","iopub.execute_input":"2024-11-16T08:45:38.818791Z","iopub.status.idle":"2024-11-16T08:45:38.836951Z","shell.execute_reply.started":"2024-11-16T08:45:38.818751Z","shell.execute_reply":"2024-11-16T08:45:38.835648Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"weighted soft voting","metadata":{}},{"cell_type":"code","source":"# import optuna\n# import numpy as np\n# from sklearn.metrics import accuracy_score\n\n# # Initialize lists to store predictions from each model\n# cropnet_preds = []\n# densenet_preds = []\n# efficientnet_preds = []\n# true_labels = []  # Actual labels for the training data\n\n# # Iterate over the training dataset\n# for img_batch, label_batch in train_ds:\n#     # Convert images to numpy array if necessary\n#     img_batch = np.array(img_batch)\n    \n#     # Get predictions from each model\n#     cropnet_pred = cropnet_model.predict(img_batch)\n#     densenet_pred = old_densenet_model.predict(img_batch)\n#     efficientnet_pred = old_efficientnet_model.predict(img_batch)\n    \n#     # Extract main tensor if predictions are in dictionary format\n#     cropnet_pred = list(cropnet_pred.values())[0] if isinstance(cropnet_pred, dict) else cropnet_pred\n#     densenet_pred = list(densenet_pred.values())[0] if isinstance(densenet_pred, dict) else densenet_pred\n#     efficientnet_pred = list(efficientnet_pred.values())[0] if isinstance(efficientnet_pred, dict) else efficientnet_pred\n\n#     # Convert to numpy if necessary\n#     cropnet_pred = cropnet_pred.numpy() if hasattr(cropnet_pred, 'numpy') else cropnet_pred\n#     densenet_pred = densenet_pred.numpy() if hasattr(densenet_pred, 'numpy') else densenet_pred\n#     efficientnet_pred = efficientnet_pred.numpy() if hasattr(efficientnet_pred, 'numpy') else efficientnet_pred\n\n#     # Append predictions and true labels\n#     cropnet_preds.extend(cropnet_pred)\n#     densenet_preds.extend(densenet_pred)\n#     efficientnet_preds.extend(efficientnet_pred)\n#     true_labels.extend(label_batch.numpy())\n\n# # Convert lists to numpy arrays for optimization\n# cropnet_preds = np.array(cropnet_preds)\n# densenet_preds = np.array(densenet_preds)\n# efficientnet_preds = np.array(efficientnet_preds)\n# true_labels = np.array(true_labels)\n\n\n# # Define objective function for Bayesian optimization\n# def objective(trial):\n#     # Suggest weight values for each model in the range [0, 1]\n#     cropnet_weight = trial.suggest_float(\"cropnet_weight\", 0.0, 1.0)\n#     densenet_weight = trial.suggest_float(\"densenet_weight\", 0.0, 1.0)\n#     efficientnet_weight = trial.suggest_float(\"efficientnet_weight\", 0.0, 1.0)\n    \n#     # Normalize the weights so that they sum to 1\n#     total_weight = cropnet_weight + densenet_weight + efficientnet_weight\n#     cropnet_weight /= total_weight\n#     densenet_weight /= total_weight\n#     efficientnet_weight /= total_weight\n\n#     # Calculate weighted ensemble predictions\n#     weighted_preds = (\n#         cropnet_weight * cropnet_preds + \n#         densenet_weight * densenet_preds + \n#         efficientnet_weight * efficientnet_preds\n#     )\n\n#     # Calculate accuracy for these weights\n#     ensemble_predictions = np.argmax(weighted_preds, axis=1)  # Convert probabilities to class predictions\n#     accuracy = accuracy_score(true_labels, ensemble_predictions)\n    \n#     # Return the accuracy (higher is better)\n#     return accuracy\n\n# def load_best_weights():\n#     study = optuna.create_study(direction=\"maximize\")\n#     study.optimize(objective, n_trials=50) \n\n#     # Get the best weights\n#     best_weights = study.best_params\n    \n#     # Normalize the best weights to ensure they sum to 1\n#     total_weight = sum(best_weights.values())\n#     for key in best_weights:\n#         best_weights[key] /= total_weight\n    \n#     return best_weights\n    \n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-16T08:45:38.838633Z","iopub.execute_input":"2024-11-16T08:45:38.839210Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import os\nimport numpy as np\nimport pandas as pd\nfrom tensorflow.keras.preprocessing.image import load_img, img_to_array\n\n# Load best weights\ncropnet_weight = 0.7\ndensenet_weight = 0.3\nefficientnet_weight = 0\n\n# Set image path and define empty lists to store data\nimage_dir = '/kaggle/input/cassava-leaf-disease-classification/test_images'\npredictions = []\nimage_names = []\n\n# Define image size as per model's expected input\nimg_size = (224, 224)\n\n# Process each image in the folder\nfor filename in os.listdir(image_dir):\n    if filename.endswith(\".jpg\"): \n        # Load and preprocess image\n        img_path = os.path.join(image_dir, filename)\n        img = load_img(img_path, target_size=img_size)\n        img_array = img_to_array(img) / 255.0  # Normalize image to [0, 1] range\n        img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension\n        \n        # Get predictions from each model\n        cropnet_pred = cropnet_model(img_array)\n        densenet_pred = old_densenet_model(img_array)\n        efficientnet_pred = old_efficientnet_model(img_array)\n        \n        # Handle dictionary outputs by extracting the main tensor\n        cropnet_pred = list(cropnet_pred.values())[0] if isinstance(cropnet_pred, dict) else cropnet_pred\n        densenet_pred = list(densenet_pred.values())[0] if isinstance(densenet_pred, dict) else densenet_pred\n        efficientnet_pred = list(efficientnet_pred.values())[0] if isinstance(efficientnet_pred, dict) else efficientnet_pred\n\n        # Convert predictions to numpy if necessary\n        cropnet_pred = cropnet_pred.numpy() if hasattr(cropnet_pred, 'numpy') else cropnet_pred\n        densenet_pred = densenet_pred.numpy() if hasattr(densenet_pred, 'numpy') else densenet_pred\n        efficientnet_pred = efficientnet_pred.numpy() if hasattr(efficientnet_pred, 'numpy') else efficientnet_pred\n\n        # Apply the weights from Bayesian optimization\n        avg_pred = (\n            cropnet_weight * cropnet_pred +\n            densenet_weight * densenet_pred +\n            efficientnet_weight * efficientnet_pred\n        )\n        \n        # Determine the predicted class based on highest probability\n        predicted_class = np.argmax(avg_pred)\n        \n        # Append to lists for submission\n        predictions.append(predicted_class)\n        image_names.append(filename)\n\n# Create DataFrame for submission\nsubmission_df = pd.DataFrame({\n    'image_id': image_names,\n    'label': predictions\n})\n\n# Save to CSV\nsubmission_df.to_csv('/kaggle/working/submission.csv', index=False)\nprint(\"Submission file created: submission.csv\")\n\n# Display the first few rows to verify\nprint(submission_df.head())\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"hard voting with priority","metadata":{}},{"cell_type":"code","source":"# import os\n# import numpy as np\n# import pandas as pd\n# from tensorflow.keras.preprocessing.image import load_img, img_to_array\n\n# # Set image path and define empty lists to store data\n# image_dir = '/kaggle/input/cassava-leaf-disease-classification/test_images'\n# predictions = []\n# image_names = []\n\n# # Define image size as per model's expected input\n# img_size = (224, 224)\n\n# # Process each image in the folder\n# for filename in os.listdir(image_dir):\n#     if filename.endswith(\".jpg\"): \n#         # Load and preprocess image\n#         img_path = os.path.join(image_dir, filename)\n#         img = load_img(img_path, target_size=img_size)\n#         img_array = img_to_array(img) / 255.0  # Normalize image to [0, 1] range\n#         img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension\n        \n#         # Get predictions from each model\n#         cropnet_pred = cropnet_model(img_array)\n#         densenet_pred = old_densenet_model(img_array)\n#         efficientnet_pred = efficientnet_model(img_array)\n        \n#         # Handle dictionary outputs by extracting the main tensor\n#         cropnet_pred = list(cropnet_pred.values())[0] if isinstance(cropnet_pred, dict) else cropnet_pred\n#         densenet_pred = list(densenet_pred.values())[0] if isinstance(densenet_pred, dict) else densenet_pred\n#         efficientnet_pred = list(efficientnet_pred.values())[0] if isinstance(efficientnet_pred, dict) else efficientnet_pred\n\n#         # Convert predictions to numpy if necessary\n#         cropnet_pred = cropnet_pred.numpy() if hasattr(cropnet_pred, 'numpy') else cropnet_pred\n#         densenet_pred = densenet_pred.numpy() if hasattr(densenet_pred, 'numpy') else densenet_pred\n#         efficientnet_pred = efficientnet_pred.numpy() if hasattr(efficientnet_pred, 'numpy') else efficientnet_pred\n\n#         # Get the predicted class from each model (hard vote)\n#         cropnet_class = np.argmax(cropnet_pred)\n#         densenet_class = np.argmax(densenet_pred)\n#         efficientnet_class = np.argmax(efficientnet_pred)\n\n#         # Collect votes\n#         votes = [cropnet_class, densenet_class, efficientnet_class]\n        \n#         # Hard voting with CropNet as priority\n#         # If there is a majority, take the majority class; otherwise, prioritize CropNet\n#         if votes.count(cropnet_class) >= 2:\n#             predicted_class = cropnet_class\n#         elif votes.count(densenet_class) >= 2:\n#             predicted_class = densenet_class\n#         elif votes.count(efficientnet_class) >= 2:\n#             predicted_class = efficientnet_class\n#         else:\n#             # If there's a tie, use CropNet's prediction as the final prediction\n#             predicted_class = cropnet_class\n        \n#         # Append to lists for submission\n#         predictions.append(predicted_class)\n#         image_names.append(filename)\n\n# # Create DataFrame for submission\n# submission_df = pd.DataFrame({\n#     'image_id': image_names,\n#     'label': predictions\n# })\n\n# # Save to CSV\n# submission_df.to_csv('/kaggle/working/submission.csv', index=False)\n# print(\"Submission file created: submission.csv\")\n\n# # Display the first few rows to verify\n# print(submission_df.head())\n","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}