PyTorch基础入门(1)

神经网络模块 (nn.Module)

nn.Module :是pytorch里面神经网络的基类,当我们实现线性模型时需要继承它

1.线性模型:

	构建模型(样例):

import torch.nn as nn
import torch
from torch.autograd import Variable

class LinearModel(nn.Module):
    # 构建线性模型
    def __init__(self):
    	super(LinerModel, self).__init__()
        self.linear = nn.Linear(1,2)  # 1表示输入维度，2表示输出维度
    def forward(self,x):
        output = self.linear(x)  # x表示的输入的数据
        return output
"""
上面是实现的一个简单的线性模型
下面表示训练该线性模型的过程
"""
if torch.cuda.is_available():  # 判断cuda是否能用
    model = LinearModel().cuda()  # 表示使用cuda(也及时启用GPU)训练模型
else:
    model = LinearModel()
"设置损失函数和优化器"
criterion = nn.MSELoss()  # 使用均方差误差损失函数
optimizer = torch.optim.SGD(model.parameters(),lr=1e-3)  # 初始化优化器，这儿使用的是随机梯度下降
"开始训练"
"设置迭代次数"
num_epochs = 1000
for epoch in range(num_epochs):
    """
    x_train:表示训练时的输入
    y_train:表示训练时的输出
    """
    if torch.cuda.is_availabel():
        "使用Variable将输入转成变量放入计算图"
        inputs = Variable(x_train).cuda()  # 启用cuda加速
        labels = Variable(y_train).cuda()  # 启用cuda加速
    else:
        inputs = Variable(x_train)  # 不启用cuda加速
        labels = Variable(y_train)  # 不启用cuda加速
	outputs = model(inputs)  # 进行前向传播，获得输出
    loss = criterion(outputs, labels)  # 进行误差计算,就是比较模型输出与标签的差异
    optimizer.zero_grad()  # 将优化器的梯度置零，防止梯度叠加，导致无法收敛
    loss.backward()  # 反向传播
    optimizer.step()
    
    if (epoch+1)%20 == 0:
        print("Epoch[{}/{}],loss:{:.6f}".format(epoch+1,num_epochs,loss.data[0]))

"进行模型的测试"
model.eval()  # 将模型转换成测试模型(如果不适用这个可能会报错)
predict = model(Variable(x_test))
predict = predict.data.numpy()  # 转成能够打印的数据
pring(predict)

2.分类模型(以二分类为例):

	构建模型(样例):

import torch.nn as nn
import torch
from torch.autograd import Variable


class ClassificationModel(nn.Module):
    # 构建二分类模型，使用sigmoid()函数进行分类
    def __init__(self):
        super(ClassificationModel, self).__init__()
        self.Linear = nn.Linear(2,1)
        self.sigmoid = nn.sigmoid()
    
    def forward(self,x):
        out = self.Linear(x)
        out = self.sigmoid(out)
    	
        return out

classification = ClassificationModel()  # 初始化分类模型
if torch.cuda.is_available():
    classification.cuda()

criterion = nn.BCELoss()  # 二分类的损失函数
optimizer = torch.optim.SGD(classification.parameters(), lr=1e-3,momentum=0.9)

num_epoch = 5000
for epoch in range(num_epoch):
    if torch.cuda.is_available():
        inputs = Variable(x_train).cuda()
        labels = Variable(y_train).cuda()
    else:
         inputs = Variable(x_train)
         outputs = Variable(y_train)
    "前向传播"
    outputs = classification(inputs)
    loss = criterion(outputs,labels)
    mask = outputs.ge(0.5).float()  # 0.5表示阈值，如果大于0.5表示属于第一类，不然属于第二类
    correct = (mask==labels).sum()
    acc = correct.data[0]/inputs.size(0)  # 计算精度
    "反向传播"
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if (epoch+1) %20 == 0:
        print('*'*10)
        print('epoch:{}'.format(epoch+1))
        print('loss:{}'.format(loss.data[0]))
        print('acc：{}'.format(acc))


	说明:

			correct = (mask==labels).sum()  该方法是用于统计该分类与标签相同的个数

参考书籍:《深度学习入门之PyTorch》