noshot 12.0.0__tar.gz → 13.0.0__tar.gz

{noshot-12.0.0 → noshot-13.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noshot
-Version: 12.0.0
+Version: 13.0.0
 Summary: Support library for Artificial Intelligence, Machine Learning and Data Science tools
 Author: Tim Stan S
 License: MIT

{noshot-12.0.0 → noshot-13.0.0}/noshot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noshot
-Version: 12.0.0
+Version: 13.0.0
 Summary: Support library for Artificial Intelligence, Machine Learning and Data Science tools
 Author: Tim Stan S
 License: MIT

noshot-13.0.0/noshot.egg-info/SOURCES.txt

@@ -0,0 +1,35 @@
+LICENSE.txt
+README.md
+setup.py
+noshot.egg-info/PKG-INFO
+noshot.egg-info/SOURCES.txt
+noshot.egg-info/dependency_links.txt
+noshot.egg-info/not-zip-safe
+noshot.egg-info/top_level.txt
+src/noshot/__init__.py
+src/noshot/main.py
+src/noshot/data/DLE FSD BDA/DLE/DLE 1 (Json)/1. DNN (Image Classification).ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 1 (Json)/2. DNN vs CNN.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 1 (Json)/3. CNN (Object Detecrion).ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 1 (Json)/4. FCN (Image Segmentaion).ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 2 (tim stan s)/1.1 DNN (Pytorch).ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 2 (tim stan s)/1.2 DNN (Tensorflow).ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 2 (tim stan s)/1.3 DNN (Image Classification).ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 2 (tim stan s)/2.1 DNN vs CNN.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 2 (tim stan s)/2.2 DNN vs CNN.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 2 (tim stan s)/4. FCNN (Image Segmentation).ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 2 (tim stan s)/Lab Excercise (Training DNN).ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 2 (tim stan s)/Load-Images.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 3 (sonic boy)/Ex1.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 3 (sonic boy)/Ex2.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 3 (sonic boy)/Ex3.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 3 (sonic boy)/Ex4.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 4 (senior)/Exp01/DNN Ex No 1.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 4 (senior)/Exp01/Ex No 1 Build in dataset.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 4 (senior)/Exp01/Exp1-Short-DL_ANN_ImageClassification.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 4 (senior)/Exp01/OR GATE .ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 4 (senior)/Exp02/Exp2-Short-DL_CNN_ImageClassification.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 4 (senior)/Exp03/DL-Ex3-RNN.ipynb
+src/noshot/data/DLE FSD BDA/DLE/DLE 4 (senior)/Exp04/Ex no 4.ipynb
+src/noshot/utils/__init__.py
+src/noshot/utils/shell_utils.py

{noshot-12.0.0 → noshot-13.0.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as f:
 
 setup(
     name="noshot",
-    version="12.0.0",
+    version="13.0.0",
     author="Tim Stan S",
     description="Support library for Artificial Intelligence, Machine Learning and Data Science tools",
     long_description=long_description,

noshot-13.0.0/src/noshot/data/DLE FSD BDA/DLE/DLE 2 (tim stan s)/1.1 DNN (Pytorch).ipynb

@@ -0,0 +1,164 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ab870464-a374-4292-9b59-0fe123e478df",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import numpy as np\n",
+    "from PIL import Image\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import classification_report, confusion_matrix\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "import torchvision.transforms as transforms\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "dataset_path = \"<filepath>\"\n",
+    "IMG_SIZE = 128\n",
+    "BATCH_SIZE = 32\n",
+    "EPOCHS = 10\n",
+    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "\n",
+    "class PetDataset(Dataset):\n",
+    "    def __init__(self, images, labels, transform=None):\n",
+    "        self.images = images\n",
+    "        self.labels = labels\n",
+    "        self.transform = transform\n",
+    "    def __len__(self):\n",
+    "        return len(self.images)\n",
+    "    def __getitem__(self, idx):\n",
+    "        img = self.images[idx]\n",
+    "        if self.transform:\n",
+    "            img = self.transform(img)\n",
+    "        label = self.labels[idx]\n",
+    "        return img, label\n",
+    "\n",
+    "def load_images(folder_path, image_size=IMG_SIZE):\n",
+    "    images, labels, class_names = [], [], sorted(os.listdir(folder_path))\n",
+    "    for label, class_name in enumerate(class_names):\n",
+    "        class_dir = os.path.join(folder_path, class_name)\n",
+    "        for file in os.listdir(class_dir):\n",
+    "            img = Image.open(os.path.join(class_dir, file)).convert('RGB').resize((image_size,image_size))\n",
+    "            images.append(np.array(img)/255.0)\n",
+    "            labels.append(label)\n",
+    "    return np.array(images, dtype=np.float32), np.array(labels), class_names\n",
+    "\n",
+    "X, y, class_names = load_images(dataset_path)\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
+    "transform = transforms.Compose([transforms.ToTensor()])\n",
+    "train_dataset = PetDataset(X_train, y_train, transform=transform)\n",
+    "test_dataset = PetDataset(X_test, y_test, transform=transform)\n",
+    "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
+    "test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE)\n",
+    "\n",
+    "class SimpleCNN(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "        self.conv = nn.Sequential(\n",
+    "            nn.Conv2d(3,32,3,padding=1), nn.ReLU(), nn.MaxPool2d(2),\n",
+    "            nn.Conv2d(32,64,3,padding=1), nn.ReLU(), nn.MaxPool2d(2)\n",
+    "        )\n",
+    "        self.fc = nn.Sequential(\n",
+    "            nn.Flatten(),\n",
+    "            nn.Linear(64*32*32,128), nn.ReLU(),\n",
+    "            nn.Linear(128,len(class_names))\n",
+    "        )\n",
+    "    def forward(self,x):\n",
+    "        return self.fc(self.conv(x))\n",
+    "\n",
+    "model = SimpleCNN().to(device)\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
+    "\n",
+    "train_losses, val_losses, train_acc, val_acc = [], [], [], []\n",
+    "\n",
+    "for epoch in range(EPOCHS):\n",
+    "    model.train()\n",
+    "    running_loss, correct, total = 0,0,0\n",
+    "    for imgs, labels in train_loader:\n",
+    "        imgs, labels = imgs.to(device), labels.to(device)\n",
+    "        optimizer.zero_grad()\n",
+    "        outputs = model(imgs)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        running_loss += loss.item()\n",
+    "        _, preds = torch.max(outputs,1)\n",
+    "        correct += (preds==labels).sum().item()\n",
+    "        total += labels.size(0)\n",
+    "    train_losses.append(running_loss/len(train_loader))\n",
+    "    train_acc.append(correct/total)\n",
+    "\n",
+    "    model.eval()\n",
+    "    val_loss, correct, total = 0,0,0\n",
+    "    with torch.no_grad():\n",
+    "        for imgs, labels in test_loader:\n",
+    "            imgs, labels = imgs.to(device), labels.to(device)\n",
+    "            outputs = model(imgs)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            val_loss += loss.item()\n",
+    "            _, preds = torch.max(outputs,1)\n",
+    "            correct += (preds==labels).sum().item()\n",
+    "            total += labels.size(0)\n",
+    "    val_losses.append(val_loss/len(test_loader))\n",
+    "    val_acc.append(correct/total)\n",
+    "    print(f\"Epoch {epoch+1}/{EPOCHS} - Train Acc: {train_acc[-1]:.3f}, Val Acc: {val_acc[-1]:.3f}\")\n",
+    "\n",
+    "y_true, y_pred = [], []\n",
+    "model.eval()\n",
+    "with torch.no_grad():\n",
+    "    for imgs, labels in test_loader:\n",
+    "        imgs, labels = imgs.to(device), labels.to(device)\n",
+    "        outputs = model(imgs)\n",
+    "        preds = torch.argmax(outputs,1)\n",
+    "        y_true.extend(labels.cpu().numpy())\n",
+    "        y_pred.extend(preds.cpu().numpy())\n",
+    "\n",
+    "print(\"Classification Report:\")\n",
+    "print(classification_report(y_true, y_pred, target_names=class_names))\n",
+    "print(\"Confusion Matrix:\")\n",
+    "print(confusion_matrix(y_true, y_pred))\n",
+    "\n",
+    "plt.figure(figsize=(12,4))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(train_acc,label='Train Accuracy')\n",
+    "plt.plot(val_acc,label='Val Accuracy')\n",
+    "plt.title('Accuracy')\n",
+    "plt.legend()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.plot(train_losses,label='Train Loss')\n",
+    "plt.plot(val_losses,label='Val Loss')\n",
+    "plt.title('Loss')\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "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-13.0.0/src/noshot/data/DLE FSD BDA/DLE/DLE 2 (tim stan s)/1.2 DNN (Tensorflow).ipynb

@@ -0,0 +1,94 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "272ad344-26ac-46a9-887a-823bc177175e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import numpy as np\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import classification_report, confusion_matrix\n",
+    "import matplotlib.pyplot as plt\n",
+    "import tensorflow as tf\n",
+    "from tensorflow.keras.preprocessing.image import load_img, img_to_array\n",
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense\n",
+    "\n",
+    "dataset_path = \"<filepath>\"\n",
+    "IMG_SIZE = (128, 128)\n",
+    "\n",
+    "def load_images(folder_path, image_size=IMG_SIZE):\n",
+    "    images, labels, class_names = [], [], sorted(os.listdir(folder_path))\n",
+    "    for label, class_name in enumerate(class_names):\n",
+    "        class_dir = os.path.join(folder_path, class_name)\n",
+    "        for file in os.listdir(class_dir):\n",
+    "            img = load_img(os.path.join(class_dir, file), target_size=image_size)\n",
+    "            images.append(img_to_array(img)/255.0)\n",
+    "            labels.append(label)\n",
+    "    return np.array(images), np.array(labels), class_names\n",
+    "\n",
+    "X, y, class_names = load_images(dataset_path)\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
+    "\n",
+    "model = Sequential([\n",
+    "    Conv2D(32, (3,3), activation='relu', input_shape=(*IMG_SIZE,3)),\n",
+    "    MaxPooling2D(2,2),\n",
+    "    Conv2D(64, (3,3), activation='relu'),\n",
+    "    MaxPooling2D(2,2),\n",
+    "    Flatten(),\n",
+    "    Dense(128, activation='relu'),\n",
+    "    Dense(len(class_names), activation='softmax')\n",
+    "])\n",
+    "\n",
+    "model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])\n",
+    "history = model.fit(X_train, y_train, validation_split=0.2, epochs=10, batch_size=32)\n",
+    "\n",
+    "test_loss, test_acc = model.evaluate(X_test, y_test)\n",
+    "print(f\"Test Accuracy: {test_acc*100:.2f}%\")\n",
+    "\n",
+    "y_pred = np.argmax(model.predict(X_test), axis=-1)\n",
+    "print(\"Classification Report:\")\n",
+    "print(classification_report(y_test, y_pred, target_names=class_names))\n",
+    "print(\"Confusion Matrix:\")\n",
+    "print(confusion_matrix(y_test, y_pred))\n",
+    "\n",
+    "plt.figure(figsize=(12,4))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(history.history['accuracy'], label='Train Accuracy')\n",
+    "plt.plot(history.history['val_accuracy'], label='Val Accuracy')\n",
+    "plt.title('Accuracy')\n",
+    "plt.legend()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.plot(history.history['loss'], label='Train Loss')\n",
+    "plt.plot(history.history['val_loss'], label='Val Loss')\n",
+    "plt.title('Loss')\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "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-13.0.0/src/noshot/data/DLE FSD BDA/DLE/DLE 2 (tim stan s)/1.3 DNN (Image Classification).ipynb

@@ -0,0 +1,134 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e5e0508-ead9-401c-bb0a-98e48722c959",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import torch.optim as optim\n",
+    "from torchvision import datasets, transforms\n",
+    "from torch.utils.data import DataLoader\n",
+    "from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "data_transforms = transforms.Compose([\n",
+    "    transforms.Resize(256),\n",
+    "    transforms.CenterCrop(224),\n",
+    "    transforms.ToTensor(),\n",
+    "    transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
+    "                         std=[0.229, 0.224, 0.225])\n",
+    "])\n",
+    "\n",
+    "data_dir = \"dataset\"\n",
+    "image_dataset = datasets.ImageFolder(root=data_dir, transform=data_transforms)\n",
+    "batch_size = 32\n",
+    "dataloader = DataLoader(image_dataset, batch_size=batch_size, shuffle=True)\n",
+    "\n",
+    "class FeedforwardNet(nn.Module):\n",
+    "    def __init__(self, input_size, num_classes):\n",
+    "        super(FeedforwardNet, self).__init__()\n",
+    "        self.fc1 = nn.Linear(input_size, 512)\n",
+    "        self.fc2 = nn.Linear(512, 256)\n",
+    "        self.fc3 = nn.Linear(256, num_classes)\n",
+    "        self.relu = nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = x.view(x.size(0), -1)\n",
+    "        x = self.relu(self.fc1(x))\n",
+    "        x = self.relu(self.fc2(x))\n",
+    "        x = self.fc3(x)\n",
+    "        return x\n",
+    "\n",
+    "input_size = 224 * 224 * 3\n",
+    "num_classes = len(image_dataset.classes)\n",
+    "model = FeedforwardNet(input_size, num_classes)\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "model.to(device)\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
+    "num_epochs = 10\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    model.train()\n",
+    "    running_loss = 0.0\n",
+    "    for images, labels in dataloader:\n",
+    "        images, labels = images.to(device), labels.to(device)\n",
+    "        outputs = model(images)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "        optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        running_loss += loss.item() * images.size(0)\n",
+    "    epoch_loss = running_loss / len(image_dataset)\n",
+    "    print(f\"Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss:.4f}\")\n",
+    "\n",
+    "model.eval()\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in dataloader:\n",
+    "        images, labels = images.to(device), labels.to(device)\n",
+    "        outputs = model(images)\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "    accuracy = 100 * correct / total\n",
+    "print(f\"Accuracy of the model on {total} images: {accuracy:.2f}%\")\n",
+    "\n",
+    "true_labels = []\n",
+    "predicted_labels = []\n",
+    "with torch.no_grad():\n",
+    "    for images, labels in dataloader:\n",
+    "        images, labels = images.to(device), labels.to(device)\n",
+    "        outputs = model(images)\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        true_labels.extend(labels.cpu().numpy())\n",
+    "        predicted_labels.extend(predicted.cpu().numpy())\n",
+    "\n",
+    "precision = precision_score(true_labels, predicted_labels, average='weighted')\n",
+    "recall = recall_score(true_labels, predicted_labels, average='weighted')\n",
+    "f1 = f1_score(true_labels, predicted_labels, average='weighted')\n",
+    "print(f\"Precision: {precision:.4f}\")\n",
+    "print(f\"Recall: {recall:.4f}\")\n",
+    "print(f\"F1-score: {f1:.4f}\")\n",
+    "\n",
+    "cm = confusion_matrix(true_labels, predicted_labels)\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',\n",
+    "            xticklabels=image_dataset.classes,\n",
+    "            yticklabels=image_dataset.classes)\n",
+    "plt.xlabel('Predicted Labels')\n",
+    "plt.ylabel('True Labels')\n",
+    "plt.title('Confusion Matrix')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "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-13.0.0/src/noshot/data/DLE FSD BDA/DLE/DLE 2 (tim stan s)/2.1 DNN vs CNN.ipynb

@@ -0,0 +1,127 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "335957c2-a530-4a12-8b04-1475513e138f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import tensorflow as tf\n",
+    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D, Dropout\n",
+    "from tensorflow.keras.optimizers import Adam\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "data_dir = \"Bean_Dataset/Bean_Dataset\"\n",
+    "img_height, img_width = 128, 128\n",
+    "batch_size = 32\n",
+    "\n",
+    "datagen = ImageDataGenerator(\n",
+    "    rescale=1./255,\n",
+    "    validation_split=0.2,\n",
+    "    rotation_range=20,\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",
+    ")\n",
+    "\n",
+    "train_gen = datagen.flow_from_directory(\n",
+    "    data_dir, target_size=(img_height, img_width),\n",
+    "    batch_size=batch_size, class_mode='categorical', subset='training'\n",
+    ")\n",
+    "\n",
+    "val_gen = datagen.flow_from_directory(\n",
+    "    data_dir, target_size=(img_height, img_width),\n",
+    "    batch_size=batch_size, class_mode='categorical', subset='validation'\n",
+    ")\n",
+    "\n",
+    "num_classes = len(train_gen.class_indices)\n",
+    "\n",
+    "def build_dnn():\n",
+    "    model = Sequential([\n",
+    "        Flatten(input_shape=(img_height, img_width, 3)),\n",
+    "        Dense(512, activation='relu'),\n",
+    "        Dropout(0.5),\n",
+    "        Dense(256, activation='relu'),\n",
+    "        Dropout(0.5),\n",
+    "        Dense(num_classes, activation='softmax')\n",
+    "    ])\n",
+    "    model.compile(optimizer=Adam(), loss='categorical_crossentropy', metrics=['accuracy'])\n",
+    "    return model\n",
+    "\n",
+    "def build_cnn():\n",
+    "    model = Sequential([\n",
+    "        Conv2D(32, (3,3), activation='relu', input_shape=(img_height, img_width, 3)),\n",
+    "        MaxPooling2D(2,2),\n",
+    "        Conv2D(64, (3,3), activation='relu'),\n",
+    "        MaxPooling2D(2,2),\n",
+    "        Conv2D(128, (3,3), activation='relu'),\n",
+    "        MaxPooling2D(2,2),\n",
+    "        Flatten(),\n",
+    "        Dense(512, activation='relu'),\n",
+    "        Dropout(0.5),\n",
+    "        Dense(num_classes, activation='softmax')\n",
+    "    ])\n",
+    "    model.compile(optimizer=Adam(), loss='categorical_crossentropy', metrics=['accuracy'])\n",
+    "    return model\n",
+    "\n",
+    "dnn_model = build_dnn()\n",
+    "dnn_history = dnn_model.fit(train_gen, epochs=20, validation_data=val_gen)\n",
+    "\n",
+    "cnn_model = build_cnn()\n",
+    "cnn_history = cnn_model.fit(train_gen, epochs=20, validation_data=val_gen)\n",
+    "\n",
+    "plt.figure(figsize=(12,5))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(dnn_history.history['accuracy'], label='DNN Train')\n",
+    "plt.plot(dnn_history.history['val_accuracy'], label='DNN Val')\n",
+    "plt.plot(cnn_history.history['accuracy'], label='CNN Train')\n",
+    "plt.plot(cnn_history.history['val_accuracy'], label='CNN Val')\n",
+    "plt.title('Accuracy')\n",
+    "plt.xlabel('Epoch')\n",
+    "plt.ylabel('Accuracy')\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.plot(dnn_history.history['loss'], label='DNN Train')\n",
+    "plt.plot(dnn_history.history['val_loss'], label='DNN Val')\n",
+    "plt.plot(cnn_history.history['loss'], label='CNN Train')\n",
+    "plt.plot(cnn_history.history['val_loss'], label='CNN Val')\n",
+    "plt.title('Loss')\n",
+    "plt.xlabel('Epoch')\n",
+    "plt.ylabel('Loss')\n",
+    "plt.legend()\n",
+    "plt.show()\n",
+    "\n",
+    "print(f\"DNN Train Acc: {dnn_history.history['accuracy'][-1]:.4f}, Val Acc: {dnn_history.history['val_accuracy'][-1]:.4f}\")\n",
+    "print(f\"CNN Train Acc: {cnn_history.history['accuracy'][-1]:.4f}, Val Acc: {cnn_history.history['val_accuracy'][-1]:.4f}\")"
+   ]
+  }
+ ],
+ "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
+}