Tensor

import torch as t
%matplotlib inline #内嵌画图
from matplotlib import pyplot as plt
from IPython import display

t.manual_seed(1000)

def get_fake_data(batch_size=8):
    '''产生随机数据，y=x*2+3,加上了一些噪音'''
    x=t.rand(batch_size,1)*20
    y=x*2+(1+t.randn(batch_size,1))*3
    return x,y

x,y=get_fake_data()
plt.scatter(x.squeeze().numpy(),y.squeeze().numpy()) 
#scatter必须用numpy

<matplotlib.collections.PathCollection at 0x12d6aea47c0>

#随机初始化参数
w=t.rand(1,1)
b=t.zeros(1,1)
lr=0.001 #学习率

for ii in range(20000):
    x,y=get_fake_data()
    
    y_pred=x.mm(w)+b.expand_as(y)
    loss=0.5*(y_pred-y)**2 #均方误差
    loss=loss.sum()
    
    #手动计算梯度
    dloss=1
    dy_pred=dloss*(y_pred-y)
    
    dw=x.t().mm(dy_pred)
    db=dy_pred.sum()
    
    #更新参数
    w.sub_(lr*dw)
    b.sub_(lr*db)
    
    if ii%1000==0:

        #画图
        display.clear_output(wait=True)
        x=t.arange(0,20).view(-1,1) #arange返回整型numpy
        y=x.float().mm(w)+b.expand_as(x)
        plt.plot(x.numpy(),y.numpy()) #predicted
        
        x2,y2=get_fake_data(batch_size=20)
        plt.scatter(x2.numpy(),y2.numpy()) #true data
        
        plt.xlim(0,20)
        plt.ylim(0,41)
        plt.show()
        plt.pause(0.5)
        
print(w.squeeze(),b.squeeze()) #压缩
        

tensor(2.1227) tensor(2.9495)

Variable 

import torch as t
from torch.autograd import Variable as V
%matplotlib inline
from matplotlib import pyplot as plt
from IPython import display
t.manual_seed(1000)

def get_fake_data(batch_size=8):
    '''产生随机数据y=2*x+3,产生一些噪音'''
    x=t.rand(batch_size,1)*20
    y=x*2+(1+t.randn(batch_size,1))*3
    return x,y

x,y=get_fake_data()
plt.scatter(x.squeeze().numpy(),y.squeeze().numpy())

<matplotlib.collections.PathCollection at 0x12d6aea47c0>

w=V(t.rand(1,1),requires_grad=True)
b=V(t.zeros(1,1),requires_grad=True)
lr=0.001

for ii in range(8000):
    x,y=get_fake_data()
    x,y=V(x),V(y)
    y_pred=x.mm(w)+b.expand_as(y)
    loss=0.5*(y_pred-y)**2
    loss=loss.sum()
    
    loss.backward() #backward函数的输入值和返回值是variable
    
    w.data.sub_(lr*w.grad.data)
    b.data.sub_(lr*b.grad.data)
    
    w.grad.data.zero_() #每次反向传播前要将梯度清0
    b.grad.data.zero_()
    
    if ii %1000==0:
        display.clear_output(wait=True)
        x=t.arange(0,20).view(-1,1) #t.arange产生的是整形numpy
        y=x.float().mm(w.data)+b.data.expand_as(x)
        plt.plot(x.numpy(),y.numpy()) #predicted
        
        x2,y2=get_fake_data(batch_size=20)
        plt.scatter(x2.numpy(),y2.numpy()) #true data
        
        plt.xlim(0,20)
        plt.ylim(0,41)
        plt.show()
        plt.pause(0.5)
        
print(w.data.squeeze(),b.squeeze())
        

 

tensor(1.9790) tensor(3.0168, grad_fn=<SqueezeBackward0>)

2022/7/15