pytorch学习笔记

# -*- coding: utf-8 -*-
"""
Created on Fri Jun  5 16:02:50 2020

@author: CJ
"""

import torch
x_data=[1.0,2.0,3.0]#列表
y_data=[2.0,4.0,6.0]#列表
w=torch.Tensor([0.5])#张量
w.requires_grad=True#需要梯度
def forward(x):#前导函数
    return x*w#w是张量故重载*号最后得张量
def loss(x,y):#损失函数
    y_pred=forward(x)#预测
    return (y_pred-y)**2#误差平方
print(4,forward(4).item())#item是张量值
for epoch in range(100):
    for x,y in zip(x_data,y_data):
        l=loss(x,y)#计算损失函数值
        l.backward()#把梯度存起来，释放计算图
        w.data=w.data-0.01*w.grad.data#学习率*权重梯度（.data返回一个tensor）
        w.grad.data.zero_()#防止累加，所以手动清零
    print(epoch,l.item())#轮次及损失函数值（.item()返回的是一个具体的数值）
print(4,forward(4).item(),l.item())#预测x=4时的前向预测值，以及损失函数值

#线性回归
import torch
x_data=torch.Tensor([[1.0],[2.0],[3.0]])
y_data=torch.Tensor([[2.0],[4.0],[6.0]])
class LinearModel(torch.nn.Module):#torch.nn.Moudule是必须继承的
    def __init__(self):#构造函数
        super(LinearModel,self).__init__()#当前类的父类初始化
        self.linear=torch.nn.Linear(1,1)#构造Linear类对象，(1,1)是x与y都是单属性/向量
    def forward(self,x):#前向计算
        return self.linear(x)#利用linear对象计算kx+b的傎（程序员无需考虑是k是否需要转置）
    #backward反馈求梯度自协执行
model=LinearModel()#创建类对象，将来直接model(x)即可
criterion=torch.nn.MSELoss(size_average=False)#差方和做损失函数，求不求均值没所谓
optimizer=torch.optim.SGD(model.parameters(),lr=0.01)#SGD优化器，model全参扔进去，学习率0.01
for epoch in range(100):#循环100次
    y_pred=model(x_data)#1、前向求出预测值
    loss=criterion(y_pred,y_data)#2、求出损失函数
    print(epoch,loss)#输出轮次及损失函数
    optimizer.zero_grad()#3.1、所有梯度权重归0
    loss.backward()#3.2、求梯度（与上一步可视为一步）
    optimizer.step()#4、更新
print('w=',model.linear.weight.item())#看训练权重
print('b=',model.linear.bias.item())#看训练偏置
x_test=torch.Tensor([[4.0]])#输入1x1矩阵
y_test=model(x_test)#输出1x1矩阵
print('y_pred=',y_test.data)#看预测值

'''
熟悉各种优化器原理
torch.optim.Adagrad
torch.optim.Adam
torch.optim.Adamax
torch.optim.ASGD
torch.optim.LBFGS
torch.optim.RMSprop
torch.optim.Rprop
torch.optim.SGD
'''

#补充python的*传参
def func(*args,x,**kwargs):
    print(args)
    print(kwargs)
func(1,2,4,3,x=3,y=5)

#逻辑回归
import torch
x_data=torch.Tensor([[1.0],[2.0],[3.0]])
y_data=torch.Tensor([[0],[0],[1]])#不是预测值，而是分类
class LogisticRegressionModel(torch.nn.Module):
    def __init__(self):
        super(LogisticRegressionModel,self).__init__()
        self.linear=torch.nn.Linear(1,1)
    def forward(self,x):
        y_pred=torch.nn.functional.sigmoid(self.linear(x))#线性基础上加sigmoid
        return y_pred
model=LogisticRegressionModel()
criterion=torch.nn.BCELoss(size_average=False)#改BCE损失
optimizer=torch.optim.SGD(model.parameters(),lr=0.01)
for epoch in range(100):
    y_pred=model(x_data)
    loss=criterion(y_pred,y_data)
    print(epoch,loss.item())
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
import numpy as np
import matplotlib.pyplot as plt
x=np.linspace(0,10,200)
x_t=torch.Tensor(x).view((200,1))
y_t=model(x_t)
y=y_t.data.numpy()
plt.plot(x,y)
plt.plot([0,10],[0.5,0.5],c='r')
plt.xlabel('hours')
plt.ylabel('probability of pass')
plt.grid()
plt.show()

#多维输入
import torch
import numpy as np 
xy = np.loadtxt('./dataset/diabetes.csv.gz', delimiter=',', dtype=np.float32) 
x_data = torch.from_numpy(xy[:,:-1]) 
y_data = torch.from_numpy(xy[:, [-1]])
class Model(torch.nn.Module): 
    def __init__(self): #构建Model类对象时自动构建下面四个类对象
        super(Model, self).__init__() 
        self.linear1 = torch.nn.Linear(8, 6) 
        self.linear2 = torch.nn.Linear(6, 4) 
        self.linear3 = torch.nn.Linear(4, 1) 
        self.sigmoid = torch.nn.Sigmoid()
    def forward(self, x): #
        x = self.sigmoid(self.linear1(x)) 
        x = self.sigmoid(self.linear2(x)) 
        x = self.sigmoid(self.linear3(x)) 
        return x
model = Model()
criterion = torch.nn.BCELoss(size_average=True)
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
for epoch in range(100):
    y_pred = model(x_data) 
    loss = criterion(y_pred, y_data) 
    print(epoch, loss.item())
    optimizer.zero_grad() 
    loss.backward()
    optimizer.step()

#多分类
import torch
y=torch.LongTensor([0])#y设成第0个分类
z=torch.Tensor([[0.2,0.1,-0.1]])#已知三个分类的输出
criterion=torch.nn.CrossEntropyLoss()#交叉熵计算
loss=criterion(z,y)#求损失
print(loss)#输出损失
'''
交叉熵计算分三步
1、对三个类别输出值softmax，属第i类概率P(i)=exp(zi)/求和exp(zi)
2、取log得logy，y是softmax后的预测值，下面Y是标签值1
3、最后求-Ylogy，由类别生成向量（属对应Y类取1其余取0）
'''
import torch 
from torchvision import transforms 
from torchvision import datasets 
from torch.utils.data import DataLoader 
impor