python实现简单的神经卷积网络

python实现简单的神经卷积网络

import torch
import torch.nn as nn
# import torch.autograd import Variable
import torch.utils.data as Data
import torchvision #包括了数据库以及图片的数据库
import matplotlib.pyplot as plt
# import tensorflow as tf

# raise attributeerror表示函数名可能写错了

#超参数
EPOCH=1 #在训练数据多少次
BATCH_SIZE=50
LR=0.001   #学习率
DOWNLOAD_MNIST=False #表示是否需要下载MNIST数据

train_data=torchvision.datasets.MNIST(
    root='./mnist',
    train=True,
    transform=torchvision.transforms.ToTensor   (),#从下载数据改变数据形式 #(0,1)   (0,255)
    download=DOWNLOAD_MNIST
)

#画一个示例
# torch.Size([60000, 28, 28])
# torch.Size([60000])
# print(train_data.train_data.size())
# print(train_data.train_labels.size())
# plt.imshow(train_data.train_data[0].numpy(),cmap='gray')
# plt.title('%i' % train_data.train_labels[0])
# plt.show()


'''
只有这样255才不会被压缩，所以前面需要进行手动压缩
for(b_x,b_y) in train_loader
     ...
'''
'''
num_workers表示加载的子进程数，这需要电脑的资源足够多
shuffle是否重新洗牌
batch_size:一次训练进行了多大
'''
train_loader=Data.DataLoader(dataset=train_data,batch_size=BATCH_SIZE,shuffle=True,num_workers=0) #TODO :这里原先是2的时候就出错了
test_data = torchvision.datasets.MNIST('./mnist',train=False)
# test_x= Variable(torch.unsqueeze(test_data.test_data,dim=1),volatile=True).type(torch.FloatTensor)[:2000]/255.
# 压缩纬度，将第一个纬度给压没了（可以理解为x的纬度）
test_x = torch.unsqueeze(test_data.data, dim=1).type(torch.FloatTensor)[:2000] / 255.
# test_y=test_data.test_labels[:2000]
test_y=test_data.targets[:2000]

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1=nn.Sequential(
            nn.Conv2d(#(1*28*28) #这里的1表示通道
                in_channels=1,
                out_channels=16,
                kernel_size=5,
                stride=1,
                padding=2, #如果 stride=1，padding=(kernel_size-1)/2=(5-1)/2
            ),# -->(16,28*28)
            nn.ReLU(),# -->(16,28*28)
            nn.MaxPool2d(kernel_size=2),# -->(16,14*14)
        )
        self.conv2=nn.Sequential(# (16,14*14)
            nn.Conv2d(16,32,5,1,2),#加工32层-->(32 14*14)
            nn.ReLU(),#-->(32 14*14)
            nn.MaxPool2d(2),#-->(32 7*7)
        )
        self.out=nn.Linear(32*7*7,10) #把前面的纬度32*7*7变成10

    def forward(self,x):
        x=self.conv1(x)
        x=self.conv2(x)  #(batch, 32 ,7,7)
        x=x.view(x.size(0),-1)  #(batch,32*7*7)
        output=self.out(x)
        return output
cnn=CNN()
print(cnn)

# 进行反向迭代的时候的梯度下降方法实现，lr就是学习率，另外就是传入网络的参数
optimizer = torch.optim.Adam(cnn.parameters(),lr=LR) #优化所有的cnn参数
print(cnn.parameters())
#损失函数
loss_func = nn.CrossEntropyLoss()  #这个目标标签不是一个one-hotted

'''
for i, data in enumerate(trainloader, 0):
            #data里面包含图像数据（inputs）(tensor类型的）和标签（labels）(tensor类型）。
            inputs, labels = data
'''
for epoch in range(EPOCH):
    for step, (x, y) in enumerate(train_loader):
        # 50*10  最后输出是分类的概率大小
        output = cnn(x)  # 得到网络中的输出数据
        loss = loss_func(output, y)  # 计算每一个网络的损失值
        optimizer.zero_grad()  # 在下一次求导之前将保留的grad清空
        loss.backward()  # 反向传播，计算梯度
        optimizer.step()  # 应用求导到优化器上去

        if step % 50 == 0:#表示已经进行了50的倍数了
            test_output = cnn(test_x)
            # 在分类问题中，通常需要使用max()函数对softmax函数的输出值进行操作，求出预测值索引，然后与标签进行比对，计算准确率。其中1表示纬度
            # 函数会返回两个tensor，第一个tensor是每行的最大值；第二个tensor是每行最大值的索引。我们需要的是第二个的索引，本来是tensor的格式，这里需要化为numpy格式
            pred_y = torch.max(test_output, 1)[1].data.numpy()
            # size()考虑到可能大小也是有纬度的，所以取的是第一个纬度
            # 这里的loss.data.numpy()和accuracy都是一纬的,如果是数组就直接把数据给输出了，这里也是可以的
            accuracy = sum(pred_y == test_y.data.numpy()) / test_y.size(0)
            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.2f' % accuracy)

# 从测试数据中计算10个预测,[:10]表示列表中第一项到第10项
test_output = cnn(test_x[:10])
# 这里为什么是max从而获得预测值
pred_y = torch.max(test_output, 1)[1].data.numpy() #返回的是最大值的索引
print(pred_y, 'prediction number')
print(test_y[:10].numpy(), 'real number')

# # 按间距中的绿色按钮以运行脚本。
#  if __name__ == '__main__':