diff --git a/Ricardo/image-processing.ipynb b/Ricardo/image-processing.ipynb new file mode 100644 index 0000000000..3c98810cd5 --- /dev/null +++ b/Ricardo/image-processing.ipynb @@ -0,0 +1,438 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From c:\\Users\\ricar\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.\n", + "\n" + ] + } + ], + "source": [ + "import os\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from tensorflow import keras\n", + "from keras.preprocessing import image\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "IMAGE_FOLDER_PATH=r\"C:\\Users\\ricar\\Documents\\4Geeks_Projects\\Image-Procesing\\data\\train\"\n", + "FILE_NAMES=os.listdir(IMAGE_FOLDER_PATH)\n", + "WIDTH=150\n", + "HEIGHT=150" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "targets=list()\n", + "full_paths=list()\n", + "for file_name in FILE_NAMES:\n", + " target=file_name.split(\".\")[0]\n", + " full_path=os.path.join(IMAGE_FOLDER_PATH, file_name)\n", + " full_paths.append(full_path)\n", + " targets.append(target)\n", + "\n", + "dataset=pd.DataFrame()\n", + "dataset['image_path']=full_paths\n", + "dataset['target']=targets" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
image_pathtarget
0C:\\Users\\ricar\\Documents\\4Geeks_Projects\\Image...cat
1C:\\Users\\ricar\\Documents\\4Geeks_Projects\\Image...cat
2C:\\Users\\ricar\\Documents\\4Geeks_Projects\\Image...cat
3C:\\Users\\ricar\\Documents\\4Geeks_Projects\\Image...cat
4C:\\Users\\ricar\\Documents\\4Geeks_Projects\\Image...cat
\n", + "
" + ], + "text/plain": [ + " image_path target\n", + "0 C:\\Users\\ricar\\Documents\\4Geeks_Projects\\Image... cat\n", + "1 C:\\Users\\ricar\\Documents\\4Geeks_Projects\\Image... cat\n", + "2 C:\\Users\\ricar\\Documents\\4Geeks_Projects\\Image... cat\n", + "3 C:\\Users\\ricar\\Documents\\4Geeks_Projects\\Image... cat\n", + "4 C:\\Users\\ricar\\Documents\\4Geeks_Projects\\Image... cat" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "target\n", + "cat 12500\n", + "dog 12500\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset['target'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "dataset = dataset[dataset['target'].isin(['dog', 'cat'])]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of dogs in the dataset:12500\n", + "Number of cats in the dataset:12500\n" + ] + } + ], + "source": [ + "target_counts=dataset['target'].value_counts()\n", + "print(\"Number of dogs in the dataset:{}\".format(target_counts['dog']))\n", + "print(\"Number of cats in the dataset:{}\".format(target_counts['cat']))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def show_model_history(modelHistory, model_name):\n", + " history=pd.DataFrame()\n", + " history[\"Train Loss\"]=modelHistory.history['loss']\n", + " history[\"Validatin Loss\"]=modelHistory.history['val_loss']\n", + " history[\"Train Accuracy\"]=modelHistory.history['accuracy']\n", + " history[\"Validatin Accuracy\"]=modelHistory.history['val_accuracy']\n", + " \n", + " history.plot(figsize=(12,8))\n", + " plt.title(\" Convulutional Model {} Train and Validation Loss and Accuracy History\".format(model_name))\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "from keras.models import Sequential\n", + "from keras.layers import Dense, MaxPool2D, Flatten, Conv2D\n", + "\n", + "model = Sequential()\n", + "model.add(Conv2D(input_shape=(WIDTH, HEIGHT, 3), filters=64, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(Conv2D(filters=64, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))\n", + "model.add(Conv2D(filters=128, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(Conv2D(filters=128, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))\n", + "model.add(Conv2D(filters=256, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(Conv2D(filters=256, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(Conv2D(filters=256, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))\n", + "model.add(Conv2D(filters=512, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(Conv2D(filters=512, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(Conv2D(filters=512, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))\n", + "model.add(Conv2D(filters=512, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(Conv2D(filters=512, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(Conv2D(filters=512, kernel_size=(3, 3), padding=\"same\", activation=\"relu\"))\n", + "model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2)))\n", + "\n", + "# Move the Data through the Dense Layers\n", + "model.add(Flatten())\n", + "model.add(Dense(units=4096, activation=\"relu\"))\n", + "model.add(Dense(units=4096, activation=\"relu\"))\n", + "model.add(Dense(units=2, activation=\"softmax\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from keras.optimizers import Adam\n", + "\n", + "model.compile(optimizer = Adam(learning_rate = 0.0001), loss = \"categorical_crossentropy\", metrics = [\"accuracy\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "dataset_train, dataset_test=train_test_split(dataset, test_size=0.2, random_state=42)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 20000 validated image filenames belonging to 2 classes.\n" + ] + } + ], + "source": [ + "from keras.preprocessing.image import ImageDataGenerator\n", + "\n", + "train_datagen=ImageDataGenerator(\n", + "rotation_range=15,\n", + "rescale=1./255,\n", + "shear_range=0.1,\n", + "zoom_range=0.2,\n", + "horizontal_flip=True,\n", + "width_shift_range=0.1,\n", + "height_shift_range=0.1)\n", + "\n", + "train_datagenerator = train_datagen.flow_from_dataframe(\n", + " dataframe=dataset_train,\n", + " x_col=\"image_path\",\n", + " y_col=\"target\",\n", + " target_size=(WIDTH, HEIGHT),\n", + " class_mode=\"categorical\",\n", + " batch_size=150\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 5000 validated image filenames belonging to 2 classes.\n" + ] + } + ], + "source": [ + "test_datagen=ImageDataGenerator(rescale=1./255)\n", + "\n", + "test_datagenerator = test_datagen.flow_from_dataframe(\n", + " dataframe=dataset_test,\n", + " x_col=\"image_path\",\n", + " y_col=\"target\",\n", + " target_size=(WIDTH, HEIGHT),\n", + " class_mode=\"categorical\",\n", + " batch_size=150\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/2\n", + "133/133 [==============================] - 2065s 16s/step - loss: 0.6696 - accuracy: 0.5690 - val_loss: 0.6860 - val_accuracy: 0.6026\n", + "Epoch 2/2\n", + "133/133 [==============================] - 2009s 15s/step - loss: 0.6199 - accuracy: 0.6501 - val_loss: 0.6375 - val_accuracy: 0.6457\n" + ] + } + ], + "source": [ + "modelHistory = model.fit(\n", + " train_datagenerator,\n", + " epochs=2,\n", + " validation_data=test_datagenerator,\n", + " validation_steps=dataset_test.shape[0]//150, \n", + " steps_per_epoch=dataset_train.shape[0]//150\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\ricar\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\engine\\training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n", + " saving_api.save_model(\n" + ] + } + ], + "source": [ + "model.save(\"model.h5\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(modelHistory.history[\"accuracy\"])\n", + "plt.plot(modelHistory.history[\"val_accuracy\"])\n", + "plt.plot(modelHistory.history[\"loss\"])\n", + "plt.plot(modelHistory.history[\"val_loss\"])\n", + "\n", + "# Configure the Plot Layout\n", + "plt.title(\"Model Accuracy and Loss\")\n", + "plt.ylabel(\"Accuracy / Loss\")\n", + "plt.xlabel(\"Epoch\")\n", + "plt.legend([\"Accuracy\", \"Validation Accuracy\", \"Loss\", \"Validation Loss\"])\n", + "\n", + "# Show the Plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "34/34 [==============================] - 107s 3s/step\n" + ] + } + ], + "source": [ + "predictions = model.predict(test_datagenerator)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}