HybridSN 에 SE 모듈 추가

코드 연습
HybridSN 에 SE 모듈 추가

#! wget http://www.ehu.eus/ccwintco/uploads/6/67/Indian_pines_corrected.mat
#! wget http://www.ehu.eus/ccwintco/uploads/c/c4/Indian_pines_gt.mat
#! pip install spectral
import numpy as np
import matplotlib.pyplot as plt
import scipy.io as sio
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report, cohen_kappa_score
import spectral
import torch
import torchvision
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

class_num = 16

class SEBlock(nn.Module):
  def __init__(self,in_channels,r=16):
    super(SEBlock,self).__init__()
    self.globalAvgPool = nn.AdaptiveAvgPool2d((1,1))
    self.fc1 = nn.Linear(in_channels,round(in_channels/r))
    self.fc2 = nn.Linear(round(in_channels/r),in_channels)
  def forward(self,x):
    out = self.globalAvgPool(x)
    out = out.view(out.shape[0],-1)
    out = F.relu(self.fc1(out))
    out = F.sigmoid(self.fc2(out))
    out = out.view(x.shape[0],x.shape[1],1,1)
    out = x * out
    return out

class HybridSN(nn.Module):
  def __init__(self):
    super(HybridSN,self).__init__()
    self.conv3d1 = nn.Conv3d(1,8,kernel_size=(7,3,3),stride=1,padding=0)
    self.bn1 = nn.BatchNorm3d(8)
    self.conv3d2 = nn.Conv3d(8,16,kernel_size=(5,3,3),stride=1,padding=0)
    self.bn2 = nn.BatchNorm3d(16)
    self.conv3d3 = nn.Conv3d(16,32,kernel_size=(3,3,3),stride=1,padding=0)
    self.bn3 = nn.BatchNorm3d(32)
    self.conv2d4 = nn.Conv2d(576,64,kernel_size=(3,3),stride=1,padding=0)
    self.SElayer = SEBlock(64,16)
    self.bn4 = nn.BatchNorm2d(64)
    self.fc1 = nn.Linear(18496,256)
    self.fc2 = nn.Linear(256,128)
    self.fc3 = nn.Linear(128,16)
    self.dropout = nn.Dropout(0.4)

  def forward(self,x):
    out = F.relu(self.bn1(self.conv3d1(x)))
    out = F.relu(self.bn2(self.conv3d2(out)))
    out = F.relu(self.bn3(self.conv3d3(out)))
    out = F.relu(self.bn4(self.conv2d4(out.reshape(out.shape[0],-1,19,19))))
    out = self.SElayer(out)
    out = out.reshape(out.shape[0],-1)
    out = F.relu(self.dropout(self.fc1(out)))
    out = F.relu(self.dropout(self.fc2(out)))
    out = self.fc3(out)
    return out


def applyPCA(X, numComponents):
    newX = np.reshape(X, (-1, X.shape[2]))
    pca = PCA(n_components=numComponents, whiten=True)
    newX = pca.fit_transform(newX)
    newX = np.reshape(newX, (X.shape[0], X.shape[1], numComponents))
    return newX

#           patch  ，         ，  ，         padding   
def padWithZeros(X, margin=2):
    newX = np.zeros((X.shape[0] + 2 * margin, X.shape[1] + 2* margin, X.shape[2]))
    x_offset = margin
    y_offset = margin
    newX[x_offset:X.shape[0] + x_offset, y_offset:X.shape[1] + y_offset, :] = X
    return newX

#           patch ，        keras      
def createImageCubes(X, y, windowSize=5, removeZeroLabels = True):
    #   X   padding
    margin = int((windowSize - 1) / 2)
    zeroPaddedX = padWithZeros(X, margin=margin)
    # split patches
    patchesData = np.zeros((X.shape[0] * X.shape[1], windowSize, windowSize, X.shape[2]))
    patchesLabels = np.zeros((X.shape[0] * X.shape[1]))
    patchIndex = 0
    for r in range(margin, zeroPaddedX.shape[0] - margin):
        for c in range(margin, zeroPaddedX.shape[1] - margin):
            patch = zeroPaddedX[r - margin:r + margin + 1, c - margin:c + margin + 1]   
            patchesData[patchIndex, :, :, :] = patch
            patchesLabels[patchIndex] = y[r-margin, c-margin]
            patchIndex = patchIndex + 1
    if removeZeroLabels:
        patchesData = patchesData[patchesLabels>0,:,:,:]
        patchesLabels = patchesLabels[patchesLabels>0]
        patchesLabels -= 1
    return patchesData, patchesLabels

def splitTrainTestSet(X, y, testRatio, randomState=345):
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=testRatio, random_state=randomState, stratify=y)
    return X_train, X_test, y_train, y_test
#     
class_num = 16
X = sio.loadmat('Indian_pines_corrected.mat')['indian_pines_corrected']
y = sio.loadmat('Indian_pines_gt.mat')['indian_pines_gt']

#          
test_ratio = 0.90
#          patch    
patch_size = 25
#    PCA   ，        
pca_components = 30

print('Hyperspectral data shape: ', X.shape)
print('Label shape: ', y.shape)

print('
... ... PCA tranformation ... ...')
X_pca = applyPCA(X, numComponents=pca_components)
print('Data shape after PCA: ', X_pca.shape)

print('
... ... create data cubes ... ...')
X_pca, y = createImageCubes(X_pca, y, windowSize=patch_size)
print('Data cube X shape: ', X_pca.shape)
print('Data cube y shape: ', y.shape)

print('
... ... create train & test data ... ...')
Xtrain, Xtest, ytrain, ytest = splitTrainTestSet(X_pca, y, test_ratio)
print('Xtrain shape: ', Xtrain.shape)
print('Xtest  shape: ', Xtest.shape)

#    Xtrain, Ytrain    ，    keras    
Xtrain = Xtrain.reshape(-1, patch_size, patch_size, pca_components, 1)
Xtest  = Xtest.reshape(-1, patch_size, patch_size, pca_components, 1)
print('before transpose: Xtrain shape: ', Xtrain.shape) 
print('before transpose: Xtest  shape: ', Xtest.shape) 

#      pytorch   ，     transpose
Xtrain = Xtrain.transpose(0, 4, 3, 1, 2)
Xtest  = Xtest.transpose(0, 4, 3, 1, 2)
print('after transpose: Xtrain shape: ', Xtrain.shape) 
print('after transpose: Xtest  shape: ', Xtest.shape) 


""" Training dataset"""
class TrainDS(torch.utils.data.Dataset): 
    def __init__(self):
        self.len = Xtrain.shape[0]
        self.x_data = torch.FloatTensor(Xtrain)
        self.y_data = torch.LongTensor(ytrain)        
    def __getitem__(self, index):
        #               
        return self.x_data[index], self.y_data[index]
    def __len__(self): 
        #          
        return self.len

""" Testing dataset"""
class TestDS(torch.utils.data.Dataset): 
    def __init__(self):
        self.len = Xtest.shape[0]
        self.x_data = torch.FloatTensor(Xtest)
        self.y_data = torch.LongTensor(ytest)
    def __getitem__(self, index):
        #               
        return self.x_data[index], self.y_data[index]
    def __len__(self): 
        #          
        return self.len

#    trainloader   testloader
trainset = TrainDS()
testset  = TestDS()
train_loader = torch.utils.data.DataLoader(dataset=trainset, batch_size=128, shuffle=True, num_workers=2)
test_loader  = torch.utils.data.DataLoader(dataset=testset,  batch_size=128, shuffle=False, num_workers=2)
#   GPU  ，      "      " -> "       "      
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

#     GPU 
net = HybridSN().to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.001)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min',verbose=True,factor=0.9,min_lr=1e-6)

#     
total_loss = 0
net.train()
for epoch in range(100):
    for i, (inputs, labels) in enumerate(train_loader):
        inputs = inputs.to(device)
        labels = labels.to(device)
        #        
        optimizer.zero_grad()
        #      +　     +    
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        scheduler.step(loss) 
        total_loss += loss.item()
        nn.ReLU()
    print('[Epoch: %d]   [loss avg: %.4f]   [current loss: %.4f]' %(epoch + 1, total_loss/(epoch+1), loss.item()))

print('Finished Training')
net.eval()
count = 0
for inputs,labels in test_loader:
  inputs = inputs.to(device)
  labels = labels.to(device)
  outputs = net(inputs)
  _,preds = torch.max(outputs,1)
  count += (preds == labels).sum().item()
print("Test ACC:{}".format(count/len(testset)))

테스트 결과 대비
BN, SE 모듈 을 추가 하지 않 았 을 때 세 번 테스트 한 결과: 0.9805, 0.9412, 0.9624 BN 층 을 추가 한 후 세 번 테스트 한 결과: 0.9860, 0.9789, 0.9820 재 첨가 학 습 률 감소 후 세 번 테스트 한 결과: 0.9895, 0.9901, 0.9897 SE 모듈 을 추가 한 후 세 번 테스트 한 결과: 0.9913, 0.9895, 0.9912
BN 층 을 추가 한 후 훈련 결과 가 안정 적 이 고 수렴 이 빠르다.SE 모듈 을 추가 한 후에 도 정확도 가 약간 높 아 졌 지만 효과 가 그리 뚜렷 하지 않 았 다. 모델 이 비교적 간단 하고 성능 을 향상 시 키 는 일부 조작 을 취 했 으 며 SE 모듈 만 추 가 했 기 때문에 향상 이 그리 뚜렷 하지 않 았 다.
문제 사고
네트워크 를 훈련 하고 몇 번 더 테스트 하면 분류 결과 가 다른 이 유 를 발견 할 수 있다.
네트워크 에 dropout 층 과 BN 층 이 추가 되 었 을 때 테스트 할 때 이 두 층 을 닫 아야 하기 때문이다.훈련 할 때 현재 훈련 모드 를 지정 해 야 합 니 다. model. train () 은 이 두 층 을 엽 니 다.테스트 할 때 테스트 모드 를 지정 해 야 합 니 다: model. eval () 이 두 층 을 닫 습 니 다.dropout 층 은 훈련 과정 에서 지 정 된 확률 p 로 신경 원 을 활성화 시 켜 이번 전파 과정 에서 의 출력 을 0 으로 한다.우리 의 모델 이 예측 을 잘 훈련 할 때 는 모든 뉴 런 을 사용 하고 보상 계 수 를 곱 해 야 한다.그래서 현재 훈련 인지 테스트 모드 인지 지정 해 야 합 니 다.BN 층 은 테스트 할 때 고정된 mean 과 var 를 사용 하 는데 이 두 개의 고정된 매개 변 수 는 훈련 할 때 통계 적 으로 계산 한 것 이다.이 두 매개 변 수 는 전방 향 전파 과정 에서 계산 되 기 때문에 테스트 모드 에서 모델. eval () 을 지정 하지 않 으 면 이 두 매개 변 수 는 테스트 데이터 에 따라 업데이트 되 어 결과 의 참고 가치 가 크 지 않다.다시 말 하면 네트워크 에 BN 층 과 dropout 층 을 추가 하고 model. eval () 을 사용 하지 않 으 면 테스트 할 때마다 모델 이 고정 되 어 있 지 않 기 때문에 매번 분류 결과 가 일치 하지 않 을 수 있 습 니 다.
SENet 의 분류 성능 향상 의 본질 원리
Excitation 의 출력 가중치 는 특징 선택 후의 모든 특징 채널 의 중요성 을 중시 한 다음 에 곱셈 을 통 해 채널 마다 이전의 특징 에 가중 시 켜 채널 차원 에서 원시 적 특징 에 대한 재 표 시 를 완성 하고 유용 한 특징 을 향상 시 키 며 현재 작업 에 큰 도움 이 되 지 않 는 특징 을 억제한다.추측: 유용 한 특징의 곱 하기 scale 이 비교적 크 고 그 수치 가 비교적 크다.용도 가 크 지 않 은 특징 을 곱 한 scale 이 비교적 작 으 면 그 수 치 는 비교적 작다.마지막 전체 국면 에서 평균 연못 화 층 을 고려 할 때 유용 한 특징 은 연못 화 를 거 친 후의 수출 도 비교적 크다. 이 는 최종 분류 결과 에 대한 영향 이 비교적 크 고 같은 용도 가 크 지 않 은 특징 이 최종 분류 결과 에 미 치 는 영향 이 비교적 작 아서 분류의 성능 을 향상 시 켰 다.