HSI_plastic.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3045b980-74e8-4861-88f9-b04e11d9d6fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.model_selection import train_test_split\n",
    "import numpy as np\n",
    "\n",
    "def dim_reduc(hycube,n_components):\n",
    "    new_hycube =np.reshape(hycube,(-1,hycube.shape[2]))\n",
    "    pca = PCA(n_components,whiten=True,random_state=0)\n",
    "    new_hycube = pca.fit_transform(new_hycube)\n",
    "    new_hycube =np.reshape(new_hycube,(hycube.shape[0],hycube.shape[1],n_components))\n",
    "    return new_hycube\n",
    "\n",
    "def patchify(hycube,hycube_y,wsize,padding=True):\n",
    "    pad = int((wsize-1)/2)\n",
    "    N = hycube.shape[0]*hycube.shape[1]\n",
    "    if padding:\n",
    "        hycube = np.pad(hycube,pad_width=((pad,pad),(pad,pad),(0,0)),constant_values=0)\n",
    "    new_hycube = np.zeros((N,wsize,wsize,hycube.shape[2]))\n",
    "    new_hycube_y = np.zeros((N))\n",
    "    id =0\n",
    "    for r in range(pad,hycube.shape[0]-pad):\n",
    "        for c in range(pad,hycube.shape[1]-pad):\n",
    "            new_hycube[id,:,:,:] = hycube[r-pad:r+pad+1,c-pad:c+pad+1]\n",
    "            new_hycube_y[id]=hycube_y[r-pad,c-pad]\n",
    "            id += 1\n",
    "    return new_hycube,new_hycube_y\n",
    "\n",
    "def preprocess(hycube,hycube_y,n_components=4,split=True,wsize=25):\n",
    "    new_hycube = dim_reduc(hycube,n_components)\n",
    "    for i in range(203):\n",
    "        for j in range(117):\n",
    "            if i<100 and j>50 and hycube_y[i,j]==1:\n",
    "                hycube_y[i,j]=2\n",
    "            elif i>100 and j<50 and hycube_y[i,j]==1:\n",
    "                hycube_y[i,j]=3\n",
    "            elif i>100 and j>50 and hycube_y[i,j]==1:\n",
    "                hycube_y[i,j]=4\n",
    "    X,y = patchify(new_hycube,hycube_y,wsize)\n",
    "    if split:\n",
    "        X_train,X_test,y_train,y_test = train_test_split(X,y,train_size=0.80)\n",
    "        X_train =np.reshape(X_train,(-1,X_train.shape[3],X_train.shape[1],X_train.shape[2]))\n",
    "        X_test= np.reshape(X_test,(-1,X_test.shape[3],X_test.shape[1],X_test.shape[2]))\n",
    "        y_train = y_train.astype(int)\n",
    "        y_test = y_test.astype(int)\n",
    "        X_train = X_train.astype(np.float32)\n",
    "        X_test = X_test.astype(np.float32)\n",
    "        X_train = torch.from_numpy(X_train)\n",
    "        y_train = torch.from_numpy(y_train)\n",
    "        X_test = torch.from_numpy(X_test)\n",
    "        y_test = torch.from_numpy(y_test)\n",
    "        return X_train,X_test,y_train,y_test\n",
    "    X = np.reshape(X,(-1,X.shape[3],X.shape[1],X.shape[2]))\n",
    "    X = X.astype(np.float32)\n",
    "    y = y.astype(int)\n",
    "    X = torch.from_numpy(X)\n",
    "    y = torch.from_numpy(y)\n",
    "    return X,y\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7d28c51c-282b-43a4-b3ff-ede121fb478a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "from torchvision.transforms import ToTensor\n",
    "import scipy.io as sio\n",
    "class HsiDataset(Dataset):\n",
    "    def __init__(self,transform=ToTensor(),training=True):\n",
    "        self.transform = transform\n",
    "        self.training = training\n",
    "        data = sio.loadmat('prep_data.mat')\n",
    "        self.hycube = data['prep_sample']\n",
    "        self.hycube_y = data['prep_mask']\n",
    "        self.X_train,self.X_test,self.y_train,self.y_test = preprocess(self.hycube,self.hycube_y)\n",
    "    def __len__(self):\n",
    "        if self.training:\n",
    "            return len(self.y_train)\n",
    "        return len(self.y_test)\n",
    "    def __getitem__(self, index):\n",
    "        if self.training:\n",
    "            X = self.X_train[index]\n",
    "            y = self.y_train[index]\n",
    "        else:\n",
    "            X = self.X_test[index]\n",
    "            y = self.y_test[index]\n",
    "        return X,y\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b6a0fdb7-3ef2-486a-8aaf-41592d72def7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "class HSI_CNN(nn.Module):\n",
    "    def __init__(self,in_channels=4) -> None:\n",
    "        super(HSI_CNN,self).__init__()\n",
    "        self.conv1 = nn.Conv2d(in_channels,in_channels*2,5)\n",
    "        self.conv2 = nn.Conv2d(in_channels*2,in_channels*4,5)\n",
    "        self.conv3 = nn.Conv2d(in_channels*4,in_channels*4,3)\n",
    "        self.pool = nn.MaxPool2d(2,2)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.linear1 = nn.Linear(784,256)\n",
    "        self.linear2 = nn.Linear(256,64)\n",
    "        self.linear3 = nn.Linear(64,16)\n",
    "        self.linear4 = nn.Linear(16,5)\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "    def forward(self,x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.pool(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.linear1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.linear2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.linear3(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.linear4(x)\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5174e529-738d-431e-9b21-72a6c121b400",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HSI_CNN(\n",
       "  (conv1): Conv2d(4, 8, kernel_size=(5, 5), stride=(1, 1))\n",
       "  (conv2): Conv2d(8, 16, kernel_size=(5, 5), stride=(1, 1))\n",
       "  (conv3): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1))\n",
       "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (flatten): Flatten(start_dim=1, end_dim=-1)\n",
       "  (linear1): Linear(in_features=784, out_features=256, bias=True)\n",
       "  (linear2): Linear(in_features=256, out_features=64, bias=True)\n",
       "  (linear3): Linear(in_features=64, out_features=16, bias=True)\n",
       "  (linear4): Linear(in_features=16, out_features=5, bias=True)\n",
       "  (relu): ReLU()\n",
       ")"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = HSI_CNN()\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "948fd512-d5aa-44e3-8f9a-07adfc0e4a60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9549077181208053\n",
      "Epoch: 1\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9641359060402684\n",
      "Epoch: 2\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9714765100671141\n",
      "Epoch: 3\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9760906040268457\n",
      "Epoch: 4\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9697986577181208\n",
      "Epoch: 5\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9821728187919463\n",
      "Epoch: 6\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.979236577181208\n",
      "Epoch: 7\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9783696868275636\n",
      "Epoch: 8\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9807046979865772\n",
      "Epoch: 9\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9825922818791947\n",
      "Epoch: 10\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9811241610738255\n",
      "Epoch: 11\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9844798657718121\n",
      "Epoch: 12\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9815436241610739\n",
      "Epoch: 13\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.989513422818792\n",
      "Epoch: 14\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9828020134228188\n",
      "Epoch: 15\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9886744966442953\n",
      "Epoch: 16\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9851090604026845\n",
      "Epoch: 17\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9861577181208053\n",
      "Epoch: 18\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9838506711409396\n",
      "Epoch: 19\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9886744966442953\n",
      "Epoch: 20\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9861577181208053\n",
      "Epoch: 21\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9831935123309193\n",
      "Epoch: 22\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9865771812080537\n",
      "Epoch: 23\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9884647651006712\n",
      "Epoch: 24\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9876258389261745\n",
      "Epoch: 25\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9842701342281879\n",
      "Epoch: 26\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9911912751677853\n",
      "Epoch: 27\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9823825503355704\n",
      "Epoch: 28\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.988255033557047\n",
      "Epoch: 29\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9903523489932886\n",
      "Epoch: 30\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9916107382550335\n",
      "Epoch: 31\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9911912751677853\n",
      "Epoch: 32\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9920302013422819\n",
      "Epoch: 33\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9905620805369127\n",
      "Epoch: 34\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9905620805369127\n",
      "Epoch: 35\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.988255033557047\n",
      "Epoch: 36\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9828020134228188\n",
      "Epoch: 37\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9916107382550335\n",
      "Epoch: 38\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9939177852348994\n",
      "Epoch: 39\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9916107382550335\n",
      "Epoch: 40\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9941275167785235\n",
      "Epoch: 41\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9914010067114094\n",
      "Epoch: 42\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9941275167785235\n",
      "Epoch: 43\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.993498322147651\n",
      "Epoch: 44\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9905620805369127\n",
      "Epoch: 45\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9916107382550335\n",
      "Epoch: 46\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9882270693778992\n",
      "Epoch: 47\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9903523489932886\n",
      "Epoch: 48\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.9893036912751678\n",
      "Epoch: 49\n",
      "Starting eval\n",
      "Epoch Eval Accuracy: 0.990981543624161\n"
     ]
    }
   ],
   "source": [
    "from torch.utils.data import DataLoader\n",
    "from torch.optim import Adam\n",
    "import torch.nn as nn\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "train_data = HsiDataset()\n",
    "test_data = HsiDataset(training=False)\n",
    "train_dataloader = DataLoader(train_data,batch_size=32,shuffle=True)\n",
    "test_dataloader = DataLoader(test_data,batch_size=32)\n",
    "\n",
    "model = HSI_CNN()\n",
    "optimizer = Adam(model.parameters(),lr=0.001)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "best_acc = 0\n",
    "for epoch in range(50):\n",
    "    model.train()\n",
    "    print(f'Epoch: {epoch}')\n",
    "    # train_loss =0\n",
    "    for i,(X,y) in enumerate(train_dataloader):\n",
    "        logits = model(X)\n",
    "        batch_loss = criterion(logits,y)\n",
    "        optimizer.zero_grad()\n",
    "        batch_loss.backward()\n",
    "        optimizer.step()\n",
    "        # train_loss += batch_loss\n",
    "        # if i%50 ==0:\n",
    "        #     print(f'Train Loss: {batch_loss} batch_id: {i}')\n",
    "    print(\"Starting eval\")\n",
    "    model.eval()\n",
    "    # test_loss =0\n",
    "    epoch_acc = 0\n",
    "    with torch.no_grad():\n",
    "        for i,(X,y) in enumerate(test_dataloader):\n",
    "            logits = model(X)\n",
    "            # print(X.size())\n",
    "            batch_loss = criterion(logits,y)\n",
    "            y_score,y_pred= logits.max(dim=1)\n",
    "            acc = (y==y_pred).sum()/y.size(0)\n",
    "            acc = acc.item()\n",
    "            epoch_acc += acc\n",
    "            # print(f'Batch Accuracy: {acc} batch_id: {i}')\n",
    "        if (epoch_acc/(i+1)) > best_acc:\n",
    "            torch.save(model.state_dict(),'best_model.pth')\n",
    "            best_acc = (epoch_acc/(i+1))\n",
    "        print(f'Epoch Eval Accuracy: {epoch_acc/(i+1)}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ee4aa2c5-2216-43f2-b32f-24b9a1f15ac5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = sio.loadmat('prep_data.mat')\n",
    "hycube = data['prep_sample']\n",
    "hycube_y = data['prep_mask']\n",
    "h = hycube.shape[0]\n",
    "w = hycube.shape[1]\n",
    "# print(h,w)\n",
    "X,y = preprocess(hycube,hycube_y,split=False,wsize=25)\n",
    "# print(X.size(),y.size())\n",
    "pred_img = torch.zeros((h,w))\n",
    "new_model = HSI_CNN()\n",
    "new_model.load_state_dict(torch.load('best_model.pth'))\n",
    "new_model.eval()\n",
    "id =0\n",
    "for i in range(h):\n",
    "    for j in range(w):\n",
    "        patch = X[id,:,:,:]\n",
    "        patch = torch.unsqueeze(patch,0)\n",
    "        # print(patch.size())\n",
    "        logit = new_model(patch)\n",
    "        y_score,y_pred = logit.max(dim=1)\n",
    "        pred_img[i,j] = y_pred\n",
    "        id+=1\n",
    "predicted_img = pred_img.numpy()\n",
    "f,(axs1,axs2) = plt.subplots(1,2,figsize=(15,8))\n",
    "axs1.set_title('Ground Truth')\n",
    "axs2.set_title('Prediction')\n",
    "axs1.imshow(hycube_y)\n",
    "axs2.imshow(predicted_img)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1f102a5-86d9-4472-8f3a-bb8adbc5d9c9",
   "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}