noshot 12.0.0__py3-none-any.whl → 13.0.0__py3-none-any.whl

noshot/data/DLE FSD BDA/DLE/DLE 3 (sonic boy)/Ex4.ipynb

@@ -0,0 +1,186 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6a60369e-1161-4281-b04d-f0168bf5ef7f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tensorflow as tf\n",
+    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+    "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Conv2DTranspose, Input\n",
+    "from tensorflow.keras.models import Model\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b1c3acba-dff0-4bbb-9b35-16f18d36f84f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Paths to images and masks directories\n",
+    "image_dir = r\"D:\\Neeraj\\SEM 7\\DLE LAB\\Banana FCN\\Banana FCN\\Images\"\n",
+    "mask_dir = r\"D:\\Neeraj\\SEM 7\\DLE LAB\\Banana FCN\\Banana FCN\\Mask\"\n",
+    "\n",
+    "# Image and mask data generators\n",
+    "image_datagen = ImageDataGenerator(rescale=1./255)\n",
+    "mask_datagen = ImageDataGenerator(rescale=1./255)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a25255b3-ad4f-4037-8ca7-e66572ac6352",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image_generator = image_datagen.flow_from_directory(\n",
+    "    image_dir,\n",
+    "    class_mode=None,\n",
+    "    color_mode='rgb',\n",
+    "    target_size=(128, 128),\n",
+    "    batch_size=8,\n",
+    "    seed=42\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f06864c7-8962-44f8-a51f-89e29335eab8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mask_generator = mask_datagen.flow_from_directory(\n",
+    "    mask_dir,\n",
+    "    class_mode=None,\n",
+    "    color_mode='grayscale',\n",
+    "    target_size=(128, 128),\n",
+    "    batch_size=8,\n",
+    "    seed=42\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2ab0717a-efb1-4178-b1a3-da50bff63147",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Combine generators into one which yields image and mask\n",
+    "train_generator = zip(image_generator, mask_generator)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c07463ee-7151-49b9-b62f-b7cd750fbae9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def build_fcnn():\n",
+    "    inputs = Input((128, 128, 3))\n",
+    "\n",
+    "    # Encoder\n",
+    "    conv1 = Conv2D(128, (3, 3), activation='relu', padding='same')(inputs)\n",
+    "    pool1 = MaxPooling2D((2, 2))(conv1)\n",
+    "\n",
+    "    conv2 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool1)\n",
+    "    pool2 = MaxPooling2D((2, 2))(conv2)\n",
+    "\n",
+    "    # Decoder\n",
+    "    conv3 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool2)\n",
+    "    up1 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same')(conv3)\n",
+    "\n",
+    "    conv4 = Conv2D(128, (3, 3), activation='relu', padding='same')(up1)\n",
+    "    up2 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(conv4)\n",
+    "\n",
+    "    outputs = Conv2D(1, (1, 1), activation='sigmoid', padding='same')(up2)\n",
+    "\n",
+    "    model = Model(inputs, outputs)\n",
+    "    return model\n",
+    "\n",
+    "model = build_fcnn()\n",
+    "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6fd59bd5-ef68-4245-8f38-6d07f0d1168e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Train the FCNN model\n",
+    "def combined_generator(image_gen, mask_gen):\n",
+    "    while True:  # Keep yielding data indefinitely\n",
+    "        img_batch = next(image_gen)\n",
+    "        mask_batch = next(mask_gen)\n",
+    "        yield img_batch, mask_batch  # Keras expects (input, target)\n",
+    "# Fit the model with the custom generator\n",
+    "train_generator = combined_generator(image_generator, mask_generator)\n",
+    "model.fit(train_generator, steps_per_epoch=len(image_generator), epochs=5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77a2606d-0d22-4c8c-95cf-df9c4ddec7ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Sample image for prediction\n",
+    "sample_image = image_generator[0][0]\n",
+    "predicted_mask = model.predict(np.expand_dims(sample_image, axis=0))[0]\n",
+    "\n",
+    "# Display the original image and predicted mask\n",
+    "plt.figure(figsize=(10, 5))\n",
+    "\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.title(\"Original Image\")\n",
+    "plt.imshow(sample_image)\n",
+    "\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.title(\"Predicted Mask\")\n",
+    "plt.imshow(predicted_mask.squeeze(), cmap='gray')\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "87630680-a078-42f4-92bd-cce91efe2d0f",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

noshot/data/DLE FSD BDA/DLE/DLE 4 (senior)/Exp01/DNN Ex No 1.ipynb

@@ -0,0 +1,398 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Train a deep neural network for an Image classification task using Bean leaf dataset\n",
+    "\n",
+    "**Dataset**: <https://www.kaggle.com/datasets/prakharrastogi534/bean-leaf-dataset>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import necessary packages\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "import tensorflow as tf\n",
+    "\n",
+    "from tensorflow import keras\n",
+    "from sklearn.metrics import confusion_matrix\n",
+    "\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import random as rn\n",
+    "from os import listdir\n",
+    "from sklearn.preprocessing import LabelBinarizer\n",
+    "from keras.models import Sequential\n",
+    "from keras.layers import Activation, Flatten, Dropout, Dense\n",
+    "from keras import backend as K\n",
+    "from keras.preprocessing.image import ImageDataGenerator\n",
+    "from keras.preprocessing import image\n",
+    "from tensorflow.keras.preprocessing.image import img_to_array\n",
+    "from sklearn.preprocessing import MultiLabelBinarizer\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import matplotlib.pyplot as plt\n",
+    "from numpy.random import seed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "import skimage.io\n",
+    "import skimage.transform\n",
+    "import skimage.filters\n",
+    "import keras\n",
+    "from skimage import data, exposure, img_as_float"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "EPOCHS = 25\n",
+    "INIT_LR = 1e-3\n",
+    "BS = 32\n",
+    "default_image_size = tuple((128, 128))\n",
+    "image_size = 0\n",
+    "directory_root = r\"C://Users/admin/Downloads/Bean//train\" # Change this to your directory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def convert_image_to_array(image_dir):\n",
+    "    try:\n",
+    "        image = cv2.imread(image_dir)\n",
+    "        if image is not None :\n",
+    "            image = cv2.resize(image, default_image_size)\n",
+    "            return img_to_array(image)\n",
+    "        else :\n",
+    "            return np.array([])\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error : {e}\")\n",
+    "        return None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image_list, label_list = [], []\n",
+    "try:\n",
+    "    print(\"[INFO] Loading images ...\")\n",
+    "    root_dir = listdir(directory_root)\n",
+    "    for directory in root_dir :\n",
+    "        # remove .DS_Store from list\n",
+    "        if directory == \".DS_Store\" :\n",
+    "            root_dir.remove(directory)\n",
+    "\n",
+    "    for plant_folder in root_dir :\n",
+    "        plant_disease_folder_list = listdir(f\"{directory_root}/{plant_folder}\")\n",
+    "\n",
+    "\n",
+    "        for plant_disease_folder in plant_disease_folder_list:\n",
+    "            print(f\"[INFO] Processing {plant_disease_folder} ...\")\n",
+    "\n",
+    "            plant_disease_image_list = listdir(f\"{directory_root}/{plant_folder}/{plant_disease_folder}/\")\n",
+    "            print(plant_disease_folder)\n",
+    "            i=len(plant_disease_image_list)\n",
+    "            print (i)\n",
+    "            for image in plant_disease_image_list[:10000]:\n",
+    "                image_directory = f\"{directory_root}/{plant_folder}/{plant_disease_folder}/{image}\"\n",
+    "                if image_directory.endswith(\".jpg\") == True or image_directory.endswith(\".JPG\") == True:\n",
+    "                    image_list.append(convert_image_to_array(image_directory))\n",
+    "                    label_list.append(plant_disease_folder)\n",
+    "                elif image_directory.endswith(\".png\") == True or image_directory.endswith(\".PNG\") == True:\n",
+    "                    image_list.append(convert_image_to_array(image_directory))\n",
+    "                    label_list.append(plant_disease_folder)\n",
+    "              \n",
+    "    print(\"[INFO] Image loading completed\")\n",
+    "except Exception as e:\n",
+    "    print(f\"Error : {e}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image_size = len(image_list)\n",
+    "print(image_size)\n",
+    "label_binarizer = LabelBinarizer()\n",
+    "image_labels = label_binarizer.fit_transform(label_list)\n",
+    "print(image_labels)\n",
+    "n_classes = len(label_binarizer.classes_)\n",
+    "np_image_list = np.array(image_list, dtype=np.float32) / 225.0\n",
+    "print(\"[INFO] Spliting data to train, test\")\n",
+    "X_train, X_test, y_train, y_test = train_test_split(np_image_list, image_labels,\n",
+    "                                                    test_size=0.2, random_state = 42,shuffle=True)\n",
+    "\n",
+    "print(image_labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.imshow(X_train[1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Check the shape of the data\n",
+    "X_train.shape, X_test.shape, y_train.shape, y_test.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Check the data type of the dataset\n",
+    "X_train.dtype, X_test.dtype, y_train.dtype, y_test.dtype"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type(y_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Build the sequential model\n",
+    "\n",
+    "model=tf.keras.Sequential([\n",
+    "    tf.keras.layers.Flatten(input_shape=(128,128,3)),\n",
+    "    tf.keras.layers.Dense(128,activation='relu'),\n",
+    "    tf.keras.layers.Dense(128,activation='relu'),\n",
+    "    tf.keras.layers.Dense(128,activation='relu'),\n",
+    "    tf.keras.layers.Dense(256,activation='relu'),\n",
+    "    tf.keras.layers.Dense(3,activation='softmax')\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Check model summary\n",
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Compile the model\n",
+    "\n",
+    "model.compile(loss = tf.keras.losses.CategoricalCrossentropy(),\n",
+    "              optimizer = tf.keras.optimizers.Adam(), metrics = ['accuracy'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Fit the model\n",
+    "\n",
+    "model_history = model.fit(X_train, y_train, validation_data = (X_test, y_test), epochs = 50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Evaluate the model\n",
+    "\n",
+    "model.evaluate(X_test, y_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tensorflow.keras.utils import plot_model\n",
+    "\n",
+    "plot_model(model, show_shapes = True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize = (12, 6))\n",
+    "plt.style.use('fivethirtyeight')\n",
+    "train_loss = model_history.history['loss']\n",
+    "val_loss = model_history.history['val_loss'] \n",
+    "epoch = range(1, 51)\n",
+    "sns.lineplot(epoch, train_loss, label = 'Training Loss')\n",
+    "sns.lineplot(epoch, val_loss, label = 'Validation Loss')\n",
+    "plt.title('Training and Validation Loss\\n')\n",
+    "plt.xlabel('Epochs')\n",
+    "plt.ylabel('Loss')\n",
+    "plt.legend(loc = 'best')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize = (12, 6))\n",
+    "\n",
+    "train_loss = model_history.history['accuracy']\n",
+    "val_loss = model_history.history['val_accuracy'] \n",
+    "epoch = range(1, 51)\n",
+    "sns.lineplot(epoch, train_loss, label = 'Training accuracy')\n",
+    "sns.lineplot(epoch, val_loss, label = 'Validation accuracy')\n",
+    "plt.title('Training and Validation Accuracy\\n')\n",
+    "plt.xlabel('Epochs')\n",
+    "plt.ylabel('Accuracy')\n",
+    "plt.legend(loc = 'best')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Making predictions\n",
+    "\n",
+    "y_probs = model.predict(X_test)\n",
+    "y_preds = y_probs.argmax(axis = 1)\n",
+    "\n",
+    "y_preds[:100]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "label = ['angular_leaf_spot',        \n",
+    "'bean_rust' ,  \n",
+    "'healthy' ,       \n",
+    " ]\n",
+    "Ypred = model.predict(X_test)\n",
+    "\n",
+    "Ypred = np.argmax(Ypred, axis=1)\n",
+    "Ytrue = np.argmax(y_test, axis=1)\n",
+    "\n",
+    "cm = confusion_matrix(Ytrue, Ypred)\n",
+    "plt.figure(figsize=(12, 12))\n",
+    "ax = sns.heatmap(cm, cmap=\"rocket_r\", fmt=\".01f\",annot_kws={'size':24}, annot=True, square=True, xticklabels=label, yticklabels=label)\n",
+    "ax.set_ylabel('Actual', fontsize=20)\n",
+    "ax.set_xlabel('Predicted', fontsize=20)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import confusion_matrix, classification_report\n",
+    "\n",
+    "print('Classification Report:')\n",
+    "print(classification_report(Ytrue, Ypred))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kaggle": {
+   "accelerator": "gpu",
+   "dataSources": [
+    {
+     "datasetId": 2243,
+     "sourceId": 9243,
+     "sourceType": "datasetVersion"
+    }
+   ],
+   "dockerImageVersionId": 30097,
+   "isGpuEnabled": true,
+   "isInternetEnabled": true,
+   "language": "python",
+   "sourceType": "notebook"
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}