pytorch学习笔记（1）

糟糕的环境下除了学习，没什么能做的了，假期不能出去玩，只能一个人在宿舍学习了。刚开始接触pytorch，记录一下学习笔记

import torch
print(torch.__version__)#1.5.1
print('gpu:',torch.cuda.is_available())

1.手写梯度运算

import numpy as np
#y=wx+b
def compute_error_for_line_given_points(b,w,points):
    totalError=0
    for i in range(0,len(points)):
        x=points[i,0]
        y=points[i,1]
        totalError+=(y-(w*x+b))**2
    return totalError/float(len(points))
def step_gradient(b_current,w_current,points,learningRate):
    b_gradient=0
    w_gradient=0
    N=float(len(points))
    for i in range(0,len(points)):
        x=points[i,0]
        y=points[i,1]
        b_gradient+=-(2/N)*(y-((w_current*x)+b_current))
        w_gradient+=-(2/N)*x*(y-((w_current*x)+b_current))
    new_b=b_current-(learningRate*b_gradient)
    new_w=w_current-(learningRate*w_gradient)
    return [new_b,new_w]
def gradient_descent_runner(points,starting_b,starting_w,learning_rate,num_iterations):
    b=starting_b
    w=starting_w
    for i in range(num_iterations):
        b,w=step_gradient(b,w,np.array(points),learning_rate)
    return [b,w]
def run():
    points=np.genfromtxt('data.csv',delimiter=',')
    learning_rate=0.001
    initial_b=0
    initial_w=0
    num_iterations=1000
    print('Starting gradient descent at b={0},m={1},error={2}'.format(initial_b,initial_w,compute_error_for_line_given_points(initial_b,initial_w,points)))
    print('Running')
    [b,w]=gradient_descent_runner(points,initial_b,initial_w,learning_rate,num_iterations)
    print('After{0} iterations b={1},w={2},error={3}'.format(num_iterations,b,w,compute_error_for_line_given_points(b,w,points)))
if __name__ =='__main__':
    run()

　　

2.pytorch入门基础操作

#1.创建tensor
import torch 
import numpy as np


t1=torch.Tensor([1,2,3])#t1:tensor([1., 2., 3.])

array1=np.arange(12).reshape(3,4)

array1

torch.Tensor(array1)#将array换成tensor

torch.empty([3,4])#3行4列很大或者很小的随机数
torch.ones([3,4])#3行4列全为1
torch.zeros([3,4])#3行4列全为0
torch.rand([3,4])#3行4列随机值，在区间【0，1】
torch.randint(low=0,high=10,size=([3,4]))#3行4列随机整数，在区间【low，high】
t3=torch.randn([3,4])#3行4列随机值，均值，方差1，即服从正态分布

#2.tensor方法与属性
t1=torch.Tensor([[[1]]])
t1
t1.item()#当tensor中只有1个元素时，可以用item方法获取元素值

t2=torch.Tensor([[[1,2]]])
t=t2.numpy()#array([[[1., 2.]]], dtype=float32),numpy方法可以将tensor转化成array形式
tt=torch.from_numpy(t)#将numpy转换成tensor

t2.shape#shape属性
t2.size()#size方法可以获取属性，也可以获取某一维度的形状
t2.size(2)

t3.view(4,3)#view方法可以改变tensor维度，numpy中使用reshape是一种浅拷贝

t1.dim()#获取维度

t3.max()#最大值
t3.min()
t3.std()#标准差
t3.t()#转置
t4=torch.Tensor(np.arange(24).reshape(2,3,4))#制造3维度数据
t4.size()#torch.Size([2, 3, 4])
t4.transpose(0,1)#将第0维度和第1维度交换》》（3，2，4）
t4.permute(2,1,0)#换维度》》（4，3，2）

t4.dtype#torch.float32，默认是float32
torch.tensor([2,3],dtype=torch.float32)#设置数值类型tensor([2., 3.])
#数值类型转换
t4.type(torch.float)
t3.double()

　3.numpy 实现两层神经网络

#numpy 实现两层神经网络

N,D_in,H,D_out=64,1000,100,10#定义输入有64个数据，每个数据1000维，中间层100神经元，输出10维度
x=np.random.randn(N,D_in)#生成数据
y=np.random.randn(N,D_out)
w1=np.random.randn(D_in,H)
w2=np.random.randn(H,D_out)
learning_rate=1e-6
for it in range(200):
    h=x.dot(w1)#前向传输
    h_relu=np.maximum(h,0)#relu激活
    y_pred=h_relu.dot(w2)
    loss=np.square(y_pred-y).sum()#求loss
    print(it,loss)
    grad_y_pred=2.0*(y_pred-y)#反向传播求导
    grad_w2=h_relu.T.dot(grad_y_pred)
    grad_h_relu=grad_y_pred.dot(w2.T)
    gard_h=grad_h_relu.copy()
    grad_h[h<0]=0
    grad_w1=x.T.dot(grad_h)
    #更新参数
    w1-=learning_rate*grad_w1
    w2-=learning_rate*grad_w2

　　

　　

 4.Torch 实现两层神经网络

N,D_in,H,D_out=64,1000,100,10#定义输入有64个数据，每个数据1000维，中间层100神经元，输出10维度
x=torch.randn(N,D_in)#生成数据
y=torch.randn(N,D_out)
w1=torch.randn(D_in,H)
w2=torch.randn(H,D_out)
learning_rate=1e-6
for it in range(200):
    h=x.mm(w1)#前向传输
    h_relu=h.clamp(min=0)#relu激活
    y_pred=h_relu.mm(w2)
    loss=(y_pred-y).pow(2).sum().item()#求loss
    print(it,loss)
    grad_y_pred=2.0*(y_pred-y)#反向传播求导
    grad_w2=h_relu.t().mm(grad_y_pred)
    grad_h_relu=grad_y_pred.mm(w2.t())
    grad_h=grad_h_relu.clone()
    grad_h[h<0]=0
    grad_w1=x.T.mm(grad_h)
    #更新参数
    w1-=learning_rate*grad_w1
    w2-=learning_rate*grad_w2

#torch求grad
x=torch.tensor(1.,requires_grad=True)
w=torch.tensor(2.,requires_grad=True)
b=torch.tensor(3.,requires_grad=True)
y=w*x+b
y.backward()
print(x.grad)#tensor(2.)
print(w.grad)#tensor(1.)
print(b.grad)#tensor(1.)

 

　　`

import torch
import numpy as np

#tensor》》》ndarray
a=torch.ones(5)
b=a.numpy()
b#array([1., 1., 1., 1., 1.], dtype=float32)

#ndarray>>>tensor
a=np.ones(5)
b=torch.from_numpy(a)
b#tensor([1., 1., 1., 1., 1.], dtype=torch.float64)

#手动定义求导
x=torch.randn(3,4,requires_grad=True)#方法1
x

x=torch.randn(3,4)
x.requires_grad=True#方法2
x

#求和
b=torch.randn(3,4,requires_grad=True)
t=x+b#两个矩阵相加
y=t.sum()#矩阵内元素相加
y


y.backward()#从y开始反向传播

b.grad#y对b求导

x.requires_grad,b.requires_grad,t.requires_grad#(True, True, True)

　　

#小计算
x=torch.rand(1)
b=torch.rand(1,requires_grad=True)
w=torch.rand(1,requires_grad=True)
y=w*x
z=y+b#z=wx+b
x.requires_grad,b.requires_grad,w.requires_grad,y.requires_grad#(False, True, True, True)

x.is_leaf,w.is_leaf,b.is_leaf,y.is_leaf,z.is_leaf#是否是叶子节点，即自变量(True, True, True, False, False)

z.backward(retain_graph=True)#不清空会把之前的导数值再累加进来
w.grad

b.grad

　　

#线性回归模型
x_values=[i for i in range(11)]
x_train=np.array(x_values,dtype=np.float32)
x_train=x_train.reshape(-1,1)
x_train.shape#(11, 1)，ndarray

y_values=[2*i+1 for i in x_values]
y_train=np.array(y_values,dtype=np.float32)
y_train=y_train.reshape(-1,1)
y_train.shape#(11, 1)

import torch.nn as nn
class LinearRegressionModel(nn.Module):
    def __init__(self,input_dim,output_dim):
        super(LinearRegressionModel,self).__init__()
        self.linear=nn.Linear(input_dim,output_dim)
    def forward(self,x):
        out=self.linear(x)
        return out
input_dim=1
output_dim=1
model=LinearRegressionModel(input_dim,output_dim)
model#LinearRegressionModel(  (linear): Linear(in_features=1, out_features=1, bias=True))
epochs=1000
learning_rate=0.01
optimizer=torch.optim.SGD(model.parameters(),lr=learning_rate)
criterion=nn.MSELoss()
for epoch in range(epochs):
    epoch+=1
    #将ndarray转换成tensor
    inputs=torch.from_numpy(x_train)
    labels=torch.from_numpy(y_train)
    #梯度每次迭代要清零
    optimizer.zero_grad()
    #前向传播
    outputs=model(inputs)
    #计算损失
    loss=criterion(outputs,labels)
    #反向传播
    loss.backward()
    #更新权重参数
    optimizer.step()
    if epoch%50==0:
        print('epoch{},loss{}'.format(epoch,loss.item()))
#预测
predicted=model(torch.from_numpy(x_train).requires_grad_()).data.numpy()

#模型的报讯与读取
torch.save(model.state_dict(),'model.pkl')

model.load_state_dict(torch.load('model.pkl'))