pytorch 利用BP神经网路对坐标区域进行分类

代码test 部分是meng yu hong 写的   画图部分的代码

import numpy as np
import scipy.io as scio
import torch 
import torch.nn.functional as Fun
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import Dataset, DataLoader
import matplotlib.pyplot as plt

### train
x1=np.arange(100)
y1=np.arange(401)
### test ay[]
x2=np.arange(110,210)
reg1=[]
reg1_2=[]
### the region 1 
for i in x1: 
    for j in y1:
        reg1_2.append([i,j])
        demo1=[i,j,1,0]
        reg1.append(demo1) 
reg2 = []
#print(reg1_2)
# assert False
reg2_2=[]
for i in x2: 
    for j in y1:
        reg2_2.append([i,j])
        demo2=[i,j,0,1]
        reg2.append(demo2) 
print(len(reg1)*0.7, len(reg2)*0.7)

# fig = plt.figure()  
# ax1 = fig.add_subplot(111)
# ax1.scatter(np.array(reg1)[:,0],np.array(reg1)[:,1],c = 'b',marker = 'o')  
# ax1.scatter(np.array(reg2)[:,0],np.array(reg2)[:,1],c = 'r',marker = 'o')  
# plt.show()
# assert False 
'''
def produceData(r, w, d, num): 
    r1 = r-w/2
    r2 = r+w/2
    #上半圆 
    theta1 = np.random.uniform(0, np.pi ,num) 
    X_Col1 = np.random.uniform( r1*np.cos(theta1),r2*np.cos(theta1),num)[:, np.newaxis] 
    X_Row1 = np.random.uniform(r1*np.sin(theta1),r2*np.sin(theta1),num)[:, np.newaxis] 
    Y_label1 = np.ones(num) #类别标签为1 
    #下半圆 
    theta2 = np.random.uniform(-np.pi, 0 ,num) 
    X_Col2 = (np.random.uniform( r1*np.cos(theta2),r2*np.cos(theta2),num) + r)[:, np.newaxis] 
    X_Row2 = (np.random.uniform(r1 * np.sin(theta2), r2 * np.sin(theta2), num) -d)[:,np.newaxis] 
    Y_label2 = -np.ones(num) #类别标签为-1,注意：由于采取双曲正切函数作为激活函数，类别标签不能为0 
    #合并 
    X_Col = np.vstack((X_Col1, X_Col2)) 
    X_Row = np.vstack((X_Row1, X_Row2)) 
    X = np.hstack((X_Col, X_Row)) 
    Y_label = np.hstack((Y_label1,Y_label2)) 
    Y_label.shape = (num*2 , 1) 
    return X,Y_label
'''
np.random.shuffle(reg1)
np.random.shuffle(reg2)
train = np.r_[reg1[0:28070], reg2[0:27789]]
test = np.r_[reg1[28070:len(reg1)], reg2[27789:len(reg2)]]
# fig = plt.figure()  
# ax1 = fig.add_subplot(111)
# ax1.scatter(train[:,0], train[:,1], c='b', marker='o')  
# ax1.scatter(test[:,0], test[:,1], c = 'r',marker = 'o')  
# plt.show()
# assert False 

# train = np.random.normal(size=(500,2))
# plt.scatter(train[:, 0], train[:, 1])
# plt.show()
# assert 0

print("type(test):", type(test))

class TrainDataset(Dataset):
    def __init__(self):
        self.train_dataset = train### 76943*343
        # print("---------",self.train_dataset.shape, type( self.train_dataset[0][0]) )
        self.data_tf = transforms.ToTensor()
        
    def __getitem__(self, i):
        # print("type(self.train_dataset[i]):",type(self.train_dataset[i][2]))
        return torch.from_numpy(self.train_dataset[i][0:2]), torch.from_numpy(np.array([self.train_dataset[i][2:4]]))

    def __len__(self):
        return len(self.train_dataset)


class TestDataset(Dataset):
    def __init__(self):
        self.train_dataset = test### 76943*343
        # print("---------",self.train_dataset.shape, type( self.train_dataset[0][0]) )
        self.data_tf = transforms.ToTensor()
        
    def __getitem__(self, i):
        # print("type(self.train_dataset[i]):",type(self.train_dataset[i][2]))
        # print(type([self.train_dataset[i][2:4]]))
       
        return torch.from_numpy(self.train_dataset[i][0:2]), torch.from_numpy(np.array([self.train_dataset[i][2:4]]))

    def __len__(self):
        return len(self.train_dataset )


train_dataset = TrainDataset()
print(train_dataset, type(train_dataset))
test_dataset = TestDataset()
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=128,                                            
                                           shuffle=True)  ### 将数据打乱

test_loader = torch.utils.data.DataLoader(dataset=test_dataset, 
                                          batch_size=200, 
                                          shuffle=True)           

# 定义BP神经网络
class CNNnet(torch.nn.Module):
    def __init__(self):
        super(CNNnet, self).__init__()
        self.mlp1 = torch.nn.Linear(2, 10)
        # print( "============", type( self.mlp1 ))
        self.mlp2 = torch.nn.Linear(10, 10)
        self.mlp3 = torch.nn.Linear(10, 2)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):       
        x = self.mlp1(x)
        # x = self.relu(x)
        x = Fun.relu(x)
        x = self.mlp2(x)
        # x = self.relu(x)
        x = Fun.relu(x)
        x = self.mlp3(x)
        # x = self.sigmoid(x)
        x = Fun.sigmoid(x)
        return x

model = CNNnet().double()
print(model) # foward() won't run
# assert False
# criterion=nn.CrossEntropyLoss()
#criterion = nn.BCEWithLogitsLoss()
criterion = nn.BCELoss()
total_step = len(train_loader)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

epochs = 15
loss_list = []
acc_list = []
for epoch in range(epochs):
    model.train()
    for i, (data,label) in enumerate(train_loader):
        out = model(data.double())
        predict = torch.max(out, 1)[1]
        label = label.view(out.shape[0], out.shape[1])
        labels_ = torch.max(label, 1)[1]
        acc = (predict == labels_).sum().item() / label.size()[0]
        acc_list.append(acc)
        # print(label.shape,label)
        loss = criterion(out, label.double())
        loss_list.append(loss.item())
        # print("loss",loss)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if (i+1)%100 == 0:
            print('Epoch[{}/{}], step[{}/{}], loss:{:.4f}, acc:{:.4f}'.format(epoch+1, epochs, i+1, total_step, loss.item(), acc)) 
            # loss.item() return the data item of a tensor
        
with torch.no_grad():
    correct = 0.
    total = 0.
    for data1, labels in test_loader:
        outputs = model(data1.double())
        predict = torch.max(outputs, 1)[1] # torch.max(t, axis=1) return elements and indexs
        total += labels.size(0)
        labels = labels.view(outputs.shape[0], outputs.shape[1]).double()
        labels_ = torch.max(labels, 1)[1]
        # print("outputs.shape:",labels_.shape, predict.shape)
        correct += (predict == labels_).sum().item()
    
  #  print("============:\n", outputs)
    # print("outputs.shape:",outputs.shape[0],outputs.shape[1])
    # print(labels.size(0),labels.shape, outputs.shape)
    # print("labels:",labels)ape)
  # print(outputs.shape, labels.shape)
    # print(predicted.shape,labels.sh)
    
    print('Accuracy of the network on the {} test samples: {} %'.format(total, 100 * correct/total))
    
torch.save(model.state_dict(), 'model.ckpt')

plt.figure()
plt.plot(loss_list)
plt.figure()
plt.plot(acc_list)
plt.show()

为画图部分的代码

import numpy as np
import scipy.io as scio
import torch 
import torch.nn.functional as Fun
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import Dataset, DataLoader
import matplotlib.pyplot as plt
### train
x1=np.arange(100)
y1=np.arange(401)
### test ay[]
x2=np.arange(110,210)
reg1=[]
reg1_2=[]
### the region 1 
for i in x1: 
    for j in y1:
        reg1_2.append([i,j])
        demo1=[i,j,1,0]
        reg1.append(demo1) 
reg2 = []
#print(reg1_2)
# assert False
reg2_2=[]
for i in x2: 
    for j in y1:
        reg2_2.append([i,j])
        demo2=[i,j,0,1]
        reg2.append(demo2) 
print(len(reg1)*0.7, len(reg2)*0.7)

np.random.shuffle(reg1)
np.random.shuffle(reg2)
train = np.r_[reg1[0:28070], reg2[0:27789]]
test = np.r_[reg1[28070:len(reg1)], reg2[27789:len(reg2)]]

print("type(test):", type(test))

class TrainDataset(Dataset):
    def __init__(self):
        self.train_dataset = train### 76943*343
        # print("---------",self.train_dataset.shape, type( self.train_dataset[0][0]) )
        self.data_tf = transforms.ToTensor()
        
    def __getitem__(self, i):
        # print("type(self.train_dataset[i]):",type(self.train_dataset[i][2]))
        return torch.from_numpy(self.train_dataset[i][0:2]), torch.from_numpy(np.array([self.train_dataset[i][2:4]]))#### 第4的一个元素不展示

    def __len__(self):
        return len(self.train_dataset)


class TestDataset(Dataset):
    def __init__(self):
        self.train_dataset = test### 76943*343
        # print("---------",self.train_dataset.shape, type( self.train_dataset[0][0]) )
        self.data_tf = transforms.ToTensor()
        
    def __getitem__(self, i):
        # print("type(self.train_dataset[i]):",type(self.train_dataset[i][2]))
        # print(type([self.train_dataset[i][2:4]]))
        return torch.from_numpy(self.train_dataset[i][0:2]), torch.from_numpy(np.array([self.train_dataset[i][2:4]]))

    def __len__(self):
        return len(self.train_dataset )


train_dataset = TrainDataset()
# print(train_dataset, type(train_dataset))
test_dataset = TestDataset()
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=128,                                            
                                           shuffle=True)  ### 将数据打乱

test_loader = torch.utils.data.DataLoader(dataset=test_dataset, 
                                          batch_size=200, 
                                          shuffle=True)           
# 定义BP神经网络
class CNNnet(torch.nn.Module):
    def __init__(self):
        super(CNNnet, self).__init__()
        self.mlp1 = torch.nn.Linear(2, 10)
        # print( "============", type( self.mlp1 ))
        self.mlp2 = torch.nn.Linear(10, 10)
        self.mlp3 = torch.nn.Linear(10, 2)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()    #将输出全部置为0~1之间
    def forward(self, x):       
        x = self.mlp1(x)
        # x = self.relu(x)
        x = Fun.relu(x)
        x = self.mlp2(x)
        # x = self.relu(x)
        x = Fun.relu(x)
        x = self.mlp3(x)
        # x = self.sigmoid(x)
        x = Fun.sigmoid(x)
        return x
model = CNNnet().double()
print(model) # foward() won't run
# assert False
#  criterion=nn.CrossEntropyLoss()
#criterion = nn.BCEWithLogitsLoss()
criterion = nn.BCELoss()
total_step = len(train_loader)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
epochs = 10

for epoch in range(epochs):
    model.train()
    for i, (data,label) in enumerate(train_loader):
        out = model(data.double())
        loss = criterion(out, label.double())
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if (i+1)%100 == 0:
            print('Epoch[{}/{}], step[{}/{}],, loss:{:.4f}'.format(epoch+1, epochs, i+1, total_step, loss.item() )) 
            # loss.item() return the data item of a tensor
with torch.no_grad():
    correct = 0.
    total = 0.
    for data1, labels in test_loader:
        outputs = model(data1.double())
        predict = torch.max(outputs, 1)[1] # torch.max(t, axis=1) return elements and indexs
        total += labels.size(0)
        labels = labels.view(outputs.shape[0], outputs.shape[1]).double()
        labels_ = torch.max(labels, 1)[1]
        # print("outputs.shape:",labels_.shape, predict.shape)
        correct += (predict == labels_).sum().item()
    print('Accuracy of the network on the {} test samples: {} %'.format(total, 100 * correct/total))
    
torch.save(model.state_dict(), 'model.ckpt')