CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import cv2\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torchvision.transforms as transforms\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "# Define a custom dataset class\n",
    "class CustomDataset(Dataset):\n",
    "    def __init__(self, images, labels, transform=None):\n",
    "        self.images = images\n",
    "        self.labels = labels\n",
    "        self.transform = transform\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.images)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        image = self.images[idx]\n",
    "        label = self.labels[idx]\n",
    "\n",
    "        if self.transform:\n",
    "            image = self.transform(image)\n",
    "\n",
    "        return image, label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 1: Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Folder T2S9 does not have a corresponding species label.\n",
      "Folder T4S1 does not have a corresponding species label.\n",
      "Folder T4S4 does not have a corresponding species label.\n"
     ]
    }
   ],
   "source": [
    "species_mapping = pd.read_csv(\"species_percentage.csv\")\n",
    "species_mapping = species_mapping[species_mapping['Percentage'] >= 80]\n",
    "\n",
    "# data_dir = 'D:/Yehmh/test_py/202301/P00074_transect_1/1m_1m/known'\n",
    "# Folder_names = \"T1S\"\n",
    "# image_size = 34\n",
    "\n",
    "data_dir = 'D:/Yehmh/test_py/202301/P00073_transect_234/5m_5m/known'\n",
    "Folder_names = \"T\"\n",
    "\n",
    "X = []  # Features\n",
    "y = []  # Labels\n",
    "\n",
    "for folder in os.listdir(data_dir):\n",
    "    if folder.startswith(Folder_names):\n",
    "        species_info = species_mapping.loc[species_mapping[\"Plot\"] == folder]\n",
    "        if not species_info.empty and not pd.isna(species_info[\"SpeciesID\"].values[0]):\n",
    "            species = species_info[\"SpeciesID\"].values[0]\n",
    "            for file in os.listdir(os.path.join(data_dir, folder)):\n",
    "                if file.endswith(\".tif\"):\n",
    "                    image_path = os.path.join(data_dir, folder, file)\n",
    "                    image = cv2.imread(image_path)\n",
    "                    if image.shape[0] > 64:\n",
    "                        image = cv2.resize(image, (64, 64))  # Resize image if necessary\n",
    "                    else:\n",
    "                        print(\"image size: \", image.shape)\n",
    "                    \n",
    "                    X.append(image)\n",
    "                    y.append(species)\n",
    "        else:\n",
    "            print(f\"Folder {folder} does not have a corresponding species label.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2: Data Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_encoder = LabelEncoder()\n",
    "y = label_encoder.fit_transform(y)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 5 6]\n",
      "[3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3\n",
      " 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3\n",
      " 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 1\n",
      " 1 1 1 1 1 1 1 1 1 1 1 3 3 3 3 3 3 3 3 3 3 3 3 3 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 3 3 3\n",
      " 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3\n",
      " 3 3 3 3 3 3 3 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n",
      "265 67\n"
     ]
    }
   ],
   "source": [
    "print(label_encoder.classes_)\n",
    "print(y)\n",
    "print(len(X_train), len(X_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3: Define transformations and create datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),  # Convert image to PyTorch tensor\n",
    "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # Normalize image data\n",
    "])\n",
    "\n",
    "train_dataset = CustomDataset(X_train, y_train, transform=transform)\n",
    "test_dataset = CustomDataset(X_test, y_test, transform=transform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Data Augmentation ------\n",
    "\n",
    "# from PIL import Image\n",
    "\n",
    "# train_transform = transforms.Compose([\n",
    "#     transforms.Lambda(lambda x: Image.fromarray(x)),  # Convert NumPy array to PIL Image\n",
    "#     transforms.RandomHorizontalFlip(),  # Randomly flip the images horizontally\n",
    "#     transforms.RandomRotation(degrees=15),  # Randomly rotate the images by up to 15 degrees\n",
    "#     transforms.RandomCrop(size=(32, 32), padding=4),  # Randomly crop a 32x32 region of the image with padding\n",
    "#     transforms.ToTensor(),  # Convert image to PyTorch tensor\n",
    "#     transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])  # Normalize image data\n",
    "# ])\n",
    "\n",
    "# test_transform = transforms.Compose([\n",
    "#     transforms.ToTensor(),  # Convert image to PyTorch tensor\n",
    "#     transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])  # Normalize image data\n",
    "# ])\n",
    "\n",
    "# train_dataset = CustomDataset(X_train, y_train, transform=train_transform)\n",
    "# test_dataset = CustomDataset(X_test, y_test, transform=test_transform)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 4: Create data loaders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
    "# test_loader is created with shuffle=False. \n",
    "# Ensures that the evaluation process remains consistent across different evaluations \n",
    "# and that the model is tested on the same data distribution every time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 5: Define the CNN model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64, 64, 3)\n"
     ]
    }
   ],
   "source": [
    "print(image.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self, num_classes):\n",
    "        super(CNN, self).__init__()\n",
    "        # Define the convolutional layers\n",
    "        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)     # (in_channels (rgb), out_channels, filter_num, stride, padding), default stride = 1\n",
    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
    "        self.conv3 = nn.Conv2d(64, 64, kernel_size=3, padding=1)\n",
    "        # Define the fully connected layers\n",
    "        self.fc1 = nn.Linear(64 * 8 * 8, 128)\n",
    "        # self.fc1 = nn.Linear(64 * 4 * 4, 128)\n",
    "        self.fc2 = nn.Linear(128, num_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Define the forward pass through the network\n",
    "        x = nn.functional.relu(self.conv1(x))\n",
    "        x = nn.functional.max_pool2d(x, 2)\n",
    "        x = nn.functional.relu(self.conv2(x))\n",
    "        x = nn.functional.max_pool2d(x, 2)\n",
    "        x = nn.functional.relu(self.conv3(x))\n",
    "        x = nn.functional.max_pool2d(x, 2)\n",
    "        # x = x.view(-1, 64 * 16 * 16)\n",
    "        x = x.view(x.size(0), -1)\n",
    "        x = nn.functional.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "        # return nn.functional.softmax(x, dim=1)  # Apply softmax activation for multi-class classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 6: Initialize model. loss function, and optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = CNN(num_classes=len(label_encoder.classes_))\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(len(label_encoder.classes_))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 7: Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy(predictions, laels):\n",
    "    pred = torch.max(prediction.data, 1)[1]\n",
    "    rights = pred.eq(labels.data.view_as(pred)).sum()\n",
    "    return rights, len(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# num_epochs = 5000\n",
    "# for epoch in range(num_epochs):\n",
    "#     model.train()\n",
    "#     for images, labels in train_loader:\n",
    "#         # print(\"Batch Shape - Images:\", images.shape)\n",
    "#         # print(\"Batch Shape - Labels:\", labels.shape)\n",
    "\n",
    "#         optimizer.zero_grad()   # Zero the gradient\n",
    "#         outputs = model(images) # Forward pass: computer predicted outputs\n",
    "#         # print(outputs.shape)\n",
    "#         loss = criterion(outputs, labels) # Compute the loss\n",
    "#         loss.backward()     # Backward pass: compute gradient of the loss with respect to model parameters\n",
    "#         optimizer.step()    # Update the model parameters based on the gradients\n",
    "\n",
    "#     print(f\"Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/100], Loss: 1.271635373433431, Accuracy: 0.36981132075471695\n",
      "Epoch [2/100], Loss: 1.0615625116560194, Accuracy: 0.5735849056603773\n",
      "Epoch [3/100], Loss: 1.066502120759752, Accuracy: 0.5622641509433962\n",
      "Epoch [4/100], Loss: 0.972279237376319, Accuracy: 0.6037735849056604\n",
      "Epoch [5/100], Loss: 1.0367319915029738, Accuracy: 0.6490566037735849\n",
      "Epoch [6/100], Loss: 0.8879634274376763, Accuracy: 0.6490566037735849\n",
      "Epoch [7/100], Loss: 0.8317416111628214, Accuracy: 0.6415094339622641\n",
      "Epoch [8/100], Loss: 0.7492787506845262, Accuracy: 0.6528301886792452\n",
      "Epoch [9/100], Loss: 0.6835910545455085, Accuracy: 0.7169811320754716\n",
      "Epoch [10/100], Loss: 0.632704668574863, Accuracy: 0.7433962264150943\n",
      "Epoch [11/100], Loss: 0.5782165461116366, Accuracy: 0.7735849056603774\n",
      "Epoch [12/100], Loss: 0.5497346023718516, Accuracy: 0.7773584905660378\n",
      "Epoch [13/100], Loss: 0.5296963420179155, Accuracy: 0.7811320754716982\n",
      "Epoch [14/100], Loss: 0.4560655504465103, Accuracy: 0.8113207547169812\n",
      "Epoch [15/100], Loss: 0.3901757241951095, Accuracy: 0.8377358490566038\n",
      "Epoch [16/100], Loss: 0.39670853482352364, Accuracy: 0.8339622641509434\n",
      "Epoch [17/100], Loss: 0.423676523897383, Accuracy: 0.8150943396226416\n",
      "Epoch [18/100], Loss: 0.3814468714925978, Accuracy: 0.8490566037735849\n",
      "Epoch [19/100], Loss: 0.30980126725302803, Accuracy: 0.8603773584905661\n",
      "Epoch [20/100], Loss: 0.2885744588242637, Accuracy: 0.9056603773584906\n",
      "Epoch [21/100], Loss: 0.19913041012154686, Accuracy: 0.939622641509434\n",
      "Epoch [22/100], Loss: 0.18850880530145434, Accuracy: 0.9320754716981132\n",
      "Epoch [23/100], Loss: 0.1503373020225101, Accuracy: 0.969811320754717\n",
      "Epoch [24/100], Loss: 0.10178719440268146, Accuracy: 0.9547169811320755\n",
      "Epoch [25/100], Loss: 0.2941991405354606, Accuracy: 0.9056603773584906\n",
      "Epoch [26/100], Loss: 0.4849175247881148, Accuracy: 0.8301886792452831\n",
      "Epoch [27/100], Loss: 0.4131762931744258, Accuracy: 0.8490566037735849\n",
      "Epoch [28/100], Loss: 0.21335818908280796, Accuracy: 0.9433962264150944\n",
      "Epoch [29/100], Loss: 0.14471501774258083, Accuracy: 0.9547169811320755\n",
      "Epoch [30/100], Loss: 0.09966442692610952, Accuracy: 0.9773584905660377\n",
      "Epoch [31/100], Loss: 0.06925873375601238, Accuracy: 0.9849056603773585\n",
      "Epoch [32/100], Loss: 0.06323809942437543, Accuracy: 0.9773584905660377\n",
      "Epoch [33/100], Loss: 0.038543167834480606, Accuracy: 0.9924528301886792\n",
      "Epoch [34/100], Loss: 0.025068654213100672, Accuracy: 1.0\n",
      "Epoch [35/100], Loss: 0.02679388214730554, Accuracy: 1.0\n",
      "Epoch [36/100], Loss: 0.014350218336201377, Accuracy: 0.9962264150943396\n",
      "Epoch [37/100], Loss: 0.010723621657234617, Accuracy: 1.0\n",
      "Epoch [38/100], Loss: 0.007224397423366706, Accuracy: 1.0\n",
      "Epoch [39/100], Loss: 0.009920850835947527, Accuracy: 0.9962264150943396\n",
      "Epoch [40/100], Loss: 0.02098433409507076, Accuracy: 0.9962264150943396\n",
      "Epoch [41/100], Loss: 0.12855601217597723, Accuracy: 0.9433962264150944\n",
      "Epoch [42/100], Loss: 0.04574680266280969, Accuracy: 0.9849056603773585\n",
      "Epoch [43/100], Loss: 0.03808929993667536, Accuracy: 0.9811320754716981\n",
      "Epoch [44/100], Loss: 0.03948755541609393, Accuracy: 0.9962264150943396\n",
      "Epoch [45/100], Loss: 0.031178377620461915, Accuracy: 0.9924528301886792\n",
      "Epoch [46/100], Loss: 0.053897214070376426, Accuracy: 0.9849056603773585\n",
      "Epoch [47/100], Loss: 0.05394813868527611, Accuracy: 0.9849056603773585\n",
      "Epoch [48/100], Loss: 0.020097509466318622, Accuracy: 1.0\n",
      "Epoch [49/100], Loss: 0.011220166815393087, Accuracy: 1.0\n",
      "Epoch [50/100], Loss: 0.005870959333454569, Accuracy: 1.0\n",
      "Epoch [51/100], Loss: 0.003451945085544139, Accuracy: 1.0\n",
      "Epoch [52/100], Loss: 0.002757411210849467, Accuracy: 1.0\n",
      "Epoch [53/100], Loss: 0.002117354548924292, Accuracy: 1.0\n",
      "Epoch [54/100], Loss: 0.0020754201363565195, Accuracy: 1.0\n",
      "Epoch [55/100], Loss: 0.0016106981072678333, Accuracy: 1.0\n",
      "Epoch [56/100], Loss: 0.0014404591250543792, Accuracy: 1.0\n",
      "Epoch [57/100], Loss: 0.0011922294894854228, Accuracy: 1.0\n",
      "Epoch [58/100], Loss: 0.0010739646709731056, Accuracy: 1.0\n",
      "Epoch [59/100], Loss: 0.001070325563584144, Accuracy: 1.0\n",
      "Epoch [60/100], Loss: 0.0010535272821370098, Accuracy: 1.0\n",
      "Epoch [61/100], Loss: 0.000754938993041934, Accuracy: 1.0\n",
      "Epoch [62/100], Loss: 0.0007641015755426553, Accuracy: 1.0\n",
      "Epoch [63/100], Loss: 0.0006497620714880112, Accuracy: 1.0\n",
      "Epoch [64/100], Loss: 0.0006578604936496251, Accuracy: 1.0\n",
      "Epoch [65/100], Loss: 0.0005994917753721691, Accuracy: 1.0\n",
      "Epoch [66/100], Loss: 0.0005291225097607821, Accuracy: 1.0\n",
      "Epoch [67/100], Loss: 0.00047712131021803036, Accuracy: 1.0\n",
      "Epoch [68/100], Loss: 0.00044452738560115296, Accuracy: 1.0\n",
      "Epoch [69/100], Loss: 0.0003863114009921749, Accuracy: 1.0\n",
      "Epoch [70/100], Loss: 0.0004211636535021373, Accuracy: 1.0\n",
      "Epoch [71/100], Loss: 0.0003679389046737924, Accuracy: 1.0\n",
      "Epoch [72/100], Loss: 0.00030267934198491275, Accuracy: 1.0\n",
      "Epoch [73/100], Loss: 0.0003271898062343502, Accuracy: 1.0\n",
      "Epoch [74/100], Loss: 0.00027247862453805283, Accuracy: 1.0\n",
      "Epoch [75/100], Loss: 0.000251779860668143, Accuracy: 1.0\n",
      "Epoch [76/100], Loss: 0.0002629039340212734, Accuracy: 1.0\n",
      "Epoch [77/100], Loss: 0.00025119542584030167, Accuracy: 1.0\n",
      "Epoch [78/100], Loss: 0.00023858798724379286, Accuracy: 1.0\n",
      "Epoch [79/100], Loss: 0.00020683781298834624, Accuracy: 1.0\n",
      "Epoch [80/100], Loss: 0.00019985481372310055, Accuracy: 1.0\n",
      "Epoch [81/100], Loss: 0.0001858379582699854, Accuracy: 1.0\n",
      "Epoch [82/100], Loss: 0.0001815603498269209, Accuracy: 1.0\n",
      "Epoch [83/100], Loss: 0.00016281141547046395, Accuracy: 1.0\n",
      "Epoch [84/100], Loss: 0.00015041699589346536, Accuracy: 1.0\n",
      "Epoch [85/100], Loss: 0.00015415543708109504, Accuracy: 1.0\n",
      "Epoch [86/100], Loss: 0.000148954520732837, Accuracy: 1.0\n",
      "Epoch [87/100], Loss: 0.00013051998151543862, Accuracy: 1.0\n",
      "Epoch [88/100], Loss: 0.00011988455258283971, Accuracy: 1.0\n",
      "Epoch [89/100], Loss: 0.00011955037835933681, Accuracy: 1.0\n",
      "Epoch [90/100], Loss: 0.00010855077521733215, Accuracy: 1.0\n",
      "Epoch [91/100], Loss: 0.00010131177946782878, Accuracy: 1.0\n",
      "Epoch [92/100], Loss: 0.00011144194811802461, Accuracy: 1.0\n",
      "Epoch [93/100], Loss: 9.66291809163522e-05, Accuracy: 1.0\n",
      "Epoch [94/100], Loss: 7.971039546343188e-05, Accuracy: 1.0\n",
      "Epoch [95/100], Loss: 7.838837255904864e-05, Accuracy: 1.0\n",
      "Epoch [96/100], Loss: 7.002141501288861e-05, Accuracy: 1.0\n",
      "Epoch [97/100], Loss: 6.730617557574685e-05, Accuracy: 1.0\n",
      "Epoch [98/100], Loss: 6.127567859140172e-05, Accuracy: 1.0\n",
      "Epoch [99/100], Loss: 5.9702262256501446e-05, Accuracy: 1.0\n",
      "Epoch [100/100], Loss: 5.741865445290589e-05, Accuracy: 1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "num_epochs = 100\n",
    "train_losses = []\n",
    "train_accuracies = []\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    model.train()\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    epoch_loss = 0.0\n",
    "    \n",
    "    for images, labels in train_loader:\n",
    "        optimizer.zero_grad()   # Zero the gradient\n",
    "        outputs = model(images) # Forward pass: compute predicted outputs\n",
    "        loss = criterion(outputs, labels) # Compute the loss\n",
    "        loss.backward()     # Backward pass: compute gradient of the loss with respect to model parameters\n",
    "        optimizer.step()    # Update the model parameters based on the gradients\n",
    "        \n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "        epoch_loss += loss.item()\n",
    "\n",
    "    train_accuracy = correct / total\n",
    "    train_loss = epoch_loss / len(train_loader)\n",
    "    train_accuracies.append(train_accuracy)\n",
    "    train_losses.append(train_loss)\n",
    "\n",
    "    print(f\"Epoch [{epoch + 1}/{num_epochs}], Loss: {train_loss}, Accuracy: {train_accuracy}\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(range(1, num_epochs + 1), train_losses, label='Training Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Training Loss')\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(range(1, num_epochs + 1), train_accuracies, label='Training Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Training Accuracy')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 8: Evaluate the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted: 3, Actual: 2\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 1, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 0, Actual: 3\n",
      "Predicted: 3, Actual: 1\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 3, Actual: 0\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 3, Actual: 0\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 1, Actual: 3\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 0, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 0, Actual: 2\n",
      "Predicted: 0, Actual: 3\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 1, Actual: 3\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 1, Actual: 1\n",
      "Predicted: 3, Actual: 3\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 0, Actual: 0\n",
      "Predicted: 1, Actual: 3\n",
      "Predicted: 1, Actual: 3\n",
      "Predicted: 3, Actual: 1\n",
      "Predicted: 3, Actual: 3\n",
      "Test Accuracy: 79.10%\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for images, labels in test_loader:\n",
    "        outputs = model(images)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "        # Print the predicted and actual labels\n",
    "        for i in range(len(labels)):\n",
    "            print(\"Predicted: {}, Actual: {}\".format(predicted[i], labels[i]))\n",
    "\n",
    "accuracy = correct / total\n",
    "print('Test Accuracy: {:.2f}%'.format(100 * accuracy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classify Whole"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import os\n",
    "# import cv2\n",
    "# import torch\n",
    "# import rasterio\n",
    "# import numpy as np\n",
    "# from torch.utils.data import DataLoader\n",
    "# from torchvision import transforms\n",
    "# # from your_model_file import CNN  # Import your CNN model class\n",
    "# import csv\n",
    "\n",
    "# # Function to extract coordinates from TIF files\n",
    "# def extract_coordinates(tif_file):\n",
    "#     with rasterio.open(tif_file) as src:\n",
    "#         crs = src.crs\n",
    "#         bounds = src.bounds\n",
    "#         center_x = (bounds.left + bounds.right) / 2\n",
    "#         center_y = (bounds.top + bounds.bottom) / 2\n",
    "#         return crs, (center_x, center_y)\n",
    "\n",
    "# # Define directory containing unknown TIF files\n",
    "# # unknown_photos_dir = 'D:\\\\Yehmh\\\\test_py\\\\202301\\\\P00073_transect_234\\\\10m_10m\\\\unknown'\n",
    "\n",
    "# def classify_and_write(unknown_photos_dir, output_csv_path):\n",
    "\n",
    "#     # Initialize lists to store unknown photo paths, coordinates, and predictions\n",
    "#     unknown_photos = []\n",
    "#     unknown_coordinates = []\n",
    "\n",
    "#     # Iterate over unknown TIF files\n",
    "#     for filename in os.listdir(unknown_photos_dir):\n",
    "#         if filename.endswith('.tif'):\n",
    "#             tif_file = os.path.join(unknown_photos_dir, filename)\n",
    "            \n",
    "#             # Extract coordinates\n",
    "#             crs, coordinates = extract_coordinates(tif_file)\n",
    "            \n",
    "#             # Append to the list\n",
    "#             unknown_photos.append(tif_file)\n",
    "#             unknown_coordinates.append((filename, crs, coordinates))\n",
    "\n",
    "#     # Now you have a list of unknown photo paths (unknown_photos) and corresponding coordinates (unknown_coordinates)\n",
    "\n",
    "#     # Load the trained model\n",
    "#     # model = CNN(num_classes=len(label_encoder.classes_))\n",
    "#     # model.load_state_dict(torch.load('path/to/your/trained/model.pth'))\n",
    "#     model.eval()  # Set the model to evaluation mode\n",
    "\n",
    "#     # Define transformations for the images\n",
    "#     transform = transforms.Compose([\n",
    "#         transforms.ToTensor(),  \n",
    "#         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  \n",
    "#     ])\n",
    "\n",
    "#     # Make predictions on the unknown photos\n",
    "#     predictions = []\n",
    "#     for photo_path in unknown_photos:\n",
    "#         # Load and preprocess the image\n",
    "#         image = cv2.imread(photo_path)\n",
    "#         image = cv2.resize(image, (64, 64))  # Resize image if necessary\n",
    "#         image = transform(image)\n",
    "#         image = image.unsqueeze(0)  # Add batch dimension\n",
    "        \n",
    "#         # Perform inference\n",
    "#         with torch.no_grad():\n",
    "#             output = model(image)\n",
    "#             predicted_class = torch.argmax(output).item()\n",
    "#             predicted_label = label_encoder.classes_[predicted_class]\n",
    "#             predictions.append(predicted_label)\n",
    "\n",
    "#     # Now you have the predictions for each unknown photo in the list 'predictions'\n",
    "#     # You can proceed to visualize the results on a map using the coordinates\n",
    "#     with open(output_csv_path, 'w', newline='') as csvfile:\n",
    "#         writer = csv.writer(csvfile)\n",
    "#         writer.writerow(['Filename', 'Latitude', 'Longitude', 'Predicted Species'])  # Write header\n",
    "#         for coord, label in zip(unknown_coordinates, predictions):\n",
    "#             filename, crs, (latitude, longitude) = coord\n",
    "#             writer.writerow([filename, latitude, longitude, label])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import csv\n",
    "\n",
    "# # Define output CSV file path\n",
    "# # output_csv_path = 'D:/Yehmh/test_py/202301/P00073_transect_234/10m_10m/species_distribution.csv'\n",
    "\n",
    "\n",
    "# # Write results to CSV file\n",
    "# with open(output_csv_path, 'w', newline='') as csvfile:\n",
    "#     writer = csv.writer(csvfile)\n",
    "#     writer.writerow(['Filename', 'Latitude', 'Longitude', 'Predicted Species'])  # Write header\n",
    "#     for coord, label in zip(unknown_coordinates, predictions):\n",
    "#         filename, crs, (latitude, longitude) = coord\n",
    "#         writer.writerow([filename, latitude, longitude, label])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list = [69, 70, 71, 75, 76, 78, 79, 82]\n",
    "\n",
    "# for i in list:\n",
    "#     unknown_photos_dir = f'D:\\\\Yehmh\\\\test_py\\\\202301\\\\P000{i}\\\\5m_5m'\n",
    "#     output_csv_path = f'D:/Yehmh/test_py/202301/P000{i}_species_distribution.csv'\n",
    "    \n",
    "#     classify_and_write(unknown_photos_dir, output_csv_path)\n",
    "    \n",
    "#     print(i, \" done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### add probabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import cv2\n",
    "import torch\n",
    "import rasterio\n",
    "import numpy as np\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import transforms\n",
    "# from your_model_file import CNN  # Import your CNN model class\n",
    "import csv\n",
    "\n",
    "# Function to extract coordinates from TIF files\n",
    "def extract_coordinates(tif_file):\n",
    "    with rasterio.open(tif_file) as src:\n",
    "        crs = src.crs\n",
    "        bounds = src.bounds\n",
    "        center_x = (bounds.left + bounds.right) / 2\n",
    "        center_y = (bounds.top + bounds.bottom) / 2\n",
    "        return crs, (center_x, center_y)\n",
    "\n",
    "# Define directory containing unknown TIF files\n",
    "# unknown_photos_dir = 'D:\\\\Yehmh\\\\test_py\\\\202301\\\\P00073_transect_234\\\\10m_10m\\\\unknown_cleaned'\n",
    "\n",
    "def classify_and_write(unknown_photos_dir, output_csv_path):\n",
    "\n",
    "    # Initialize lists to store unknown photo paths, coordinates, and predictions\n",
    "    unknown_photos = []\n",
    "    unknown_coordinates = []\n",
    "\n",
    "    # Iterate over unknown TIF files\n",
    "    for filename in os.listdir(unknown_photos_dir):\n",
    "        if filename.endswith('.tif'):\n",
    "            tif_file = os.path.join(unknown_photos_dir, filename)\n",
    "            \n",
    "            # Extract coordinates\n",
    "            crs, coordinates = extract_coordinates(tif_file)\n",
    "            \n",
    "            # Append to the list\n",
    "            unknown_photos.append(tif_file)\n",
    "            unknown_coordinates.append((filename, crs, coordinates))\n",
    "\n",
    "    # Now you have a list of unknown photo paths (unknown_photos) and corresponding coordinates (unknown_coordinates)\n",
    "\n",
    "    # Define a function to classify with threshold\n",
    "    def classify_with_threshold(probabilities, threshold):\n",
    "        max_prob, max_index = torch.max(probabilities, dim=1)\n",
    "        if max_prob.item() < threshold:\n",
    "            return \"unknown\"\n",
    "        else:\n",
    "            predicted_label = label_encoder.classes_[max_index.item()]\n",
    "            return predicted_label  # Return the index of the class with the maximum probability\n",
    "\n",
    "\n",
    "    # Load the trained model\n",
    "    # model = CNN(num_classes=len(label_encoder.classes_))\n",
    "    # model.load_state_dict(torch.load('path/to/your/trained/model.pth'))\n",
    "    model.eval()  # Set the model to evaluation mode\n",
    "\n",
    "    # Define transformations for the images\n",
    "    transform = transforms.Compose([\n",
    "        transforms.ToTensor(),  \n",
    "        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  \n",
    "    ])\n",
    "\n",
    "    # Make predictions on the unknown photos\n",
    "    predictions = []\n",
    "    for photo_path in unknown_photos:\n",
    "        # Load and preprocess the image\n",
    "        image = cv2.imread(photo_path)\n",
    "        image = cv2.resize(image, (64, 64))  # Resize image if necessary\n",
    "        image = transform(image)\n",
    "        image = image.unsqueeze(0)  # Add batch dimension\n",
    "        \n",
    "        # Perform inference\n",
    "        with torch.no_grad():\n",
    "            output = model(image)\n",
    "            probabilities = nn.functional.softmax(output, dim=1)  # Apply softmax to get probabilities\n",
    "            classification = classify_with_threshold(probabilities, threshold=0.7)  # Adjust threshold as needed\n",
    "            predictions.append(classification)\n",
    "\n",
    "    # Now you have the predictions for each unknown photo in the list 'predictions'\n",
    "    # You can proceed to visualize the results on a map using the coordinates\n",
    "    with open(output_csv_path, 'w', newline='') as csvfile:\n",
    "        writer = csv.writer(csvfile)\n",
    "        writer.writerow(['Filename', 'Latitude', 'Longitude', 'Predicted Species'])  # Write header\n",
    "        for coord, label in zip(unknown_coordinates, predictions):\n",
    "            filename, crs, (latitude, longitude) = coord\n",
    "            writer.writerow([filename, latitude, longitude, label])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import csv\n",
    "\n",
    "# # Define output CSV file path\n",
    "# output_csv_path = 'D:/Yehmh/test_py/202301/P00073_transect_234/10m_10m/species_distribution_unclassified_2.csv'\n",
    "\n",
    "# # Write results to CSV file\n",
    "# with open(output_csv_path, 'w', newline='') as csvfile:\n",
    "#     writer = csv.writer(csvfile)\n",
    "#     writer.writerow(['Filename', 'Latitude', 'Longitude', 'Predicted Species'])  # Write header\n",
    "#     for coord, label in zip(unknown_coordinates, predictions):\n",
    "#         filename, crs, (latitude, longitude) = coord\n",
    "#         writer.writerow([filename, latitude, longitude, label])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list = [69, 70, 71, 75, 76, 78, 79, 82]\n",
    "# list = [76, 78, 79, 82]\n",
    "# list = [78]\n",
    "\n",
    "# for i in list:\n",
    "#     unknown_photos_dir = f'D:\\\\Yehmh\\\\test_py\\\\202301\\\\P000{i}\\\\5m_5m'\n",
    "#     output_csv_path = f'D:/Yehmh/test_py/202301/P000{i}_species_distribution_prob_2.csv'\n",
    "    \n",
    "#     classify_and_write(unknown_photos_dir, output_csv_path)\n",
    "    \n",
    "#     print(i, \" done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done 1\n",
      "done 2\n"
     ]
    }
   ],
   "source": [
    "unknown_photos_dir = f'D:\\\\Yehmh\\\\test_py\\\\202301\\\\P00074_transect_1\\\\5m_5m'\n",
    "output_csv_path = f'D:/Yehmh/test_py/202301/P00074_species_distribution_prob.csv'\n",
    "classify_and_write(unknown_photos_dir, output_csv_path)\n",
    "print(\"done 1\")\n",
    "\n",
    "unknown_photos_dir = f'D:\\\\Yehmh\\\\test_py\\\\202301\\\\P00073_transect_234\\\\5m_5m\\\\unknown'\n",
    "output_csv_path = f'D:/Yehmh/test_py/202301/P00073_species_distribution_prob.csv'\n",
    "classify_and_write(unknown_photos_dir, output_csv_path)\n",
    "print(\"done 2\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "test",
   "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.8.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}