动手学深度学习（0-3章）代码

 我们将本书中经常导⼊和引⽤的函数、类等封装在d2l包中。

import collections #提供有关集合的操作
import hashlib #提供字符串加密的功能
import math
import os #处理文件和目录
import random
import re #正则表达式
import shutil #复制、移动、删除、压缩、解压文件
import sys #与python解释器交互的一个接口
import tarfile #压缩
import zipfile #解压
import time
from collections import defaultdict #当字典里的元素不存在但被查找时，返回一个默认值
import pandas as pd #利用series和dataframe进行数据处理
import requests #解码来自服务器的响应
from IPython import display #显示图片
from matplotlib import pyplot as plt #绘图
from matplotlib_inline import backend_inline #

d2l = sys.modules[__name__]

从 PyTorch 导⼊模块。

import numpy as np
import torch
import torchvision
from PIL import Image
from torch import nn
from torch.nn import functional as F
from torch.utils import data
from torchvision import transforms

import random
import torch
from d2l import torch as d2l

def synthetic_data(w, b, num_examples):
    X = torch.normal(0, 1, (num_examples, len(w))) #均值为0，方差为1，大小为n个样本，列数为w的长度
    y = torch.matmul(X, w) + b #y = Xw + b
    y += torch.normal(0, 0.01, y.shape) #均值为0，方差为0.1（标准差为0.01），形状和y相同，y = Xw + b + 噪声
    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)
d2l.plt.show()

import random
import torch
from d2l import torch as d2l

def synthetic_data(w, b, num_examples):
    X = torch.normal(0, 1, (num_examples, len(w)))
    y = torch.matmul(X, w) + b
    y += torch.normal(0, 0.01, 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)

print('features:',features[0],'\nlabel:',labels[0])

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

def data_iter(batch_size,features,labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    random.shuffle(indices)
    for i in range(0,num_examples,batch_size):
        batch_indices = torch.tensor(indices[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

import random
import torch
from d2l import torch as d2l

def synthetic_data(w, b, num_examples):
    X = torch.normal(0, 1, (num_examples, len(w))) #均值为0，方差为1，大小为n个样本，列数为w的长度
    y = torch.matmul(X, w) + b #y = Xw + b
    y += torch.normal(0, 0.01, y.shape) #均值为0，方差为0.1（标准差为0.01），形状和y相同，y = Xw + b + 噪声
    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)
d2l.plt.show()

def data_iter(batch_size,features,labels):
    num_examples = len(features)
    indices = list(range(num_examples)) #生成样本的index
    random.shuffle(indices) #打乱
    for i in range(0,num_examples,batch_size):
        batch_indices = torch.tensor(indices[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

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 squard_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.03
num_epochs = 3
net = linreg
loss = squard_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}')

print(f'w的误差估计：{true_w - w.reshape(true_w.shape)}')
print(f'b的误差估计：{true_b - b}')

线性回归的简洁实现

import torch
from torch import nn
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_array,batch_size,is_train = True):
    dataset = data.TensorDataset(*data_array)
    return data.DataLoader(dataset,batch_size,shuffle = is_train)

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

print(next(iter(data_iter))[0])
print(next(iter(data_iter))[0])

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_epochs = 3
for epoch in range(num_epochs):
    for X,y in data_iter:
        l = loss(net(X),y) #前向传播
        trainer.zero_grad() #梯度置0
        l.backward() #计算梯度
        trainer.step() #模型更新
    l = loss(net(features),labels)
    print(f'epoch{epoch + 1},loss{l:f}')

图像分类数据集

import torch
import torchvision
from torch.utils import data
from torchvision import transforms
from d2l import torch as d2l

d2l.use_svg_display()
trans = transforms.ToTensor() #转为tensor

mnist_train = torchvision.datasets.FashionMNIST(root = "../Data",train = True,transform = trans,download = True)
mnist_test = torchvision.datasets.FashionMNIST(root = "../Data",train = False,transform = trans,download = True)

print(len(mnist_train))
print(len(mnist_test))

print(mnist_train[0][0].shape)

def get_fashion_mnist_labels(labels):
    text_labels = ['t-shirt','trouser','pullover','dress','coat','sandal','shirt','sneaker','bag','ankle boot']
    return [text_labels[int(i)] for i in labels]

def show_images(imgs,num_rows,num_cols,titles = None,scale = 1.5):
    figsize = (num_cols * scale,num_rows * scale)
    _,axes = d2l.plt.subplots(num_rows,num_cols,figsize = figsize)
    axes = axes.flatten()
    for i,(ax,img) in enumerate(zip(axes,imgs)):
        if torch.is_tensor(img):
            ax.imshow(img.numpy(),'gray')
            """"""
            ax.axis('off')
            ax.set_title(titles[i])
        else:
            ax.imshow(img)
    d2l.plt.show()

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

batch_size = 256

def get_dataloader_workers():
    return 4 #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):
    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 = True)
    mnist_test = torchvision.datasets.FashionMNIST(root = "../Data",train = False,transform = trans,download = True)
    return (data.DataLoader(mnist_train,batch_size,shuffle = True,num_workers = get_dataloader_workers()),
            data.DataLoader(mnist_test,batch_size,shuffle = True,num_workers = get_dataloader_workers()))

softmax回归的从0开始实现

import torch
from IPython import display
from d2l import torch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

num_inputs = 784
num_outputs = 10
W = torch.normal(0,0.01,size=(num_inputs, num_outputs),requires_grad=True)
b = torch.zeros(num_outputs,requires_grad=True)

def softmax(X):
    X_exp = torch.exp(X)
    partition = X_exp.sum(1, keepdim=True)  # 输入的X为矩阵，所以就是对矩阵每一行做Softmax

    return X_exp / partition  

X = torch.normal(0, 1, (2, 5))
X_prob = softmax(X)
print(X_prob)
print(X_prob.sum(1))

def net(X):
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

X = torch.normal(0, 1, (2, 5))
print(X)
print(X + 1)

y = torch.tensor([0,2])
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
print(y_hat[[0, 1], y])

def cross_entropy(y_hat, y):
    return -torch.log(y_hat[range(len(y_hat)), y])  

def accuracy(y_hat, y):
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)  
    cmp = y_hat.type(y.dtype) == y  
    return  float(cmp.type(y.dtype).sum()) 

print(accuracy(y_hat, y))

class Accumulator:
    def __init__(self, n):
        self.data = [0.0] * n

    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]

    def reset(self):
        self.data = [0.0] * len(self.data)

    def __getitem__(self, idx):
        return self.data[idx]

def evaluate_accuracy(net, data_iter):
    if isinstance(net, torch.nn.Module):
        net.eval()
    metric = Accumulator(2)
    for X, y in data_iter:
        metric.add(accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]

def train_epoch_ch3(net, train_iter, loss, updater):
    if isinstance(net, torch.nn.Module):
        net.train()
    metric = Accumulator(3)
    for X, y in train_iter:
        y_hat = net(X)
        l = loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer): 
            updater.zero_grad()
            l.backward()
            updater.step()
            metric.add(float(l) * len(y), accuracy(y_hat, y), y.size().numel())
        else :
            l.sum().backward()
            updater(X.shape[0])
            metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())

    return metric[0] / metric[2] , metric[1] / metric[2]

class Animator:
    def __init__(self, xlabel=None, ylabel=None, legend=None, xlim=None,
                 ylim=None, xscale='linear', yscale='linear',
                 fmts=('-', 'm--', 'g-.', 'r:'), nrows=1, ncols=1,
                 figsize=(3.5, 2.5)):

        if legend is None:
            legend = []
        d2l.use_svg_display()
        self.fig, self.axes = d2l.plt.subplots(nrows, ncols, figsize=figsize)
        if nrows * ncols == 1:
            self.axes = [self.axes, ]

        self.config_axes = lambda: d2l.set_axes(
            self.axes[0], xlabel, ylabel, xlim, ylim, xscale, yscale, legend)
        self.X, self.Y, self.fmts = None, None, fmts

    def add(self, x, y):
        if not hasattr(y, "__len__"):
            y = [y]
        n = len(y)
        if not hasattr(x, "__len__"):
            x = [x] * n
        if not self.X:
            self.X = [[] for _ in range(n)]
        if not self.Y:
            self.Y = [[] for _ in range(n)]
        for i, (a, b) in enumerate(zip(x, y)):
            if a is not None and b is not None:
                self.X[i].append(a)
                self.Y[i].append(b)
        self.axes[0].cla()
        for x, y, fmt in zip(self.X, self.Y, self.fmts):
            self.axes[0].plot(x, y, fmt)
        self.config_axes()
        display.display(self.fig)
        display.clear_output(wait=True)

def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])
    for epoch in range(num_epochs):
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        test_acc = evaluate_accuracy(net, test_iter)
        animator.add(epoch + 1, train_metrics + (test_acc,))
    d2l.plt.show()  
    train_loss, train_acc = train_metrics

lr = 0.1

def updater(batch_size):
    return d2l.sgd([W, b], lr, batch_size)

num_epoch = 10
train_ch3(net, train_iter, test_iter, cross_entropy, num_epoch, updater)

def predict_ch3(net, test_iter, n=6):
    for X, y in test_iter:
        break
    trues = d2l.get_fashion_mnist_labels(y)
    preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))
    titles = [true + '\n' +pred for true, pred in zip(trues, preds)]
    d2l.show_images(X[0:n].reshape((n, 28, 28)), 1, n, titles=titles[0:n])
    d2l.plt.show()

predict_ch3(net, test_iter)

 

 

softmax的简洁实现