3.2线性回归的从零实现

%matplotlib inline
import random
import torch
from d2l import torch as d2l

#人工生成数据集
def synthetic_data(w, b, num_examples):  #@save
    """生成y=Xw+b+噪声"""
    #正太分布
    X = torch.normal(0, 1, (num_examples, len(w)))
    y = torch.matmul(X, w) + b
    #噪声
    y += torch.normal(0, 0.01, y.shape)
    #将x，y 
    return X, y.reshape((-1, 1))

true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)
print('features:', features[0],'\nlabel:', labels[0])
d2l.set_figsize()
d2l.plt.scatter(features[:, 1].detach().numpy(),
               labels.detach().numpy(), 1);
#             批量大小，   特征      标号
def data_iter(batch_size, features, labels):
    #创建特征的向量
    num_examples = len(features)
    #生成对每个样本的indices 从0到n-1
    indices = list(range(num_examples))
    #将下标完全打乱
    random.shuffle(indices)
    #          从0开始到num_examples,每次跳batch_size的位置
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(
            #从第i个到i+batch_size个
            indices[i: min(i + batch_size, num_examples)])
        #yield 一直返回下述的两个
        yield features[batch_indices], labels[batch_indices]
batch_size = 10

for X, y in data_iter(batch_size, features, labels):
    print(X, '\n', y)
    break
#数据集完成
#定义初始化模型参数
w = torch.normal(0, 0.01, size=(2, 1), requires_grad=True)
b = torch.zeros(1,requires_grad=True)

#定义模型 
def linreg(X, w, b): #@save
    """线性回归模型。"""
    return torch.matmul(X, w) + b
#定义损失函数
def  squared_loss(y_hat, y): #@save
    """均方损失。"""
    return (y_hat - y.reshape(y_hat.shape))**2 / 2
#定义损失函数
def  squared_loss(y_hat, y): #@save
    """均方损失。"""
    return (y_hat - y.reshape(y_hat.shape))**2 / 2
#超参数的设置
lr = 0.03
#把数据扫3遍
num_epochs = 3
net = linreg
#均方损失
loss = squared_loss

for epoch in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y)  # X和y的小批量损失
        # 因为l形状是(batch_size,1)，而不是一个标量。l中的所有元素被加到一起，
        # 并以此计算关于[w,b]的梯度
        l.sum().backward()
        sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数
    with torch.no_grad():
        train_l = loss(net(features, w, b), labels)
        print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')
print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')

上面是代码的实现这些东西在书里都有，我主要是把练习题记录一下。

1.   如果我们将权重初始化为零，会发生什么。算法仍然有效吗？    
   我们把w的初始化改为0会发现他依然有效. 为什么？

   #数据集完成
   #定义初始化模型参数
   w = torch.zeros((2, 1) ,requires_grad=True)
   b = torch.zeros(1,requires_grad=True)

        5.为什么在squared_loss函数中需要使用reshape函数？

        防止一个是列是个是行

简单实现线形回归

#线性回归的简洁实现
import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l


true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)

def load_array(data_arrays, batch_size, is_train=True):  #@save
    """构造一个PyTorch数据迭代器"""
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset, batch_size, shuffle=is_train)

batch_size = 10
data_iter = load_array((features, labels), batch_size)

next(iter(data_iter))

from torch import nn
#第一个指定输入特征形状，即2，第二个指定输出特征形状，
#输出特征形状为单个标量，因此为1
net = nn.Sequential(nn.Linear(2, 1))

#设置初始权重的值和
#偏差的值
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)

#定义损失函数
loss = nn.MSELoss()

#小批量随机梯度下降算法
trainer = torch.optim.SGD(net.parameters(), lr=0.03)

#训练过程
num_eprochs = 3
for epoch in range(num_eprochs):
    for X, y in data_iter:
        l = loss(net(X) ,y)
        #梯度归零
        trainer.zero_grad()
        #反向传播得到梯度
        l.backward()
        #参数更新优化
        trainer.step()
    l = loss(net(features), labels)
    print(f'epoch {epoch + 1}, loss {l:f}')

w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)

1. 如果将小批量的总损失替换为小批量损失的平均值，你需要如何更改学习率？                         对于我们的梯度下降，

    当我们的损失替换为平均值也就是除以10（代码中的batch_size = 10）我们可以将学习率除以十。

2. 查看深度学习框架文档，它们提供了哪些损失函数和初始化方法？用Huber损失代替原损失，即

   

3. 你如何访问线性回归的梯度？

笔记：

1.batchsize越小越好，大了不行。随机梯度下降从理论上来说其实是带来了噪音，因为小样本可能会带来噪音。但是为什么又说是好呢，因为你大了对于深度的神经网络来说会让你过拟合。而有点噪音可以防止你过拟合。

2.理论上学习率和批次是不会影响你的收敛结果，实际上没有那么影响。

3.detach()停止求梯度