零实现
导入所需要的包：
# %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}')
