【动手学深度学习Pytorch】1. 线性回归代码

零实现

        导入所需要的包：

# %matplotlib inline
import random
import torch
from d2l import torch as d2l
import matplotlib.pyplot as plt
import matplotlib
import os

        构造人造数据集：假设w=[2, -3.4]，b=4.2，存在随机噪音（均值为0，方差为0.001的正态分布噪声），函数拟合为。在构造数据集的过程中，首先X为正态分布（均值为0，方差为1，样本数/行数为num_examples，列数为len(w)）

torch.normal(mean, std, *, generator=None, out=None)：生成指定输出尺寸的正态分布随机数张量

torch.mv()：矩阵和向量的乘积，此处X为矩阵，w为向量

def synthetic_data(w, b, num_examples):
    X = torch.normal(0, 1, (num_examples, len(w))) #均值为0方差为1的随机数,样本数,列数
    y = torch.mv(X, w) + b #y关于x的公式
    y += torch.normal(0, 0.001, y.shape) # 加入噪声项
    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)

        查看数据集样本分布：

matplotlib.pyplot.scatter(x, y, s=None, c=None, marker=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, *, edgecolors=None, plotnonfinite=False, data=None, **kwargs):

        x，y：长度相同的数组，也就是我们即将绘制散点图的数据点，输入数据。

        s：点的大小，默认 20，也可以是个数组，数组每个参数为对应点的大小。

        c：点的颜色，默认蓝色 'b'，也可以是个 RGB 或 RGBA 二维行数组。

        marker：点的样式，默认小圆圈 'o'。

        cmap：Colormap，默认 None，标量或者是一个 colormap 的名字，只有 c 是一个浮点数数组的时才使用。如果没有申明就是 image.cmap。

        norm：Normalize，默认 None，数据亮度在 0-1 之间，只有 c 是一个浮点数的数组的时才使用。

        vmin，vmax：亮度设置，在 norm 参数存在时会忽略。

        alpha：透明度设置，0-1 之间，默认 None，即不透明。

        linewidths：标记点的长度。

        edgecolors：颜色或颜色序列，默认为 'face'，可选值有 'face', 'none', None。

        plotnonfinite：布尔值，设置是否使用非限定的 c ( inf, -inf 或 nan) 绘制点。

        **kwargs：其他参数。

detach()：允许我们从计算图中分离出张量。当对一个张量调用detach()方法时，它会创建一个新的张量，这个新张量与原始张量共享数据，但它不再参与计算图的任何操作，对分离后的张量进行的任何操作都不会影响原始张量，也不会在计算图中留下任何痕迹。

plt.scatter(features[:,(1)].detach().numpy(),labels.detach().numpy(),1);
plt.show()

        遍历数据集，输出数据集内容：

len(): 返回对象（字符、列表、元组等）长度或项目个数（此处是张量的行数）

list(): 将元组转换为列表

range()：创建一个整数列表

shuffle(): 随机打乱列表

def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples)) #生成样本索引
    random.shuffle(indices) #样本随机读取没有特定顺序
    # 进行batch划分
    for i in range(0, num_examples, batch_size): #从i开始到i+batchsize
        batch_indices =  torch.tensor(indices[i:min(i + batch_size, num_examples)])
        # 截取切片：开始位置为i，结束位置为min函数的返回值
        # 返回值为i+batch_size和num_examples的值比较小的那个
        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

      定义参数、模型、损失函数以及优化算法：

torch.mutual()：矩阵相乘

with torch.no_grad()：所有计算得出的tensor的requires_grad都自动设置为False，不会进行自动求导

grad.zero_()：将梯度置零（不然会发生累计的情况）

# 定义初始化模型参数
w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)
# 定义模型
def linreg(X, w, b):
    return torch.matmul(X, w) + b
# 定义损失函数
def squared_loss(y_hat, y):
    return (y_hat - y.reshape(y_hat.shape))**2/2
# 定义优化算法
def sgd(params, lr, batch_size):
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad / batch_size
            param.grad.zero_()

        定义训练过程：

# 训练过程
lr = 0.01
num_epochs = 10
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)
        l.sum().backward()
        sgd([w,b], lr, batch_size)
    with torch.no_grad():
        train_1= loss(net(features, w, b), labels)
        print(f'epoch{epoch + 1}, loss{float(train_1.mean()):f}')

简介实现

        导入所需要的包：

import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l
import matplotlib.pyplot as plt

        创建人造数据集：

data.TensorDataset()：将数据进行封装

data.DataLoader()：将数据分批次处理

iter()：获取列表的迭代器

next()：获取下一个值

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):
    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))

初始化模型、模型参数、loss： 

nn.Sequential()：实现模型层结构的简单排序

torch.optim.SGD()：定义优化算法

torch.optim.SGD().step()：进行模型的更新

# 使用框架的预定义好的层
from torch import nn
net = nn.Sequential(nn.Linear(2,1))
# 初始化模型参数
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)
# 计算均方误差使用的是MSELoss类
loss = nn.MSELoss()
trainer = torch.optim.SGD(net.parameters(),lr=0.01)

        定义训练过程：

num_epochs = 3
for epoch in range(num_epochs):
    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{1:f}')