├── Performance.py
├── README.md
├── GC_with_lowmemory.py
└── graph_indian.ipynb


/Performance.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import matplotlib.pyplot as plt
 3 | import torch
 4 | def performance(predict_labels, gt_labels, class_num):
 5 |     matrix = np.zeros((class_num, class_num))
 6 |     predict_labels = torch.max(predict_labels,dim=1)[1]
 7 |     
 8 |     for j in range(len(predict_labels)):
 9 |         o = predict_labels[j]
10 |         q = gt_labels[j]
11 |         if q == 0:
12 |             continue
13 |         matrix[o-1, q-1] += 1
14 | #     plt.imshow(matrix)
15 | #     plt.show()
16 |     OA = np.sum(np.trace(matrix)) / np.sum(matrix)
17 | 
18 |     
19 |     ac_list = np.zeros((class_num))
20 |     for k in range(len(matrix)):
21 |         ac_k = matrix[k, k] / sum(matrix[:, k])
22 |         ac_list[k] = round(ac_k,4)
23 |     
24 |     AA = np.mean(ac_list)
25 | 
26 |     
27 |     mm = 0
28 |     for l in range(matrix.shape[0]):
29 |         mm += np.sum(matrix[l]) * np.sum(matrix[:, l])
30 |     pe = mm / (np.sum(matrix) * np.sum(matrix))
31 |     pa = np.trace(matrix) / np.sum(matrix)
32 |     kappa = (pa - pe) / (1 - pe)
33 |     
34 |     
35 |     return OA, AA, kappa, ac_list
36 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # DMSGer
 2 | Semi-Supervised Multiscale Dynamic Graph Convolution Network for Hyperspectral Image Classification  
 3 | 
 4 | Paper Name: Semi-Supervised Multiscale Dynamic Graph Convolution Network for Hyperspectral Image Classification  
 5 | Paper Link: https://ieeexplore.ieee.org/abstract/document/9927317  
 6 | 
 7 | ![1668232839898](https://user-images.githubusercontent.com/74549002/201459834-b5cea107-8579-4448-885e-6ad9a397f359.jpg)  
 8 | 
 9 | The versions of related packages when we conducted this experiment,
10 | 
11 |   ```pytorch==1.6.0```
12 |   ```python==3.6.0```
13 |   ```CUDA==11.3```
14 |   ```numpy==1.19.5```
15 | 
16 | Of course, you might be able to run this code in lower versions of these packages.
17 | 
18 | 
19 | Note, if your results of slic is as follows,
20 | 
21 | <img src="https://github.com/TangXu-Group/DMSGer/assets/74549002/3b63da0c-1e79-4e4f-91bf-fd06d7bdce48" width="50%">
22 | 
23 | Please update your sklearn version to 0.18.3 （scikit-image==0.18.3, python==3.8）.
24 | The correct result is as follows,
25 | <img src="https://github.com/TangXu-Group/DMSGer/assets/74549002/3f23e829-19bf-4dd4-972b-022fa7321b64" width="50%">
26 | 


--------------------------------------------------------------------------------
/GC_with_lowmemory.py:
--------------------------------------------------------------------------------
 1 | from torch.nn.modules.module import Module
 2 | from torch.nn.parameter import Parameter
 3 | import math
 4 | from torch.nn import init
 5 | class Graph2dConvolution(Module):
 6 |     """
 7 |     Simple GCN layer, similar to https://arxiv.org/abs/1609.02907
 8 |     """
 9 |     def __init__(
10 |         self,
11 |         in_channels,
12 |         out_channels,
13 |         block_num,
14 |         adj_mask = None
15 |     ):
16 |         super(Graph2dConvolution, self).__init__()
17 |         
18 |         self.weight = Parameter(torch.Tensor(in_channels, out_channels, 1, 1))
19 |         self.W = Parameter(torch.Tensor(out_channels, out_channels, 1, 1))
20 |         
21 |         self.reset_parameters()
22 |         
23 |         self.in_features = in_channels
24 |         self.out_features = out_channels
25 |         self.block_num = block_num
26 |         self.adj_mask = adj_mask
27 |         
28 |     def reset_parameters(self):
29 |         init.kaiming_uniform_(self.weight, a=math.sqrt(5))
30 |         init.kaiming_uniform_(self.W, a=math.sqrt(5))
31 |         
32 |     def forward(self, input, index):
33 |         input = (input.permute(0,2,3,1)).matmul(self.weight[:,:,0,0]).permute(0,3,1,2)
34 |         
35 |         index = nn.UpsamplingNearest2d(size = (input.shape[2],input.shape[3]))(index.float()).long()
36 |         block_within_index =  list(set(np.array(seg_index.view(-1))))
37 |         
38 |         batch_size = input.shape[0]
39 |         channels = input.shape[1]
40 | 
41 |         # computing the regional mean of input
42 |         input_means = []
43 |         for i in range(len(block_within_index)):
44 |             block_mask = (index == block_within_index[i]).float()
45 |             sum_block = torch.sum(block_mask,dim = (2,3))
46 |             sum_input = torch.sum(input * block_mask, dim = (2,3))
47 |             mean_input = sum_input/sum_block
48 |             input_means.append(mean_input)
49 |         input_means = torch.stack(input_means).permute(1,0,2)
50 |         
51 |         # computing the adjance metrix
52 |         input_means_ = input_means.repeat(self.block_num, 1, 1, 1).permute(1, 2, 0, 3)
53 |         input_means_ = (input_means_ - input_means.unsqueeze(1)).permute(0, 2, 1, 3)
54 |         M = (self.W[:,:,0,0]).mm(self.W[:,:,0,0].T)
55 |         adj = input_means_.reshape(batch_size, -1, channels).matmul(M)
56 |         adj = torch.sum(adj * input_means_.reshape(batch_size, -1, channels),dim=2).view(batch_size, self.block_num,self.block_num)
57 |         adj = torch.exp(-1 * adj)+ torch.eye(self.block_num).repeat(batch_size, 1, 1).cuda()
58 |         if self.adj_mask is not None:
59 |             adj = adj * self.adj_mask
60 |         
61 |         # generating the adj_mean
62 |         adj_means = input_means.repeat(self.block_num,1,1,1).permute(1,0,2,3) * adj.unsqueeze(3)
63 |         adj_means = (1-torch.eye(self.block_num).reshape(1,self.block_num,self.block_num,1).cuda()) * adj_means
64 |         adj_means = torch.sum(adj_means, dim=2) # batch_size，self.block_num, channel_num
65 |         
66 |         #obtaining the graph update features
67 |         for i in range(len(block_within_index)):
68 |             block_mask = (index == block_within_index[i]).float()
69 |             update_input = input * block_mask + adj_means[:,i].unsqueeze(2).unsqueeze(3)
70 |             input = input * (1-block_mask) + update_input
71 |         return input
72 | 
73 |     def __repr__(self):
74 |         return self.__class__.__name__ + ' (' \
75 |                + str(self.in_features) + ' -> ' \
76 |                + str(self.out_features) + ')'


--------------------------------------------------------------------------------
/graph_indian.ipynb:
--------------------------------------------------------------------------------
   1 | {
   2 |  "cells": [
   3 |   {
   4 |    "cell_type": "code",
   5 |    "execution_count": 59,
   6 |    "metadata": {
   7 |     "ExecuteTime": {
   8 |      "end_time": "2021-02-23T09:23:57.112293Z",
   9 |      "start_time": "2021-02-23T09:23:55.341024Z"
  10 |     }
  11 |    },
  12 |    "outputs": [],
  13 |    "source": [
  14 |     "import scipy.io as scio\n",
  15 |     "import torch\n",
  16 |     "import matplotlib.pyplot as plt\n",
  17 |     "import numpy as np\n",
  18 |     "import torch.nn as nn\n",
  19 |     "import torch.optim.lr_scheduler as lr_scheduler\n",
  20 |     "from tqdm.notebook import tqdm\n",
  21 |     "import os\n",
  22 |     "import random\n",
  23 |     "from skimage.segmentation import slic,felzenszwalb\n",
  24 |     "from IPython import display\n",
  25 |     "from libtiff import TIFF\n",
  26 |     "from Performance import performance\n",
  27 |     "import torch\n",
  28 |     "\n",
  29 |     "os.environ['CUDA_VISIBLE_DEVICES'] = '0'"
  30 |    ]
  31 |   },
  32 |   {
  33 |    "cell_type": "code",
  34 |    "execution_count": 60,
  35 |    "metadata": {
  36 |     "ExecuteTime": {
  37 |      "end_time": "2021-02-23T09:23:57.119270Z",
  38 |      "start_time": "2021-02-23T09:23:57.114283Z"
  39 |     }
  40 |    },
  41 |    "outputs": [],
  42 |    "source": [
  43 |     "def data_norm(data):\n",
  44 |     "    mean = torch.mean(data)\n",
  45 |     "    std = torch.std(data)\n",
  46 |     "    data = (data - mean)/std\n",
  47 |     "    return data\n",
  48 |     "\n",
  49 |     "def calculate_topk_accuracy(y_pred, y, k = 5):\n",
  50 |     "    with torch.no_grad():\n",
  51 |     "        batch_size = y.shape[0]\n",
  52 |     "        _, top_pred = y_pred.topk(k, 1)\n",
  53 |     "        top_pred = top_pred.t()\n",
  54 |     "        correct = top_pred.eq(y.reshape(1, -1).expand_as(top_pred))\n",
  55 |     "        correct_1 = correct[:1].reshape(-1).float().sum(0, keepdim = True)\n",
  56 |     "        correct_k = correct[:k].reshape(-1).float().sum(0, keepdim = True)\n",
  57 |     "        acc_1 = correct_1 / batch_size\n",
  58 |     "        acc_k = correct_k / batch_size\n",
  59 |     "    return acc_1, acc_k"
  60 |    ]
  61 |   },
  62 |   {
  63 |    "cell_type": "markdown",
  64 |    "metadata": {},
  65 |    "source": [
  66 |     "### Get normlized data and ground truth "
  67 |    ]
  68 |   },
  69 |   {
  70 |    "cell_type": "code",
  71 |    "execution_count": 61,
  72 |    "metadata": {
  73 |     "ExecuteTime": {
  74 |      "end_time": "2021-02-23T09:23:57.365611Z",
  75 |      "start_time": "2021-02-23T09:23:57.120267Z"
  76 |     },
  77 |     "scrolled": true
  78 |    },
  79 |    "outputs": [
  80 |     {
  81 |      "name": "stdout",
  82 |      "output_type": "stream",
  83 |      "text": [
  84 |       "The number of classes is: 16\n"
  85 |      ]
  86 |     },
  87 |     {
  88 |      "data": {
  89 |       "image/png": "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\n",
  90 |       "text/plain": [
  91 |        "<Figure size 432x288 with 1 Axes>"
  92 |       ]
  93 |      },
  94 |      "metadata": {
  95 |       "needs_background": "light"
  96 |      },
  97 |      "output_type": "display_data"
  98 |     }
  99 |    ],
 100 |    "source": [
 101 |     "path = '../Data/Indian_Pines/Indian_pines_corrected.mat'\n",
 102 |     "data = scio.loadmat(path)\n",
 103 |     "data = data['indian_pines_corrected']\n",
 104 |     "data_ = torch.FloatTensor(data.astype(float))\n",
 105 |     "data = data_norm(data_)\n",
 106 |     "\n",
 107 |     "path = '../Data/Indian_Pines/Indian_pines_gt.mat'\n",
 108 |     "ground_turth = scio.loadmat(path)\n",
 109 |     "ground_turth = ground_turth['indian_pines_gt']\n",
 110 |     "ground_turth = torch.FloatTensor(ground_turth.astype(int))\n",
 111 |     "\n",
 112 |     "data_width = data.shape[0]\n",
 113 |     "data_height = data.shape[1]\n",
 114 |     "channel_num = data.shape[2]\n",
 115 |     "\n",
 116 |     "plt.imshow(ground_turth)\n",
 117 |     "class_num = len(set(np.array(ground_turth.reshape(-1))))-1\n",
 118 |     "print('The number of classes is:', class_num)"
 119 |    ]
 120 |   },
 121 |   {
 122 |    "cell_type": "code",
 123 |    "execution_count": 62,
 124 |    "metadata": {},
 125 |    "outputs": [
 126 |     {
 127 |      "data": {
 128 |       "text/plain": [
 129 |        "[7, 214, 124, 36, 72, 110, 4, 72, 3, 146, 368, 89, 31, 190, 58, 14]"
 130 |       ]
 131 |      },
 132 |      "execution_count": 62,
 133 |      "metadata": {},
 134 |      "output_type": "execute_result"
 135 |     }
 136 |    ],
 137 |    "source": [
 138 |     "from collections import Counter\n",
 139 |     "\n",
 140 |     "Number_class = Counter(list(np.array(ground_turth.reshape(-1))))\n",
 141 |     "count = np.zeros(class_num+1)\n",
 142 |     "count[np.array(list(Number_class.keys())).astype(int)] = list(Number_class.values())\n",
 143 |     "count = count[1:]\n",
 144 |     "\n",
 145 |     "# train_count = np.zeros(class_num)\n",
 146 |     "# train_count[np.where(count>30)] = 30\n",
 147 |     "# # train_count[np.where(count<=50)] = 30\n",
 148 |     "# train_count[np.where(count<=30)] = 15\n",
 149 |     "\n",
 150 |     "# train_count[np.where(count>150)] = 30\n",
 151 |     "# train_count[np.where(count<=50)] = 30\n",
 152 |     "# train_count[np.where(count<=30)] = 15\n",
 153 |     "\n",
 154 |     "# train_count = list(train_count.astype(int))\n",
 155 |     "train_count = list(np.around(count*0.15).astype(int))\n",
 156 |     "train_count"
 157 |    ]
 158 |   },
 159 |   {
 160 |    "cell_type": "code",
 161 |    "execution_count": 63,
 162 |    "metadata": {},
 163 |    "outputs": [],
 164 |    "source": [
 165 |     "# size = (35,35)\n",
 166 |     "\n",
 167 |     "# data = nn.UpsamplingNearest2d(size=size)(data.permute(2,0,1).unsqueeze(0))[0].permute(1,2,0)\n",
 168 |     "# ground_turth = nn.UpsamplingNearest2d(size=size)(ground_turth.unsqueeze(0).unsqueeze(0))[0,0]\n",
 169 |     "# data_ = nn.UpsamplingNearest2d(size=size)(data_.permute(2,0,1).unsqueeze(0))[0].permute(1,2,0)\n",
 170 |     "\n",
 171 |     "# data_width = data.shape[0]\n",
 172 |     "# data_height = data.shape[1]\n",
 173 |     "# channel_num = data.shape[2]\n",
 174 |     "\n",
 175 |     "# plt.imshow(ground_turth)\n",
 176 |     "# class_num = len(set(np.array(ground_turth.reshape(-1))))-1\n",
 177 |     "# print('The number of classes is:', class_num)"
 178 |    ]
 179 |   },
 180 |   {
 181 |    "cell_type": "markdown",
 182 |    "metadata": {},
 183 |    "source": [
 184 |     "### Type (混用): Getting train and test mask"
 185 |    ]
 186 |   },
 187 |   {
 188 |    "cell_type": "code",
 189 |    "execution_count": 64,
 190 |    "metadata": {
 191 |     "ExecuteTime": {
 192 |      "end_time": "2021-02-23T09:23:57.628907Z",
 193 |      "start_time": "2021-02-23T09:23:57.366609Z"
 194 |     }
 195 |    },
 196 |    "outputs": [
 197 |     {
 198 |      "name": "stdout",
 199 |      "output_type": "stream",
 200 |      "text": [
 201 |       "The match between train_count and train_class:  True\n"
 202 |      ]
 203 |     },
 204 |     {
 205 |      "data": {
 206 |       "image/png": "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\n",
 207 |       "text/plain": [
 208 |        "<Figure size 432x288 with 1 Axes>"
 209 |       ]
 210 |      },
 211 |      "metadata": {
 212 |       "needs_background": "light"
 213 |      },
 214 |      "output_type": "display_data"
 215 |     },
 216 |     {
 217 |      "data": {
 218 |       "image/png": "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\n",
 219 |       "text/plain": [
 220 |        "<Figure size 432x288 with 1 Axes>"
 221 |       ]
 222 |      },
 223 |      "metadata": {
 224 |       "needs_background": "light"
 225 |      },
 226 |      "output_type": "display_data"
 227 |     }
 228 |    ],
 229 |    "source": [
 230 |     "# Get class's position index\n",
 231 |     "classes_index = []\n",
 232 |     "for i in range(class_num+1): #with the background\n",
 233 |     "    class_index = np.argwhere(np.array(ground_turth) == i)\n",
 234 |     "    np.random.shuffle(class_index)\n",
 235 |     "    classes_index.append(class_index)\n",
 236 |     "\n",
 237 |     "# Get train and test index for each class\n",
 238 |     "# train_count = [30,30,30,30,30,30,15,30,15,30,30,30,30,30,30,30]\n",
 239 |     "\n",
 240 |     "test_count = []\n",
 241 |     "print('The match between train_count and train_class: ', len(train_count) == class_num)\n",
 242 |     "\n",
 243 |     "train_index = []\n",
 244 |     "test_index = []\n",
 245 |     "for i in range(class_num):\n",
 246 |     "    train_index.append(classes_index[i+1][:train_count[i]])\n",
 247 |     "    test_index.append(classes_index[i+1][-(len(classes_index[i+1])-train_count[i]):])\n",
 248 |     "    test_count.append(len(classes_index[i+1])-train_count[i])\n",
 249 |     "# Get train and test mask\n",
 250 |     "train_mask = torch.zeros(data.shape[:2])\n",
 251 |     "test_mask = torch.zeros(data.shape[:2])\n",
 252 |     "for i in range(class_num):\n",
 253 |     "    train_mask[train_index[i][:,0],train_index[i][:,1]] = 1\n",
 254 |     "    test_mask[test_index[i][:,0],test_index[i][:,1]] = 1\n",
 255 |     "plt.imshow(train_mask * ground_turth)\n",
 256 |     "plt.show()\n",
 257 |     "plt.imshow(test_mask * ground_turth)\n",
 258 |     "plt.show()"
 259 |    ]
 260 |   },
 261 |   {
 262 |    "cell_type": "code",
 263 |    "execution_count": 65,
 264 |    "metadata": {
 265 |     "ExecuteTime": {
 266 |      "end_time": "2021-02-23T09:23:57.632896Z",
 267 |      "start_time": "2021-02-23T09:23:57.629905Z"
 268 |     }
 269 |    },
 270 |    "outputs": [
 271 |     {
 272 |      "name": "stdout",
 273 |      "output_type": "stream",
 274 |      "text": [
 275 |       "Train count: [7, 214, 124, 36, 72, 110, 4, 72, 3, 146, 368, 89, 31, 190, 58, 14]\n",
 276 |       "Test count: [39, 1214, 706, 201, 411, 620, 24, 406, 17, 826, 2087, 504, 174, 1075, 328, 79]\n"
 277 |      ]
 278 |     }
 279 |    ],
 280 |    "source": [
 281 |     "print('Train count:',train_count)\n",
 282 |     "print('Test count:',test_count)"
 283 |    ]
 284 |   },
 285 |   {
 286 |    "cell_type": "markdown",
 287 |    "metadata": {},
 288 |    "source": [
 289 |     "### Get SLIC segmentation"
 290 |    ]
 291 |   },
 292 |   {
 293 |    "cell_type": "code",
 294 |    "execution_count": 66,
 295 |    "metadata": {
 296 |     "ExecuteTime": {
 297 |      "end_time": "2021-02-23T09:23:57.891206Z",
 298 |      "start_time": "2021-02-23T09:23:57.633894Z"
 299 |     },
 300 |     "scrolled": false
 301 |    },
 302 |    "outputs": [
 303 |     {
 304 |      "name": "stdout",
 305 |      "output_type": "stream",
 306 |      "text": [
 307 |       "Block_num: 18\n"
 308 |      ]
 309 |     },
 310 |     {
 311 |      "name": "stderr",
 312 |      "output_type": "stream",
 313 |      "text": [
 314 |       "/home/amax/anaconda3/envs/pytorch/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: skimage.measure.label's indexing starts from 0. In future version it will start from 1. To disable this warning, explicitely set the `start_label` parameter to 1.\n",
 315 |       "  \"\"\"Entry point for launching an IPython kernel.\n"
 316 |      ]
 317 |     },
 318 |     {
 319 |      "data": {
 320 |       "text/plain": [
 321 |        "<matplotlib.image.AxesImage at 0x7f8c442c3828>"
 322 |       ]
 323 |      },
 324 |      "execution_count": 66,
 325 |      "metadata": {},
 326 |      "output_type": "execute_result"
 327 |     },
 328 |     {
 329 |      "data": {
 330 |       "image/png": "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\n",
 331 |       "text/plain": [
 332 |        "<Figure size 432x288 with 1 Axes>"
 333 |       ]
 334 |      },
 335 |      "metadata": {
 336 |       "needs_background": "light"
 337 |      },
 338 |      "output_type": "display_data"
 339 |     }
 340 |    ],
 341 |    "source": [
 342 |     "seg_index = (slic(np.array(data_), n_segments=50, max_iter=2))\n",
 343 |     "# seg_index = felzenszwalb(np.array(data), scale=100, sigma=0.5, min_size=100)\n",
 344 |     "# seg_index = torch.arange(data_width*data_height).reshape(data_width, data_height).numpy()\n",
 345 |     "\n",
 346 |     "seg_index = torch.Tensor(seg_index.copy())\n",
 347 |     "# seg_index = ground_turth\n",
 348 |     "Block_num = len(set(np.array(seg_index.reshape(-1))))\n",
 349 |     "print('Block_num:', Block_num)\n",
 350 |     "plt.imshow(seg_index)"
 351 |    ]
 352 |   },
 353 |   {
 354 |    "cell_type": "markdown",
 355 |    "metadata": {},
 356 |    "source": [
 357 |     "### Adj_mask computation"
 358 |    ]
 359 |   },
 360 |   {
 361 |    "cell_type": "code",
 362 |    "execution_count": 67,
 363 |    "metadata": {},
 364 |    "outputs": [],
 365 |    "source": [
 366 |     "#Fully connection\n",
 367 |     "adj_mask = torch.ones(Block_num,Block_num).int().cuda()"
 368 |    ]
 369 |   },
 370 |   {
 371 |    "cell_type": "code",
 372 |    "execution_count": 68,
 373 |    "metadata": {
 374 |     "ExecuteTime": {
 375 |      "end_time": "2021-02-23T09:24:00.375564Z",
 376 |      "start_time": "2021-02-23T09:23:57.892203Z"
 377 |     },
 378 |     "scrolled": true
 379 |    },
 380 |    "outputs": [],
 381 |    "source": [
 382 |     "#K-neighbour\n",
 383 |     "# adj_mask = torch.zeros(Block_num,Block_num).int()\n",
 384 |     "# for row in tqdm(range(seg_index.shape[0])):\n",
 385 |     "#     for low in range(seg_index.shape[1]):\n",
 386 |     "#         block_ids = list(set(np.array(seg_index[row-1:row+2, low-1:low+2].reshape(-1)).astype(int)))\n",
 387 |     "#         adj_mask[seg_index[row,low].long(),block_ids] = int(1)\n",
 388 |     "# plt.imshow(adj_mask)\n",
 389 |     "# adj_mask = adj_mask.cuda()"
 390 |    ]
 391 |   },
 392 |   {
 393 |    "cell_type": "markdown",
 394 |    "metadata": {},
 395 |    "source": [
 396 |     "# Train"
 397 |    ]
 398 |   },
 399 |   {
 400 |    "cell_type": "code",
 401 |    "execution_count": 69,
 402 |    "metadata": {
 403 |     "ExecuteTime": {
 404 |      "end_time": "2021-02-23T09:24:02.545762Z",
 405 |      "start_time": "2021-02-23T09:24:01.154481Z"
 406 |     }
 407 |    },
 408 |    "outputs": [],
 409 |    "source": [
 410 |     "# Net = SegNet(in_channel = channel_num, block_num = Block_num,class_num=class_num+1, adj_mask = adj_mask).cuda()\n",
 411 |     "# root = 'work_dir_Indian/'\n",
 412 |     "# Net.load_state_dict(torch.load(root+'best_kappa.pth'))\n",
 413 |     "# hsimg = data.permute(2,0,1).unsqueeze(0).cuda()\n",
 414 |     "# classes = Net(hsimg,seg_index.unsqueeze(0).unsqueeze(0)).cpu().detach()\n",
 415 |     "# plt.figure(dpi = 300)\n",
 416 |     "# plt.imsave(root+'indian.png',torch.max(torch.softmax(classes[0], dim =0),dim = 0)[1].cpu()*(ground_turth>0).float())"
 417 |    ]
 418 |   },
 419 |   {
 420 |    "cell_type": "code",
 421 |    "execution_count": 70,
 422 |    "metadata": {
 423 |     "ExecuteTime": {
 424 |      "end_time": "2021-01-24T15:49:08.380799Z",
 425 |      "start_time": "2021-01-24T15:49:08.377807Z"
 426 |     }
 427 |    },
 428 |    "outputs": [],
 429 |    "source": [
 430 |     "# train_mask = torch.Tensor(np.load('work_dir_Indian/train_mask.npy'))\n",
 431 |     "# test_mask = torch.Tensor(np.load('work_dir_Indian/test_mask.npy'))"
 432 |    ]
 433 |   },
 434 |   {
 435 |    "cell_type": "code",
 436 |    "execution_count": 71,
 437 |    "metadata": {},
 438 |    "outputs": [],
 439 |    "source": [
 440 |     "# from Model import SegNet"
 441 |    ]
 442 |   },
 443 |   {
 444 |    "cell_type": "code",
 445 |    "execution_count": 72,
 446 |    "metadata": {},
 447 |    "outputs": [],
 448 |    "source": [
 449 |     "from torch.nn.modules.module import Module\n",
 450 |     "from torch.nn.parameter import Parameter\n",
 451 |     "import math\n",
 452 |     "import torch.nn as nn\n",
 453 |     "import torch\n",
 454 |     "from torch.nn import init\n",
 455 |     "class Graph2dConvolution(Module):\n",
 456 |     "    \"\"\"\n",
 457 |     "    Simple GCN layer, similar to https://arxiv.org/abs/1609.02907\n",
 458 |     "    \"\"\"\n",
 459 |     "    def __init__(\n",
 460 |     "        self,\n",
 461 |     "        in_channels,\n",
 462 |     "        out_channels,\n",
 463 |     "        block_num,\n",
 464 |     "        adj_mask = None,\n",
 465 |     "        if_feature_update = True,\n",
 466 |     "        for_classification = False\n",
 467 |     "    ):\n",
 468 |     "        super(Graph2dConvolution, self).__init__()\n",
 469 |     "        \n",
 470 |     "        self.weight = Parameter(torch.randn(in_channels, out_channels))\n",
 471 |     "        self.W = Parameter(torch.randn(out_channels, out_channels))\n",
 472 |     "        self.bn = nn.BatchNorm2d(out_channels)\n",
 473 |     "        \n",
 474 |     "        self.reset_parameters()\n",
 475 |     "        \n",
 476 |     "        self.in_features = in_channels\n",
 477 |     "        self.out_features = out_channels\n",
 478 |     "        self.block_num = block_num\n",
 479 |     "        self.adj_mask = adj_mask\n",
 480 |     "        self.if_feature_update = if_feature_update\n",
 481 |     "        self.for_classification = for_classification\n",
 482 |     "        \n",
 483 |     "    def reset_parameters(self):\n",
 484 |     "        init.kaiming_uniform_(self.weight, a=math.sqrt(5))\n",
 485 |     "        init.kaiming_uniform_(self.W, a=math.sqrt(5))\n",
 486 |     "\n",
 487 |     "    def forward(self, input, index):\n",
 488 |     "        input = (input.permute(0,2,3,1)).matmul(self.weight).permute(0,3,1,2)\n",
 489 |     "        \n",
 490 |     "        if self.if_feature_update:\n",
 491 |     "            index = nn.UpsamplingNearest2d(size = (input.shape[2],input.shape[3]))(index.float()).long()\n",
 492 |     "            batch_size = input.shape[0]\n",
 493 |     "            channels = input.shape[1]\n",
 494 |     "\n",
 495 |     "            # get one-hot label\n",
 496 |     "            index_ex = torch.zeros(batch_size,self.block_num,input.shape[2],input.shape[3]).cuda()\n",
 497 |     "            index_ex = index_ex.scatter_(1, index, 1)\n",
 498 |     "            block_value_sum = torch.sum(index_ex,dim = (2,3))\n",
 499 |     "\n",
 500 |     "            # computing the regional mean of input\n",
 501 |     "            input_ = input.repeat(self.block_num,1,1,1,1).permute(1,0,2,3,4)\n",
 502 |     "            index_ex = index_ex.unsqueeze(2)\n",
 503 |     "            input_means = torch.sum(index_ex * input_,dim = (3,4))/(block_value_sum+(block_value_sum==0).float()).unsqueeze(2) #* mask.unsqueeze(2)\n",
 504 |     "\n",
 505 |     "            # computing the adjance metrix\n",
 506 |     "            input_means_ = input_means.repeat(self.block_num, 1, 1, 1).permute(1, 2, 0, 3)\n",
 507 |     "            input_means_ = (input_means_ - input_means.unsqueeze(1)).permute(0, 2, 1, 3)\n",
 508 |     "            M = (self.W).mm(self.W.T)\n",
 509 |     "            adj = input_means_.reshape(batch_size, -1, channels).matmul(M)\n",
 510 |     "            adj = torch.sum(adj * input_means_.reshape(batch_size, -1, channels),dim=2).view(batch_size, self.block_num,self.block_num)\n",
 511 |     "            adj = torch.exp(-1 * adj)+ torch.eye(self.block_num).repeat(batch_size, 1, 1).cuda()\n",
 512 |     "            if self.adj_mask is not None:\n",
 513 |     "                adj = adj * self.adj_mask\n",
 514 |     "\n",
 515 |     "            # generating the adj_mean\n",
 516 |     "            adj_means = input_means.repeat(self.block_num,1,1,1).permute(1,0,2,3) * adj.unsqueeze(3)\n",
 517 |     "            adj_means = (1-torch.eye(self.block_num).reshape(1,self.block_num,self.block_num,1).cuda()) * adj_means\n",
 518 |     "            adj_means = torch.sum(adj_means, dim=2) # batch_size，self.block_num, channel_num\n",
 519 |     "\n",
 520 |     "            #obtaining the graph update features\n",
 521 |     "            features = torch.sum(index_ex * (input_ + adj_means.unsqueeze(3).unsqueeze(4)),dim=1)\n",
 522 |     "#             features = data_norm(features)\n",
 523 |     "            features = self.bn(features) \n",
 524 |     "\n",
 525 |     "#             if self.for_classification==False:\n",
 526 |     "#                 features = self.bn(features) #for normlizing data\n",
 527 |     "        else:\n",
 528 |     "            features = input\n",
 529 |     "            features = self.bn(features)\n",
 530 |     "        return features\n",
 531 |     "\n",
 532 |     "    def __repr__(self):\n",
 533 |     "        return self.__class__.__name__ + ' (' \\\n",
 534 |     "               + str(self.in_features) + ' -> ' \\\n",
 535 |     "               + str(self.out_features) + ')'\n",
 536 |     "               \n",
 537 |     "class SegNet(nn.Module):\n",
 538 |     "    def __init__(self, in_channel, block_num, class_num, adj_mask = None, if_feature_update=True, scale_layer=4):\n",
 539 |     "        super(SegNet, self).__init__()\n",
 540 |     "        print('2D Graph convolution network are contructing~~~')\n",
 541 |     "\n",
 542 |     "        self.maxpool = nn.MaxPool2d(kernel_size = 3, stride=2, padding=1)\n",
 543 |     "        \n",
 544 |     "        self.gcn1 = Graph2dConvolution(in_channel,in_channel,block_num = block_num, adj_mask = adj_mask, if_feature_update=if_feature_update)\n",
 545 |     "\n",
 546 |     "        self.gcn2 = Graph2dConvolution(in_channel,in_channel,block_num = block_num, adj_mask = adj_mask, if_feature_update=if_feature_update)\n",
 547 |     "\n",
 548 |     "        self.gcn3 = Graph2dConvolution(in_channel,in_channel,block_num = block_num, adj_mask = adj_mask, if_feature_update=if_feature_update)\n",
 549 |     "\n",
 550 |     "        self.gcn4 = Graph2dConvolution(in_channel,in_channel,block_num = block_num, adj_mask = adj_mask, if_feature_update=if_feature_update)\n",
 551 |     "\n",
 552 |     "        self.gcn = Graph2dConvolution(int(in_channel*scale_layer),class_num,block_num = block_num, adj_mask = adj_mask, if_feature_update=if_feature_update,for_classification = True)\n",
 553 |     "        \n",
 554 |     "        self.block_num = block_num\n",
 555 |     "        self.Softmax = nn.Softmax(dim = 1)\n",
 556 |     "        self.scale_layer = scale_layer\n",
 557 |     "    def forward(self,hsimg,seg_index):\n",
 558 |     "        Up = nn.UpsamplingBilinear2d(size = (hsimg.shape[2],hsimg.shape[3]))\n",
 559 |     "\n",
 560 |     "        index = seg_index.long().cuda()\n",
 561 |     "        \n",
 562 |     "        if self.scale_layer >= 1:\n",
 563 |     "            f1 = self.gcn1(hsimg,index)\n",
 564 |     "            f1_ = self.maxpool(f1)\n",
 565 |     "            f1 = Up(f1_)\n",
 566 |     "            \n",
 567 |     "        if self.scale_layer >= 2:\n",
 568 |     "            f2 = self.gcn2(f1_,index)\n",
 569 |     "            f2_ = self.maxpool(f2)\n",
 570 |     "            f2 = Up(f2_)\n",
 571 |     "            \n",
 572 |     "        if self.scale_layer >= 3:\n",
 573 |     "            f3 = self.gcn3(f2_,index)\n",
 574 |     "            f3_ = self.maxpool(f3)\n",
 575 |     "            f3 = Up(f3_)\n",
 576 |     "            \n",
 577 |     "        if self.scale_layer >= 4:\n",
 578 |     "            f4 = self.gcn4(f3_,index)\n",
 579 |     "            f4_ = self.maxpool(f4)\n",
 580 |     "            f4 = Up(f4_)\n",
 581 |     "            \n",
 582 |     "        if self.scale_layer==1:\n",
 583 |     "            final_class = self.gcn(f1,index)\n",
 584 |     "        if self.scale_layer==2:\n",
 585 |     "            final_class = self.gcn(torch.cat((f1,f2),dim=1),index)\n",
 586 |     "        if self.scale_layer==3:\n",
 587 |     "            final_class = self.gcn(torch.cat((f1,f2,f3),dim=1),index)\n",
 588 |     "        if self.scale_layer==4:\n",
 589 |     "            final_class = self.gcn(torch.cat((f1,f2,f3,f4),dim=1),index)\n",
 590 |     "        return final_class"
 591 |    ]
 592 |   },
 593 |   {
 594 |    "cell_type": "code",
 595 |    "execution_count": 73,
 596 |    "metadata": {},
 597 |    "outputs": [],
 598 |    "source": [
 599 |     "def train_and_test():\n",
 600 |     "    Net = SegNet(in_channel = channel_num, \n",
 601 |     "                         block_num = Block_num,\n",
 602 |     "                         class_num=class_num+1, \n",
 603 |     "                         adj_mask = adj_mask,\n",
 604 |     "                         if_feature_update = if_up,\n",
 605 |     "                         scale_layer = scale).cuda()\n",
 606 |     "    # Net.load_state_dict(torch.load('best.pth'))\n",
 607 |     "\n",
 608 |     "    #Loss\n",
 609 |     "    lossf = nn.CrossEntropyLoss()\n",
 610 |     "\n",
 611 |     "    EPOCHS = 2500\n",
 612 |     "    FOUND_LR = 1e-3\n",
 613 |     "    opt = torch.optim.Adam(Net.parameters(), lr = FOUND_LR)\n",
 614 |     "\n",
 615 |     "    scheduler = lr_scheduler.StepLR(opt, step_size=500, gamma=0.6)\n",
 616 |     "\n",
 617 |     "\n",
 618 |     "    best_kappa = 0\n",
 619 |     "    losses = []\n",
 620 |     "\n",
 621 |     "    hsimg = data.permute(2,0,1).unsqueeze(0).cuda()\n",
 622 |     "    for epoch in tqdm(range(EPOCHS)):\n",
 623 |     "#         Net.train()\n",
 624 |     "        classes = Net(hsimg,seg_index.unsqueeze(0).unsqueeze(0))\n",
 625 |     "        train_gt = ground_turth * train_mask\n",
 626 |     "        pre_gt = torch.cat((train_gt.unsqueeze(0).cuda(),classes[0]),dim=0).view(class_num+2,-1).permute(1,0)\n",
 627 |     "        pre_gt_ = pre_gt[torch.argsort(pre_gt[:,0],descending=True)]\n",
 628 |     "        pre_gt_ = pre_gt_[:int(train_sum)]\n",
 629 |     "        loss = lossf(pre_gt_[:,1:],pre_gt_[:,0].long())\n",
 630 |     "        losses.append(float(loss))\n",
 631 |     "\n",
 632 |     "        opt.zero_grad()\n",
 633 |     "        loss.backward()\n",
 634 |     "        opt.step()\n",
 635 |     "        scheduler.step()\n",
 636 |     "        if (epoch+1) % 5 == 0: \n",
 637 |     "#             Net.eval()\n",
 638 |     "            classes = Net(hsimg,seg_index.unsqueeze(0).unsqueeze(0)).cpu().detach()\n",
 639 |     "            test_gt = ground_turth * test_mask\n",
 640 |     "            pre_gt = torch.cat((test_gt.unsqueeze(0),classes[0]),dim=0).view(class_num+2,-1).permute(1,0)\n",
 641 |     "            pre_gt_ = pre_gt[torch.argsort(pre_gt[:,0],descending=True)]\n",
 642 |     "            pre_gt_ = pre_gt_[:int(test_sum)]\n",
 643 |     "\n",
 644 |     "            OA, AA, kappa, ac_list = performance(pre_gt_[:,1:],pre_gt_[:,0].long(),class_num)\n",
 645 |     "\n",
 646 |     "            if best_kappa<kappa:\n",
 647 |     "                best_kappa = kappa\n",
 648 |     "                best_OA = OA\n",
 649 |     "                best_AA = AA\n",
 650 |     "                best_list = ac_list\n",
 651 |     "\n",
 652 |     "                torch.save(Net.state_dict(), 'work_dir_Indian/best_kappa.pth')\n",
 653 |     "                plt.imshow(torch.max(torch.softmax(classes[0], dim =0),dim = 0)[1].cpu()*(ground_turth>0).float())\n",
 654 |     "                display.clear_output(wait=True)\n",
 655 |     "                plt.show()\n",
 656 |     "                print('epoch',epoch,':','OA:',OA,'AA:',AA,'KAPPA:',kappa)\n",
 657 |     "                print('epoch',epoch,':','Accuracy_list:',ac_list)\n",
 658 |     "\n",
 659 |     "        if (epoch+1) % 100 == 0:          \n",
 660 |     "            losses = []\n",
 661 |     "            \n",
 662 |     "    return best_kappa, best_OA, best_AA, best_list"
 663 |    ]
 664 |   },
 665 |   {
 666 |    "cell_type": "code",
 667 |    "execution_count": null,
 668 |    "metadata": {
 669 |     "ExecuteTime": {
 670 |      "end_time": "2021-01-24T16:07:44.386695Z",
 671 |      "start_time": "2021-01-24T15:49:08.381797Z"
 672 |     }
 673 |    },
 674 |    "outputs": [],
 675 |    "source": [
 676 |     "train_sum = torch.sum(train_mask)\n",
 677 |     "test_sum = torch.sum(test_mask)\n",
 678 |     "\n",
 679 |     "best_kappas = []\n",
 680 |     "best_OAs = []\n",
 681 |     "best_AAs = []\n",
 682 |     "best_lists = []\n",
 683 |     "\n",
 684 |     "list_best_OAs_mean = []\n",
 685 |     "list_best_AAs_mean = []\n",
 686 |     "list_best_kappas_mean = []\n",
 687 |     "\n",
 688 |     "list_best_OAs_std = []\n",
 689 |     "list_best_AAs_std = []\n",
 690 |     "list_best_kappas_std = []\n",
 691 |     "\n",
 692 |     "# scale_list = [4,3,2,1]\n",
 693 |     "# feature_up_list = [True, False]\n",
 694 |     "\n",
 695 |     "scale_list = [4]\n",
 696 |     "feature_up_list = [True]\n",
 697 |     "\n",
 698 |     "for scale in scale_list:\n",
 699 |     "    for if_up in feature_up_list:\n",
 700 |     "        for i in range(10):\n",
 701 |     "            #Model\n",
 702 |     "            best_kappa, best_OA, best_AA, best_list = train_and_test()\n",
 703 |     "            best_kappas.append(best_kappa)\n",
 704 |     "            best_OAs.append(best_OA)\n",
 705 |     "            best_AAs.append(best_AA)\n",
 706 |     "            best_lists.append(best_list)\n",
 707 |     "\n",
 708 |     "\n",
 709 |     "        list_best_OAs_mean.append(np.mean(best_OAs))\n",
 710 |     "        list_best_AAs_mean.append(np.mean(best_AAs))\n",
 711 |     "        list_best_kappas_mean.append(np.mean(best_kappas))\n",
 712 |     "\n",
 713 |     "        list_best_OAs_std.append(np.std(best_OAs))\n",
 714 |     "        list_best_AAs_std.append(np.std(best_AAs))\n",
 715 |     "        list_best_kappas_std.append(np.std(best_kappas))\n",
 716 |     "\n",
 717 |     "        # print('OA:',np.mean(best_OAs),'+-',np.std(best_OAs))\n",
 718 |     "        # print('AA:',np.mean(best_AAs),'+-',np.std(best_AAs))\n",
 719 |     "        # print('kappa:',np.mean(best_kappas),'+-',np.std(best_kappas))\n",
 720 |     "        # print('list:',np.mean(np.array(best_lists),axis=0),'+-',np.std(np.array(best_lists),axis=0))"
 721 |    ]
 722 |   },
 723 |   {
 724 |    "cell_type": "code",
 725 |    "execution_count": 76,
 726 |    "metadata": {},
 727 |    "outputs": [
 728 |     {
 729 |      "name": "stdout",
 730 |      "output_type": "stream",
 731 |      "text": [
 732 |       "OA: 0.9943290092985879 +- 0.000702424912904498\n",
 733 |       "AA: 0.994955 +- 0.0006838471137615434\n",
 734 |       "kappa: 0.9935350299965142 +- 0.0008007461329981173\n",
 735 |       "list: [1.      0.98566 0.99122 1.      0.98686 0.99582 1.      1.      1.\n",
 736 |       " 0.99976 0.99502 0.99286 0.98852 1.      0.99878 0.98478] +- [0.         0.00347194 0.00205757 0.         0.00247516 0.00220581\n",
 737 |       " 0.         0.         0.         0.00048    0.00095582 0.00295066\n",
 738 |       " 0.0036367  0.         0.00244    0.00504   ]\n"
 739 |      ]
 740 |     }
 741 |    ],
 742 |    "source": [
 743 |     "# %15\n",
 744 |     "print('OA:',np.mean(best_OAs),'+-',np.std(best_OAs))\n",
 745 |     "print('AA:',np.mean(best_AAs),'+-',np.std(best_AAs))\n",
 746 |     "print('kappa:',np.mean(best_kappas),'+-',np.std(best_kappas))\n",
 747 |     "print('list:',np.mean(np.array(best_lists),axis=0),'+-',np.std(np.array(best_lists),axis=0))"
 748 |    ]
 749 |   },
 750 |   {
 751 |    "cell_type": "code",
 752 |    "execution_count": 58,
 753 |    "metadata": {},
 754 |    "outputs": [
 755 |     {
 756 |      "name": "stdout",
 757 |      "output_type": "stream",
 758 |      "text": [
 759 |       "OA: 0.9712847899763787 +- 0.001647831662329786\n",
 760 |       "AA: 0.9600937499999999 +- 0.022130790202792083\n",
 761 |       "kappa: 0.9672403931425771 +- 0.001880087161634333\n",
 762 |       "list: [1.      0.95224 0.95328 0.99912 0.96386 0.97062 0.83706 0.99912 0.84212\n",
 763 |       " 0.91658 0.9908  0.95738 0.99178 0.99318 0.99892 0.99544] +- [0.         0.00721848 0.0122225  0.00176    0.01455343 0.00674638\n",
 764 |       " 0.15642621 0.00176    0.22574543 0.00454814 0.00411971 0.00793357\n",
 765 |       " 0.00696517 0.00418922 0.00216    0.00558484]\n"
 766 |      ]
 767 |     }
 768 |    ],
 769 |    "source": [
 770 |     "# %5\n",
 771 |     "print('OA:',np.mean(best_OAs),'+-',np.std(best_OAs))\n",
 772 |     "print('AA:',np.mean(best_AAs),'+-',np.std(best_AAs))\n",
 773 |     "print('kappa:',np.mean(best_kappas),'+-',np.std(best_kappas))\n",
 774 |     "print('list:',np.mean(np.array(best_lists),axis=0),'+-',np.std(np.array(best_lists),axis=0))"
 775 |    ]
 776 |   },
 777 |   {
 778 |    "cell_type": "code",
 779 |    "execution_count": 41,
 780 |    "metadata": {
 781 |     "scrolled": true
 782 |    },
 783 |    "outputs": [
 784 |     {
 785 |      "name": "stdout",
 786 |      "output_type": "stream",
 787 |      "text": [
 788 |       "OA: 0.9854943625325238 +- 0.0008844786667116842\n",
 789 |       "AA: 0.97278875 +- 0.006005010147784957\n",
 790 |       "kappa: 0.9834715498389712 +- 0.0010086179460161327\n",
 791 |       "list: [1.      0.9776  0.98072 0.99906 0.9425  0.9994  1.      1.      0.74446\n",
 792 |       " 0.9817  0.9901  0.96328 0.99244 0.99928 0.99884 0.99524] +- [0.         0.00568401 0.00846981 0.00188    0.01078796 0.0012\n",
 793 |       " 0.         0.         0.09684556 0.00577512 0.00060332 0.00809009\n",
 794 |       " 0.01001551 0.0006735  0.0014207  0.00582979]\n"
 795 |      ]
 796 |     }
 797 |    ],
 798 |    "source": [
 799 |     "# %10\n",
 800 |     "print('OA:',np.mean(best_OAs),'+-',np.std(best_OAs))\n",
 801 |     "print('AA:',np.mean(best_AAs),'+-',np.std(best_AAs))\n",
 802 |     "print('kappa:',np.mean(best_kappas),'+-',np.std(best_kappas))\n",
 803 |     "print('list:',np.mean(np.array(best_lists),axis=0),'+-',np.std(np.array(best_lists),axis=0))"
 804 |    ]
 805 |   },
 806 |   {
 807 |    "cell_type": "code",
 808 |    "execution_count": null,
 809 |    "metadata": {},
 810 |    "outputs": [],
 811 |    "source": []
 812 |   },
 813 |   {
 814 |    "cell_type": "code",
 815 |    "execution_count": null,
 816 |    "metadata": {},
 817 |    "outputs": [],
 818 |    "source": []
 819 |   },
 820 |   {
 821 |    "cell_type": "code",
 822 |    "execution_count": null,
 823 |    "metadata": {},
 824 |    "outputs": [],
 825 |    "source": []
 826 |   },
 827 |   {
 828 |    "cell_type": "code",
 829 |    "execution_count": null,
 830 |    "metadata": {},
 831 |    "outputs": [],
 832 |    "source": []
 833 |   },
 834 |   {
 835 |    "cell_type": "code",
 836 |    "execution_count": null,
 837 |    "metadata": {},
 838 |    "outputs": [],
 839 |    "source": []
 840 |   },
 841 |   {
 842 |    "cell_type": "code",
 843 |    "execution_count": null,
 844 |    "metadata": {},
 845 |    "outputs": [],
 846 |    "source": []
 847 |   },
 848 |   {
 849 |    "cell_type": "code",
 850 |    "execution_count": null,
 851 |    "metadata": {},
 852 |    "outputs": [],
 853 |    "source": [
 854 |     "import time"
 855 |    ]
 856 |   },
 857 |   {
 858 |    "cell_type": "code",
 859 |    "execution_count": null,
 860 |    "metadata": {},
 861 |    "outputs": [],
 862 |    "source": [
 863 |     "hsimg = data.permute(2,0,1).unsqueeze(0).cuda()\n",
 864 |     "\n",
 865 |     "time1 = time.time()\n",
 866 |     "classes = Net(hsimg,seg_index.unsqueeze(0).unsqueeze(0))\n",
 867 |     "pre = torch.max(classes, dim=1)\n",
 868 |     "time2 = time.time()"
 869 |    ]
 870 |   },
 871 |   {
 872 |    "cell_type": "code",
 873 |    "execution_count": null,
 874 |    "metadata": {},
 875 |    "outputs": [],
 876 |    "source": [
 877 |     "(time2-time1)*1000"
 878 |    ]
 879 |   },
 880 |   {
 881 |    "cell_type": "code",
 882 |    "execution_count": null,
 883 |    "metadata": {},
 884 |    "outputs": [],
 885 |    "source": [
 886 |     "best_OAs"
 887 |    ]
 888 |   },
 889 |   {
 890 |    "cell_type": "code",
 891 |    "execution_count": null,
 892 |    "metadata": {},
 893 |    "outputs": [],
 894 |    "source": []
 895 |   },
 896 |   {
 897 |    "cell_type": "code",
 898 |    "execution_count": null,
 899 |    "metadata": {},
 900 |    "outputs": [],
 901 |    "source": [
 902 |     "#Computer complexity"
 903 |    ]
 904 |   },
 905 |   {
 906 |    "cell_type": "code",
 907 |    "execution_count": 75,
 908 |    "metadata": {},
 909 |    "outputs": [
 910 |     {
 911 |      "name": "stderr",
 912 |      "output_type": "stream",
 913 |      "text": [
 914 |       "Unsupported operator aten::scatter_ encountered 5 time(s)\n",
 915 |       "Unsupported operator aten::sum encountered 25 time(s)\n",
 916 |       "Unsupported operator aten::repeat encountered 20 time(s)\n",
 917 |       "Unsupported operator aten::mul encountered 35 time(s)\n",
 918 |       "Unsupported operator aten::add encountered 15 time(s)\n",
 919 |       "Unsupported operator aten::div encountered 5 time(s)\n",
 920 |       "Unsupported operator aten::sub encountered 5 time(s)\n",
 921 |       "Unsupported operator aten::numpy_T encountered 5 time(s)\n",
 922 |       "Unsupported operator aten::exp encountered 5 time(s)\n",
 923 |       "Unsupported operator aten::eye encountered 10 time(s)\n",
 924 |       "Unsupported operator aten::rsub encountered 5 time(s)\n",
 925 |       "Unsupported operator aten::max_pool2d encountered 4 time(s)\n",
 926 |       "The following submodules of the model were never called during the trace of the graph. They may be unused, or they were accessed by direct calls to .forward() or via other python methods. In the latter case they will have zeros for statistics, though their statistics will still contribute to their parent calling module.\n",
 927 |       "Softmax\n"
 928 |      ]
 929 |     },
 930 |     {
 931 |      "name": "stdout",
 932 |      "output_type": "stream",
 933 |      "text": [
 934 |       "3.1419600434601307\n",
 935 |       "[INFO] Register zero_ops() for <class 'torch.nn.modules.pooling.MaxPool2d'>.\n",
 936 |       "[INFO] Register count_normalization() for <class 'torch.nn.modules.batchnorm.BatchNorm2d'>.\n",
 937 |       "[INFO] Register count_softmax() for <class 'torch.nn.modules.activation.Softmax'>.\n",
 938 |       "0.02225572243332863\n"
 939 |      ]
 940 |     }
 941 |    ],
 942 |    "source": [
 943 |     "from thop import profile\n",
 944 |     "from fvcore.nn import FlopCountAnalysis, parameter_count_table\n",
 945 |     "\n",
 946 |     "Net = SegNet(in_channel = channel_num, \n",
 947 |     "                         block_num = Block_num,\n",
 948 |     "                         class_num=class_num+1, \n",
 949 |     "                         adj_mask = adj_mask,\n",
 950 |     "                         if_feature_update = if_up,\n",
 951 |     "                         scale_layer = scale).cuda()\n",
 952 |     "hsimg = data.permute(2,0,1).unsqueeze(0).cuda()\n",
 953 |     "\n",
 954 |     "from thop import profile\n",
 955 |     "from fvcore.nn import FlopCountAnalysis, parameter_count_table\n",
 956 |     "\n",
 957 |     "flops = FlopCountAnalysis(Net, inputs=(hsimg,seg_index.unsqueeze(0).unsqueeze(0)))\n",
 958 |     "print(flops.total()/(1024**3))w\n",
 959 |     "\n",
 960 |     "# Net.eval()\n",
 961 |     "f,p = profile(Net,inputs=(hsimg,seg_index.unsqueeze(0).unsqueeze(0),))\n",
 962 |     "print(f/(1024**3))"
 963 |    ]
 964 |   },
 965 |   {
 966 |    "cell_type": "code",
 967 |    "execution_count": 59,
 968 |    "metadata": {},
 969 |    "outputs": [
 970 |     {
 971 |      "name": "stdout",
 972 |      "output_type": "stream",
 973 |      "text": [
 974 |       "| name              | #elements or shape   |\n",
 975 |       "|:------------------|:---------------------|\n",
 976 |       "| model             | 0.3M                 |\n",
 977 |       "|  gcn1             |  80.4K               |\n",
 978 |       "|   gcn1.weight     |   (200, 200)         |\n",
 979 |       "|   gcn1.W          |   (200, 200)         |\n",
 980 |       "|   gcn1.bn         |   0.4K               |\n",
 981 |       "|    gcn1.bn.weight |    (200,)            |\n",
 982 |       "|    gcn1.bn.bias   |    (200,)            |\n",
 983 |       "|  gcn2             |  80.4K               |\n",
 984 |       "|   gcn2.weight     |   (200, 200)         |\n",
 985 |       "|   gcn2.W          |   (200, 200)         |\n",
 986 |       "|   gcn2.bn         |   0.4K               |\n",
 987 |       "|    gcn2.bn.weight |    (200,)            |\n",
 988 |       "|    gcn2.bn.bias   |    (200,)            |\n",
 989 |       "|  gcn3             |  80.4K               |\n",
 990 |       "|   gcn3.weight     |   (200, 200)         |\n",
 991 |       "|   gcn3.W          |   (200, 200)         |\n",
 992 |       "|   gcn3.bn         |   0.4K               |\n",
 993 |       "|    gcn3.bn.weight |    (200,)            |\n",
 994 |       "|    gcn3.bn.bias   |    (200,)            |\n",
 995 |       "|  gcn4             |  80.4K               |\n",
 996 |       "|   gcn4.weight     |   (200, 200)         |\n",
 997 |       "|   gcn4.W          |   (200, 200)         |\n",
 998 |       "|   gcn4.bn         |   0.4K               |\n",
 999 |       "|    gcn4.bn.weight |    (200,)            |\n",
1000 |       "|    gcn4.bn.bias   |    (200,)            |\n",
1001 |       "|  gcn              |  13.9K               |\n",
1002 |       "|   gcn.weight      |   (800, 17)          |\n",
1003 |       "|   gcn.W           |   (17, 17)           |\n",
1004 |       "|   gcn.bn          |   34                 |\n",
1005 |       "|    gcn.bn.weight  |    (17,)             |\n",
1006 |       "|    gcn.bn.bias    |    (17,)             |\n"
1007 |      ]
1008 |     }
1009 |    ],
1010 |    "source": [
1011 |     "print(parameter_count_table(Net))"
1012 |    ]
1013 |   }
1014 |  ],
1015 |  "metadata": {
1016 |   "kernelspec": {
1017 |    "display_name": "Python 3",
1018 |    "language": "python",
1019 |    "name": "python3"
1020 |   },
1021 |   "language_info": {
1022 |    "codemirror_mode": {
1023 |     "name": "ipython",
1024 |     "version": 3
1025 |    },
1026 |    "file_extension": ".py",
1027 |    "mimetype": "text/x-python",
1028 |    "name": "python",
1029 |    "nbconvert_exporter": "python",
1030 |    "pygments_lexer": "ipython3",
1031 |    "version": "3.6.13"
1032 |   },
1033 |   "toc": {
1034 |    "base_numbering": 1,
1035 |    "nav_menu": {},
1036 |    "number_sections": true,
1037 |    "sideBar": true,
1038 |    "skip_h1_title": false,
1039 |    "title_cell": "Table of Contents",
1040 |    "title_sidebar": "Contents",
1041 |    "toc_cell": false,
1042 |    "toc_position": {},
1043 |    "toc_section_display": true,
1044 |    "toc_window_display": false
1045 |   }
1046 |  },
1047 |  "nbformat": 4,
1048 |  "nbformat_minor": 4
1049 | }
1050 | 


--------------------------------------------------------------------------------