神经网络的构建

1. 神经网络的相关内容：

1.词向量：一般维度在50～300维之间，维度越高，数据的精确度就越高

将神经网络想象成一个黑匣子

2.skip-gram模型可以输入值，得到相应的相应的上下文

CBOW模型可以输入上下文，得到中间的预测值

3.数据训练：通过指定的滑动窗口，持续地改变输入input和输出output

4.如何进行训练：

二级分类：输入值是两个单词，输出值是两个单词是否具有相邻关系的概率

target=1表示是正采样数据，两个词之间具有相邻关系

人为添加3～5个负采样方案（negative samples），target=0

2.构建神经网络模型代码部分

import torch
import torch.nn as nn
from torch.nn import functional as F
from torchvision import datasets,transforms
import matplotlib.pyplot as plt
import numpy as np
from torch.utils import data as data
import torch.optim as optim


#第一步：读取数据：
# 分别构建训练集和测试集
# DataLoader来迭代取数据

#定义超参数
input_size=28#表示输入图像的尺寸是28*28*1
num_classes=10#标签的种类数
num_epochs=3#训练的总循环周期为3次
batch_size=64#一个批次的大小，64张图片

#训练集
train_dataset=datasets.MNIST(
    root='./train-images-idx3-ubyte',
    train=True,
    transform=transforms.ToTensor(),
    download=True
)

#测试集
test_dataset=datasets.MNIST(
    root='./train-images-idx3-ubyte',
    train=False,
    transform=transforms.ToTensor()
)

#构建batch数据
train_loader=data.DataLoader(
    dataset=train_dataset,
    shuffle=True
)
test_loader=data.DataLoader(
    dataset=test_dataset,
    shuffle=True
)



#第二步：卷积网络模块构建
# 一般卷积层，Relu层可以写成一个套餐
# 注意卷积最后结果还是一个特征图，需要把图转换成向量才能够做做分类或回归任务
# (conv+relu)*2+pooling

class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        #第一个卷积模块conv1：
        self.conv1=nn.Sequential(#输入大小是1*28*28
            nn.Conv2d(             #Conv2d表示二维卷积模块，通常被用于图像处理，Conv1d表示一维卷积模块，用于语言文本的处理
                in_channels=1,     #灰度图：通道数是1
                out_channels=16,   #要得到多少个特征图
                kernel_size=5,     #卷积核的大小为5
                stride=1,          #步长为1
                padding=2          #如果希望卷积后的大小和原来的一样，需要设置padding=(kernel_size-1)/2，if stride=1
            ),
            #第一次二维卷积后得到的特征图是16*28*28
            nn.ReLU(),             #Relu操作
            nn.MaxPool2d(kernel_size=2),#池化操作，输出结果是16*14*14
        )

        #第二个卷积模块conv2
        self.conv2=nn.Sequential(
            nn.Conv2d(
                16,     #第一次卷积模块的out_channels=16,作为第二次卷积模块的in_channels
                32,    #第二次二维卷积得到的特征图的通道数是32
                5,      #卷积核的大小是5
                1,          #卷积的步长是1
                2         #保证输出图像的大小与输入图像的大小一致，padding=(kernel_size-1)/2,if stride=1
                #经过卷积后图像的尺寸大小=(输入图像尺寸大小-kernel_size+2*padding)/stride+1
            ),
            #第二个卷积模块的二维卷积得到的特征图的大小是32*14*14
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),#池化操作，输出结果是32*7*7
        )

        #全连接得到的结果
        self.out=nn.Linear(32*7*7,10)#10表示10个类别

        #
        def forward(x):
            x=self.conv1(x)         #经过第一个卷积模块
            x=self.conv2(x)         #经过第二个卷积模块
            x=x.view(x.size(0),-1)  #flatten操作，结果是:(batch_size,32*7*7),将立体的图像(32,7,7)扁平化成一个矩阵
            output=self.out(x)
            return output


#第三步：准确率作为评估标准
def accuracy(predictions,labels):
    pred=torch.max(predictions.data,1)[1]
    rights=pred.eq(labels.data.view_as(pred)).sum()
    return rights,len(labels)



#第四步：训练网络模型

#实例化
net=CNN()

#损失函数
criterion=nn.CrossEntropyLoss()#自动计算出softmax()，得到交叉熵，交叉熵越高，所含的信息量就越少

#优化器:定义优化器，普遍的随机梯度下降算法
optimizer=optim.Adam(net.parameters(),lr=0.001)

#开始训练循环epochs=3
for epoch in range(num_epochs):
    train_rights=[]#将当前epoch的结果记录下来
    #更新权重操作
    for batch_idx,(data,target) in enumerate(train_loader):#针对容器中的每一个batch进行循环
        net.train()
        output=net(data)
        loss=criterion(output,target)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        right=accuracy(output,target)#得到准确率
        train_rights.append(right)

        if batch_idx%100==0:#每隔100次来看验证集的效果
            net.eval()
            val_rights=[]

            for(data,target) in test_loader:
                output=net(data)
                right=accuracy(output,target)
                val_rights.append(right)

            #准确率计算：
            train_r=(sum([tup[0] for tup in train_rights]),sum([tup[1] for tup in train_rights]))
            val_r=(sum([tup[0] for tup in val_rights]),sum([tup[1] for tup in val_rights]))

            print("当前epoch：{} [{}/{} ({:.Of}%)]\t损失:{:.6f}\t训练集准确率:{:.2f}%\t测试集准确率：{:.2f}%".format(
                epoch,batch_idx*batch_size,len(train_loader.dataset),
                100.*batch_idx/len(train_loader),
                loss.data,
                100*train_r[0].numpy()/train_r[1],
                100.*val_r[0].numpy()/val_r[1]
            ))