零实现

        导入所需要的包：

# %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+batchsizebatch_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 = 10for 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_sizeparam.grad.zero_()

        定义训练过程：

# 训练过程
lr = 0.01
num_epochs = 10
net = linreg
loss = squared_lossfor 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}')