【无标题】

动手学深度学习-pytorch简记

线性网络

线性回归简单实现

# import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l
import matplotlib.pyplot as plt
import pylab
# 生成数据集，使用既定的w，b，人工生成
true_w = torch.tensor([2,-3.4])
true_b = 4.2
# X = torch.normal(0, 0.01, (weidu1,weidu2)), y = torch.matmul(X,w)+b, y += torch.normal(0, 0.01, y.shape)
features, labels = d2l.synthetic_data(true_w, true_b, 1000)

# 读取数据集
def load_dataset(data_array, batch_size, is_train = True):
    dataset = data.TensorDataset(*data_array)
    return data.DataLoader(dataset, batch_size, is_train)
batch_size = 10
data_iter = load_dataset((features,labels), batch_size)
# 定义模型，整个算法模型，拟合公式
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)

# 定义损失函数，利用损失函数，求的梯度
loss = nn.MSELoss()

# 定义优化算法,优化算法的目的是迭代更新参数，使得参数拟合至接近真实值
trainer = torch.optim.SGD(net.parameters(), lr= 0.03)

# 训练模型
num_epoachs = 10
epoaches = []
lo = []
for epoach in range(num_epoachs):
    for X, y in data_iter:
        l = loss(net(X), y)
        # 如果不清除梯度，梯度就会累加，原先的梯度+新的梯度
        trainer.zero_grad()
        l.backward()
        # step()作用是，表示优化器对参数进行一次更新
        trainer.step()
    l = loss(net(features), labels)
    epoaches.append(epoach+1)
    lo.append(l)
    print(f'epoach: {epoach+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)
# 绘制图像
d2l.set_figsize((6.5,4.5))
e = torch.tensor(epoaches)
m = torch.tensor(lo)
print(e, m)
d2l.plt.plot(e.detach().numpy(), m.detach().numpy())
plt.show()

图像分类

# 图像分类数据集
import matplotlib
import matplotlib.pyplot as plt
import torch
import torchvision
from torch.utils import data
# 使用torchvision里面的transformers
from torchvision import transforms
from d2l import torch as d2l
# d2l使用这种可以更加清晰的图片
d2l.use_svg_display()

# 读取数据集
# 通过ToTensor实例将PIL类型转换成32位浮点数格式
# 并除以255使得所有像素的数值均在0～1之间
trans = transforms.ToTensor()
mnist_train = torchvision.datasets.FashionMNIST(
    root="../data", train=True, transform=trans, download=False)
mnist_test = torchvision.datasets.FashionMNIST(
    root="../data", train=False, transform=trans, download=False)

# 数据集包含10个类别，函数用于数字标签索引及其文本名称之间进行转换
def get_fashion_mnist_labels(labels): #@save
    text_lables = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat',
                   'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
    return [text_lables[int(i)] for i in labels]
# 可视化样本,imgs是数据集，axes其实是整个画布分成rows*cols个子画面
# 可视化样本，其实就是绘制图像，但是并没有显示图像
def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5): #@save
    # 先进行子图划分
    # 子图像大小
    figsize = (num_cols * scale, num_rows * scale)
    # 使用的是subplots，返回的是figures，ax。figures是划分的子画布，ax是子图对象的数组
    _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)
    # 将axes数组从二维变成一维的
    axes = axes.flatten()
    # 子图绘制
    # imgs是数据集里面的图片，ax是子图对象
    # i是顺序读取的数字，ax是单个子图对象，img是单个图片。for循环将batchsize的图片绘制
    for i, (ax, img) in enumerate(zip(axes, imgs)):
        # imshow()绘制图像
        if torch.is_tensor(img):
            # ax子图对象绘制img图像
            ax.imshow(img.numpy())
        else:
            ax.imshow(img)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
        if titles:
            ax.set_title(titles[i])
    return axes
# 展示数据集第一批量的图片
X, y =next(iter(data.DataLoader(mnist_train, batch_size = 18)))
show_images(X.reshape(18, 28, 28), 2, 9, titles=get_fashion_mnist_labels(y))
# 展示图片
plt.show()
# 读取小批量数据所用的时间
batch_size = 256

def get_dataloader_workers():  #@save
    """使用4个进程来读取数据"""
    return 4
train_iter = data.DataLoader(mnist_train, batch_size, shuffle=True,
                             num_workers=get_dataloader_workers())
timer = d2l.Timer()
for X, y in train_iter:
    continue
print(f'{timer.stop():.2f} sec')

# 整合所有组件，这很像是原先写过的一些深度学习算法，将数据读取、数据处理、模型放在不同的文件中，主文件整合所有的执行文件
# 就是加载数据集，并打包
def load_data_fashion_mnist(batch_size, resize=None):  #@save
    """下载Fashion-MNIST数据集，然后将其加载到内存中"""
    trans = [transforms.ToTensor()]
    if resize:
        trans.insert(0, transforms.Resize(resize))
    trans = transforms.Compose(trans)
    mnist_train = torchvision.datasets.FashionMNIST(
        root="../data", train=True, transform=trans, download=False)
    mnist_test = torchvision.datasets.FashionMNIST(
        root="../data", train=False, transform=trans, download=False)
    return (data.DataLoader(mnist_train, batch_size, shuffle=True,
                            num_workers=get_dataloader_workers()),
            data.DataLoader(mnist_test, batch_size, shuffle=False,
                            num_workers=get_dataloader_workers()))

train_iter, test_iter = load_data_fashion_mnist(32, resize=64)
for X, y in train_iter:
    print(X.shape, X.dtype, y.shape, y.dtype)
    break

仅此以记录自己复写书籍代码时的理解并加以注释！

https://zh.d2l.ai/
感谢开源，以及各位大佬们的贡献！