pytorch教程龙曲良01-05

01深度学习框架与介绍

pytorch优势
1使用gpu加速

# -*- codeing = utf-8 -*-
# @Time :2021/5/6 20:51
# @Author:sueong
# @File:grad.py
# @Software:PyCharm
import torch
import time
print(torch.__version__)
print(torch.cuda.is_available())

a=torch.randn(10000,1000)#a矩阵
b=torch.randn(1000,2000)
#cpu运算
t0=time.time()
c=torch.matmul(a,b)
t1=time.time()
print(a.device,t1-t0,c.norm(2))
#gpu 搬到cuda
device=torch.device('cuda')
a=a.to(device)
b=b.to(device)

t0=time.time()
c=torch.matmul(a,b)
t2=time.time()
print(a.device,t2-t0,c.norm(2))


#再算一次gpu上的时间 因为第一次gpu 需要cuda初始化
t0=time.time()
c=torch.matmul(a,b)
t2=time.time()
print(a.device,t2-t0,c.norm(2))

1.7.1+cu110
True
cpu 0.4168832302093506 tensor(141016.6719)
cuda:0 4.1152663230896 tensor(141416.5000, device='cuda:0')
cuda:0 0.003988981246948242 tensor(141416.5000, device='cuda:0')
#0.004体现了pytorch使用gpu加速

2自动求导 这样可以实现对loss和w每次更新的求导

# -*- codeing = utf-8 -*-
# @Time :2021/5/6 21:45
# @Author:sueong
# @File:grad2.py
# @Software:PyCharm
import torch
from torch import autograd

#初始化x=1 a=1 b=2 c=3
x=torch.tensor(1.)
a=torch.tensor(1.,requires_grad=True)#True表示需要计算梯度
b=torch.tensor(2.,requires_grad=True)
c=torch.tensor(3.,requires_grad=True)

#函数
y=a**2*x+b*x+c

print('before:',a.grad,b.grad,c.grad)
grads=autograd.grad(y,[a,b,c])#求y分别对abc的导数
print('after:',grads[0],grads[1],grads[2])

before: None None None
after: tensor(2.) tensor(1.) tensor(1.)

02开发环境的准备

本课程环境

1anaconda安装
安装后

cmd1conda list 2conda --version

看是否安装成功
2安装cuda

cuda官网

安装后cmd

nvcc -V

检查cuda是否安装成功
如果显示nvcc不存在此命令 配置环境

3pytorch的安装

官网

管理员身份cmd 复制安装命令

03线性回归-1

x’=x-grad(x)
每次x’都是x减去对x的梯度（就是y’在x的结果） 每次将x’迭代求得取到最小值得X*，但是每次x’=x-lrgrad(x) ，lr是学习率，缩放倍数，使得迭代的次数增加效果更好，这样会使得梯度慢慢降低，

当x=5发现grad（x）=0，则x’=x-lrgrad（x）=5 所以x’还是5没变化，但是因为有grad（x）有计算误差所以x会在5附近徘徊
（之后求w和b同理也是利用梯度下降不断找到符合最小值的w和b）

如果lr比较大，x’=x-lr*grad(x)，就会使得步长比较大 x在最低点附近有大幅度的波动
一般lr设置为0.001，一般比较简单的手写数字数据集是设置的0.01，比较复杂新奇的算法探索不同的learning rate

如图是不同的求解器，对公式做不同的优化，考虑上一次的前进方向要不要和本次的保持一致，加了各种各样约束就会得到各种不同的梯度下降求解器，导致求解速度更快求解精度更快
最经常用的是adam、sgd、msprop

可以求出精确解的算式是closed form solution
但是求出精确解的很少，实际问题一般是求近似解，证明近似解在经验上可行就已经达到了目的了

噪声：均值为0.01，方差为1的高斯分布

loss：求y和y_pre=wx+b之差平方的最小值，我们希望的是真实值y和预测值y_pred接近，这样可以找到精确的w和b

04线性回归2

如图是100含有高斯噪声的样本点，我们希望找到一个模型（直线）使得点尽可能在线上，即loss=（wx+b+ε-y）^2 最小


可视化可以发现w=1，b=0的时候loss比较小，
但实际问题很难可视化，
初始化w=0，b=0，每一处对w和b进行求导，更新100次左右可以发现所求的wheb比较渡河理论值
linear regression：预测的值y是个连续的值取值范围（负无穷，正无穷）或者是某个连续的实数空间也可以
已知xi和yi ，求xn的yn，yn是连续的就成为linear regression

logistics regression在linear regression增加压缩函数（sigmod function），使得y的取值从实数范围(负无穷,正无穷)变成[0,1]，可以变成概率，适合二分类或分类问题。

05线性回归实战

loss对w，b的偏导如图，之后不断更新w和b可以套两个公式
loss对w的偏导=2（wx+b-y）*x
loss对b的偏导=2（wx+b-y）*1

# -*- codeing = utf-8 -*-
# @Time :2021/5/8 20:13
# @Author:sueong
# @File:example.py
# @Software:PyCharm
import numpy as np
#y=wx+b

#计算loss
def loss(b,w,points):
    totalloss=0
    for i in range(0,len(points)):
        x=points[i,0]
        y=points[i,1]
        totalloss+=(y-(w*x+b))**2
    return totalloss/float(len(points))


#loss对w的偏导=2（wx+b-y）*x
#loss对b的偏导=2（wx+b-y）*1
#w'=w-lr*loss对w的偏导
#b'=b-lr*loss对b的偏导
#计算b和w b和w不断求偏导取得使loss最小的值
# 其中loss对b和w的偏导，会对每个样本的偏导求和再求均值
#一轮的loss对w和b的偏导，
def step_gradient(b_current,w_current,points,lr):
    b_gradient=0
    w_gradient=0
    N=float(len(points))
    #loss对b,w初始化为0
    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-lr*b_gradient
    new_w=w_current-lr*w_gradient
    return [new_b,new_w]

#循环gradient,迭代次数
def gradient_descent_runner(points,staring_b,staring_w,lr,num_iteration):
    b=staring_b
    w=staring_w
    for i in range(num_iteration):
        b,w=step_gradient(b,w,np.array(points),lr)
    return [b,w]

#主函数
def run():
    #load dataset
    points=np.genfromtxt('data.csv',delimiter=',')#,分隔数据
    lr=0.0001
    initial_b=0#initial y-intercept guess
    initial_w=0#initial slope guess
    num_iterations=1000
    print('Staring gradient descent at b={0},w={1},error={2}'
          .format(initial_b,initial_w,loss(initial_b,initial_w,points)))
    print('Runing...')
    #跑100个epoch
    [b,w]=gradient_descent_runner(points,initial_b,initial_w,lr,num_iterations)
    print('After {0} iteration b={1},w={2},error={3}'
          .format(num_iterations,b,w,loss(b,w,points)))

if __name__=='__main__':
    run()

Staring gradient descent at b=0,w=0,error=5565.107834483211
Runing...
After 1000 iteration b=0.08893651993741346,w=1.4777440851894448,error=112.61481011613473