{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":3362,"databundleVersionId":31148,"sourceType":"competition"}],"dockerImageVersionId":30699,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import warnings\nwarnings.filterwarnings('ignore')\n\nimport os\nfrom os import makedirs # make directory\nfrom os import listdir # list directories\nfrom shutil import copyfile\nfrom random import seed\nfrom random import random\nimport numpy as np\nimport pandas as pd\n\n# visuals\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nfrom matplotlib.image import imread # Used to read images\nfrom PIL import Image # Image Visulization\n\n# Scikit-learn\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import classification_report,confusion_matrix,ConfusionMatrixDisplay# Tensorflow\nimport tensorflow as tf\nfrom tensorflow.keras.models import Sequential \nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator\nfrom tensorflow.keras.layers import Dense,MaxPooling2D,Dropout,Flatten,BatchNormalization,Conv2D\nfrom tensorflow.keras.callbacks import ReduceLROnPlateau,EarlyStopping","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-05-15T16:11:51.845481Z","iopub.execute_input":"2024-05-15T16:11:51.846461Z","iopub.status.idle":"2024-05-15T16:12:06.703365Z","shell.execute_reply.started":"2024-05-15T16:11:51.846411Z","shell.execute_reply":"2024-05-15T16:12:06.702348Z"},"trusted":true},"execution_count":1,"outputs":[{"name":"stderr","text":"2024-05-15 16:11:55.130058: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n2024-05-15 16:11:55.130179: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n2024-05-15 16:11:55.261055: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n","output_type":"stream"}]},{"cell_type":"code","source":"train_path = \"../input/dogs-vs-cats/test1.zip\"\ntest_path = \"../input/dogs-vs-cats/train.zip\"\n\nfiles = \"/kaggle/working/\"\n\n# zipfile - python module for extracting files from a zip file\nimport zipfile\n\nwith zipfile.ZipFile(train_path, 'r') as zipp:\n    zipp.extractall(files)\n    \nwith zipfile.ZipFile(test_path, 'r') as zipp:\n    zipp.extractall(files)\n\n    \nimage_dir = \"../working/train/\"\n\nfilenames = os.listdir(image_dir)\nlabels = [x.split(\".\")[0] for x in filenames]\n\ndata = pd.DataFrame({\"filename\": filenames, \"label\": labels})\n\ndata.head()\n\ndata = data[:2000]\ndata.shape\n\n\n\nlabels = data['label']\n\n# 20% split\n# 80%.    20%\nX_train, X_temp = train_test_split(data, test_size=0.2, stratify=labels, random_state = 42)\n\nlabel_test_val = X_temp['label']\n\n# 10%.   10%\nX_test, X_val = train_test_split(X_temp, test_size=0.5, stratify=label_test_val, random_state = 42)\n\nprint('The shape of train data',X_train.shape)\nprint('The shape of test data',X_test.shape)\nprint('The shape of validation data',X_val.shape)\n\n\n# Define paths to the training and testing data\ndataset_home = 'dataset_dogs_vs_cats/'\nsubdirs = ['train/', 'test/']\n\nfor subdir in subdirs:\n    # create label subdirectories\n    labeldirs = ['dogs/', 'cats/']\n    for labldir in labeldirs:\n        newdir = dataset_home + subdir + labldir\n        makedirs(newdir, exist_ok=True) # Create 4 directories\n\n# seed random number generator\nseed(1)\n# define ratio of pictures to use for validation\nval_ratio = 0.2\n","metadata":{"execution":{"iopub.status.busy":"2024-05-15T16:12:57.298047Z","iopub.execute_input":"2024-05-15T16:12:57.298417Z","iopub.status.idle":"2024-05-15T16:13:09.538308Z","shell.execute_reply.started":"2024-05-15T16:12:57.298386Z","shell.execute_reply":"2024-05-15T16:13:09.53725Z"},"trusted":true},"execution_count":5,"outputs":[{"name":"stdout","text":"The shape of train data (1600, 2)\nThe shape of test data (200, 2)\nThe shape of validation data (200, 2)\n","output_type":"stream"}]},{"cell_type":"code","source":"# Copy training dataset images into subdirectories\nsrc_directory = 'train/'\nfor file in listdir(src_directory):\n    src = src_directory + '/' + file\n    dst_dir = 'train/'\n    if random() < val_ratio:\n        dst_dir = 'test/'\n    if file.startswith('cat'):\n        dst = dataset_home + dst_dir + 'cats/' + file\n        copyfile(src, dst)\n    elif file.startswith('dog'):\n        dst = dataset_home + dst_dir + 'dogs/' + file\n        copyfile(src, dst)","metadata":{"execution":{"iopub.status.busy":"2024-05-15T16:13:44.694624Z","iopub.execute_input":"2024-05-15T16:13:44.695066Z","iopub.status.idle":"2024-05-15T16:13:47.578762Z","shell.execute_reply.started":"2024-05-15T16:13:44.695032Z","shell.execute_reply":"2024-05-15T16:13:47.577793Z"},"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"code","source":"# Count the number of images in each category for both training and testing data\nnum_train_cats = len(os.listdir(dataset_home + 'train/cats/'))\nnum_train_dogs = len(os.listdir(dataset_home + 'train/dogs/'))\nnum_test_cats = len(os.listdir(dataset_home + 'test/cats/'))\nnum_test_dogs = len(os.listdir(dataset_home + 'test/dogs/'))\n\nprint('Number of cat images in training data:', num_train_cats)\nprint('Number of dog images in training data:', num_train_dogs)\nprint('Number of cat images in validation data:', num_test_cats)\nprint('Number of dog images in validation data:', num_test_dogs)\n","metadata":{"execution":{"iopub.status.busy":"2024-05-15T16:13:56.183179Z","iopub.execute_input":"2024-05-15T16:13:56.183954Z","iopub.status.idle":"2024-05-15T16:13:56.210134Z","shell.execute_reply.started":"2024-05-15T16:13:56.183914Z","shell.execute_reply":"2024-05-15T16:13:56.208994Z"},"trusted":true},"execution_count":7,"outputs":[{"name":"stdout","text":"Number of cat images in training data: 9971\nNumber of dog images in training data: 9939\nNumber of cat images in validation data: 2529\nNumber of dog images in validation data: 2561\n","output_type":"stream"}]},{"cell_type":"code","source":"# Data augmentation for training\ntrain_datagen = ImageDataGenerator(\n    rescale=1. / 255,\n    shear_range=0.2,\n    zoom_range=0.2,\n    horizontal_flip=True)\n\n# Only rescaling for testing/validation\ntest_datagen = ImageDataGenerator(rescale=1. / 255)\n\n# Generate batches of augmented data for training and testing\ntrain_generator = train_datagen.flow_from_directory(\n    dataset_home + 'train/',\n    target_size=(150, 150),\n    batch_size=32,\n    class_mode='binary')\n\ntest_generator = test_datagen.flow_from_directory(\n    dataset_home + 'test/',\n    target_size=(150, 150),\n    batch_size=32,\n    class_mode='binary')","metadata":{"execution":{"iopub.status.busy":"2024-05-15T16:14:05.7334Z","iopub.execute_input":"2024-05-15T16:14:05.733836Z","iopub.status.idle":"2024-05-15T16:14:07.116572Z","shell.execute_reply.started":"2024-05-15T16:14:05.733801Z","shell.execute_reply":"2024-05-15T16:14:07.115634Z"},"trusted":true},"execution_count":9,"outputs":[{"name":"stdout","text":"Found 19910 images belonging to 2 classes.\nFound 5090 images belonging to 2 classes.\n","output_type":"stream"}]},{"cell_type":"code","source":"def VGG16(num_blocks_2=2, num_blocks_3=3, num_blocks_4=3, num_neurons_fc=4096):\n    model = Sequential()\n    model.add(Conv2D(64, (3, 3), input_shape=(150, 150, 3), activation='relu', padding='same'))\n    model.add(Conv2D(64, (3, 3), activation='relu', padding='same'))\n    model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))\n\n    for _ in range(num_blocks_2):\n        model.add(Conv2D(128, (3, 3), activation='relu', padding='same'))\n    model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))\n\n    for _ in range(num_blocks_3):\n        model.add(Conv2D(256, (3, 3), activation='relu', padding='same'))\n    model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))\n\n    for _ in range(num_blocks_4):\n        model.add(Conv2D(512, (3, 3), activation='relu', padding='same'))\n    model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))\n\n    model.add(Flatten())\n    model.add(Dense(num_neurons_fc, activation='relu'))\n    model.add(Dropout(0.5))\n    model.add(Dense(num_neurons_fc, activation='relu'))\n    model.add(Dropout(0.5))\n    model.add(Dense(1, activation='sigmoid'))  # Changed to 1 output neuron for binary classification\n\n    return model\n\n\n\n","metadata":{"execution":{"iopub.status.busy":"2024-05-15T16:14:13.693483Z","iopub.execute_input":"2024-05-15T16:14:13.693944Z","iopub.status.idle":"2024-05-15T16:14:13.710893Z","shell.execute_reply.started":"2024-05-15T16:14:13.69391Z","shell.execute_reply":"2024-05-15T16:14:13.709548Z"},"trusted":true},"execution_count":10,"outputs":[]},{"cell_type":"code","source":"# Function to train and evaluate the model\ndef train_evaluate_model(model, train_generator, test_generator):\n    model.compile(loss='binary_crossentropy',\n                  optimizer='adam',\n                  metrics=['accuracy'])\n\n    history = model.fit(\n        train_generator,\n        steps_per_epoch= len(train_generator),\n        epochs=5,\n        validation_data=test_generator,\n        validation_steps=len(test_generator),\n        verbose=1)  # Setting verbose to 0 to suppress training output\n\n    score = model.evaluate(test_generator, steps=len(test_generator))\n    return history, score[1]\n","metadata":{"execution":{"iopub.status.busy":"2024-05-15T16:27:36.320513Z","iopub.execute_input":"2024-05-15T16:27:36.321559Z","iopub.status.idle":"2024-05-15T16:27:36.328783Z","shell.execute_reply.started":"2024-05-15T16:27:36.32151Z","shell.execute_reply":"2024-05-15T16:27:36.327481Z"},"trusted":true},"execution_count":14,"outputs":[]},{"cell_type":"code","source":"\n# Define lists to store accuracy for each experiment\naccuracies = []\n","metadata":{"execution":{"iopub.status.busy":"2024-05-15T16:27:58.905499Z","iopub.execute_input":"2024-05-15T16:27:58.905988Z","iopub.status.idle":"2024-05-15T16:27:58.912067Z","shell.execute_reply.started":"2024-05-15T16:27:58.905952Z","shell.execute_reply":"2024-05-15T16:27:58.910801Z"},"trusted":true},"execution_count":16,"outputs":[]},{"cell_type":"code","source":"model = VGG16()\nhistory, accuracy = train_evaluate_model(model, train_generator, test_generator)\naccuracies.append(accuracy)\n\nmodel = VGG16(num_blocks_2=4)\nhistory, accuracy = train_evaluate_model(model, train_generator, test_generator)\naccuracies.append(accuracy)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Accuracies for experiments 1 and 2\nexperiment_names = ['Experiment 1', 'Experiment 2']\n\n# Plot line chart\nplt.plot(experiment_names, accuracies, marker='o')\nplt.title('Accuracy Comparison for Experiments 1 and 2')\nplt.xlabel('Experiment')\nplt.ylabel('Accuracy')\nplt.grid(True)\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-05-15T17:10:48.090117Z","iopub.execute_input":"2024-05-15T17:10:48.090494Z","iopub.status.idle":"2024-05-15T17:10:48.360407Z","shell.execute_reply.started":"2024-05-15T17:10:48.090464Z","shell.execute_reply":"2024-05-15T17:10:48.359177Z"},"trusted":true},"execution_count":35,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{"trusted":true},"execution_count":null,"outputs":[]}]}