PyTorch框架，深度学习的主流选择
1.线性回归的简洁实现 用tpyorch实现线性回归 2.图片分类数据集 整合函数功能： 3.sofemax的实现 实现 创建一个 …
1.线性回归的简洁实现
用tpyorch实现线性回归
import torch
import numpy as np
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_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))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_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{l:f}')
2.图片分类数据集
%matplotlib inline
import torch
import torchvision
from torch.utils import data
from torchvision import transforms
from d2l import torch as d2l
d2l.use_svg_display()
mnist_train[0][0].shape
def get_fashion_mnist_labels(labels):
"""返回Fashion-MNIST数据集的文本标签"""
text_labels = [
't_skirt','trouser','pullover','dress','coat','sandal','shirt',
'snearker','bag','ankle boot']
return [text_labels[int(i)] for i in labels]
#@tab pytorch
def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5): #@save
"""绘制图像列表"""
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())
else:
# PIL图片
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))
batch_size = 256
def get_dataloader_workers(): #@save
"""使用4个进程来读取数据"""
return 0
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
f'{timer.stop():.2f} sec'
设置了一个时间函数
'4.42 sec'整合函数功能：
#@tab pytorch
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=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=False,
num_workers=get_dataloader_workers()))3.sofemax的实现
from d2l import torch as d2l
import torch
from IPython import display
batch_size = 256
train_iter,test_iter =d2l.load_data_fashion_mnist(batch_size)
num_inputs = 784#softmax输入要求一个向量，所以展平 28*28
num_outputs = 10#10个label
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)
return x_exp/partition #这里应用了广播机制实现
def nex(x):
return softmax(torch.matmul(x.reshape((-1,w.shape[0])),w)+b)创建一个数据y_hat，其中包含2个样本在3个类别的预测概率，使用y作为y_hat中概率的索引
y = torch.tensor([0,2])
y_hat = torch.tensor([[0.1,0.3,0.5],[0.3,0.2,0.5]])
y_hat[[0,1],y]实现交叉熵损失函数
def cross_entropy(y_hat,y):
return -torch.log(y_hat[range(len(y_hat)),y])
cross_entropy(y_hat,y)
>
tensor([0.1000, 0.5000])将预测类别与真实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())
accuracy(y_hat,y) / len(y)输出
