网页设计模板代码免费,网站优化报表,wordpress主题设置插件,西丽网站设计文章目录 一、理论知识1.图像分类数据集2.softmax回归的从零开始实现3.Softmax简洁实现 【相关总结】torch.sum()torch.argmax()isinstance():[python] softmax回归 一、理论知识
回归估计一个连续值分类预测一个离散类别 回归单连续数值输出自然区间R跟真实值的区别作为损失 … 文章目录 一、理论知识1.图像分类数据集2.softmax回归的从零开始实现3.Softmax简洁实现 【相关总结】torch.sum()torch.argmax()isinstance():[python] softmax回归 一、理论知识
回归估计一个连续值分类预测一个离散类别 回归单连续数值输出自然区间R跟真实值的区别作为损失 分类通常多个输出输出i是预测为第i类的置信度 一般我们使用交叉熵用来衡量两个概率的区别 将它作为损失 其梯度是真实概率和预测概率的区别 其梯度是真实概率和预测概率的区别 损失函数 (1)L2 Loss (2)L1 Loss (3)Huber’s Robust Loss 优点当预测值与真实值相差较远时候梯度还是按照均匀的变化在比较靠近的时候梯度绝对值会变小保证优化比较平滑。
1.图像分类数据集
MNIST数据集是图像分类中广泛使用的数据集之一但其较为简单我们将使用Fashion-MNIST数据集 1.导入需要的包
%matplotlib inline
import torch
import torchvision
from torch.utils import data
from torchvision import transforms
from d2l import torch as d2ld2l.use_svg_display() #通过svg显示图片清晰度更高2.通过框架中的内置函数将Fashion-MNIST数据集下载并读取到内存中 Fashion-MNIST由10个类别的图像组成
# 通过ToTensor实例将图像数据从PIL类型变换成32位浮点数格式
# 并处以255使得所有像素的数值均在0到1之间
trans transforms.ToTensor()
mnist_train torchvision.datasets.FashionMNIST(root../data, trainTrue, transformtrans,downloadTrue)
mnist_test torchvision.datasets.FashionMNIST(root../data, trainFalse,transformtrans,downloadTrue)len(mnist_train), len(mnist_test)(60000, 10000)
mnist_train[0][0].shape #第0个exampletorch.Size([1, 28, 28]) 3.两个可视化数据集的函数
def get_fashion_mnist_labels(labels): 返回Fashion-MNIST数据集的文本标签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, titlesNone, scale1.5): 绘制图像列表figsize (num_cols * scale, num_rows * scale)
# 创建一个包含多个子图的图形
# 下划线表示我们对图形本身不感兴趣只关心返回的子图像_,axes d2l.plt.subplots(num_rows, num_cols, figsizefigsize)
# print(_)
# print(axes)
# print(type(axes)) #numpy
# 使用NumPy中的flatten()函数将axes数组从多维数组变成一维数组
# axes:原本是一个包含多个子图对象的二维数组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)
# 设置子图的X轴和Y轴刻度标签不可见ax.axes.get_xaxis().set_visible(False)ax.axes.get_yaxis().set_visible(False)if titles:
# print(titles)
# 给每个子图设置相应的标题ax.set_title(titles[i])return axes# iter():函数生成迭代器
# next()返回迭代器的下一个项目一般与iter()结合使用
X, y next(iter(data.DataLoader(mnist_train, batch_size18)))# 拿到第一个小批量的数据X和y标签y
# print(y)
show_images(X.reshape(18, 28, 28), 2, 9, titlesget_fashion_mnist_labels(y));
# 绘制两行图片每一行有9张图片
# titles是每张图片的标号4.读取一小批数据大小为batch_size
batch_size 256def get_dataloader_workers():使用4个进程来读取数据return 4train_iter data.DataLoader(mnist_train, batch_size, shuffleTrue,num_workers4)
# num_workers 0代表单进程而不是没有进程timer d2l.Timer() # Timer函数用于测试速度
# print(train_iter)batch next(iter(train_iter))
print(batch)# for X,y in train_iter:
# # print(train_iter)# # for X, y in train_iter:
# continue
f{timer.stop():.2f} sec # 输出读取数据所用的秒数精度为2位小数‘3.51 sec’
❗❗❗ 如果运行出现此种报错一般是由于taLoader的多进程造成的我们可以通过设置num_workers0代表单进程加载. 5.定义load_data_fashion_mnist函数 为了方便后续使用我们可以把上面的各个实现数据读取的操作写在函数中
def load_data_fashion_mnist(batch_size, resizeNone):下载Fashion-MNIST数据集然后将其加载到内存中trans [transforms.ToTensor()]if resize:trans.inserts(0, transforms.Resize(resize))trans transforms.Compose(trans)mnist_train torchvision.datasets.FashionMNIST(root../data,trainTrue,transformtrans,downloadTrue)mnist_test torchvision.datasets.FashionMNIST(root../data,trainTrue,transformtrans,downloadTrue)return (data.DataLoader(mnist_train, batch_size, shuffleTrue,num_workersget_dataloader_workers()),data.DataLoader(mnist_test, batch_size, shuffleTrue,num_workersget_dataloader_workers()))2.softmax回归的从零开始实现
1.导入相关包
import torch
from IPython import display
from d2l import torch as d2lbatch_size 256
# 返回训练数据和测试数据的迭代器
train_iter, test_iter d2l.load_data_fashion_mnist(batch_size)
2.将展平每个图像将它们视为长度为784的向量。因为数据有10个类别所以网格输出维度为
# 28*28 784
num_inputs 784
num_outputs 10W torch.normal(0, 0.01, size(num_inputs, num_outputs), requires_gradTrue)
b torch.zeros(num_outputs, requires_gradTrue)3.给定一个矩阵X,对所有元素求和
X torch.tensor([[1.0, 2.0, 3.0], [4.0,5.0,6.0]])
# 按照维度为0进行将行数变为1按照维度为1进行求和把列数变为1keepdim表示保持维度
X.sum(0, keepdimTrue), X.sum(1, keepdimTrue)(tensor([[5., 7., 9.]]),tensor([[ 6.],[15.]]))4.实现softmax
def softmax(X):X_exp torch.exp(X)
# 按行求和print(----------------X_exp------------)print(X_exp)partition X_exp.sum(1, keepdimTrue)print(-------------partition------------)print(partition)
# 运用广播机制print(----------X_exp / partition--------)print(X_exp / partition)return X_exp / partition5.将每个元素变成一个非负数依据概率原理每行总和为1
X torch.normal(0, 1, (2, 5))
print(X)
X_prob softmax(X)
X_prob, X_prob.sum(1)tensor([[-0.0477, -0.8353, 0.6251, -0.0551, -1.3545],[ 1.9616, -0.2592, -1.7372, 1.6476, -0.1598]])
----------------X_exp------------
tensor([[0.9534, 0.4337, 1.8684, 0.9464, 0.2581],[7.1107, 0.7717, 0.1760, 5.1943, 0.8523]])
-------------partition------------
tensor([[ 4.4600],[14.1051]])
----------X_exp / partition--------
tensor([[0.2138, 0.0972, 0.4189, 0.2122, 0.0579],[0.5041, 0.0547, 0.0125, 0.3683, 0.0604]])
(tensor([[0.2138, 0.0972, 0.4189, 0.2122, 0.0579],[0.5041, 0.0547, 0.0125, 0.3683, 0.0604]]),tensor([1., 1.]))
16.实现softmax回归模型
def net(X):return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) b)7.创建一个数据y_hat,其中包含2个样本在3个类别的预测概率使用y作为y_hat中概率的索引
y torch.tensor([0, 2])
y_hat torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
# y0 0 0.1 y1 2 0.5
y_hat[[0, 1], y]tensor([0.1000, 0.5000])8.实现交叉熵损失函数
def cross_entropy(y_hat, y):return -torch.log(y_hat[range(len(y_hat)), y])cross_entropy(y_hat, y)tensor([2.3026, 0.6931])9.将预测类别与真实y元素进行比较
def accuracy(y_hat, y):计算预测正确的数量
# print(y_hat.shape) 列数大于1if len(y_hat.shape) 1 and y_hat.shape[1] 1:
# 将每一行元素值最大的下标存下来y_hat y_hat.argmax(axis1)cmp y_hat.type(y.dtype) y
# 转成和y同样的形状并求和return float(cmp.type(y.dtype).sum())# 预测正确的样本数/y的长度
accuracy(y_hat, y) / len(y)0.510.评估在任意模型net的准确率
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]11.Accumulator实例中创建了2个变量用于分别存储正确预测的数量和预测的总数量
class Accumulator:在n个变量上累加def __init__(self, n):self.data [0.0] * ndef 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]evaluate_accuracy(net, test_iter)0.128512.Softmax回归的训练
def train_epoch_ch3(net, train_iter, loss, updater): #save训练模型一个迭代周期定义见第3章if isinstance(net, torch.nn.Module):net.train() # Accumulator(3)创建3个变量训练损失总和、训练准确度总和、样本数metric Accumulator(3)for X, y in train_iter:# 计算梯度并更新参数y_hat net(X)l loss(y_hat, y)# 判断updater是否为优化器if isinstance(updater, torch.optim.Optimizer):# 使用PyTorch内置的优化器和损失函数updater.zero_grad() #把梯度设置为0l.mean().backward() #计算梯度updater.step() #自更新else:# 使用定制的优化器和损失函数# 自我实现的话l出来是向量先求和再求梯度l.sum().backward()updater(X.shape[0])metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())# 返回训练损失和训练精度metric的值由Accumulator得到return metric[0] / metric[2], metric[1] / metric[2]
13.定义一个在动画中绘制数据的使用程序类
class Animator: 在动画中绘制数据def __init__(self, xlabelNone, ylabelNone, legendNone, xlimNone,ylimNone, xscalelinear, yscalelinear,fmts(-, m--, g-., r:), nrows1, ncols1,figsize(3.5, 2.5)):# 增量地绘制多条线if legend is None:legend []d2l.use_svg_display()self.fig, self.axes d2l.plt.subplots(nrows, ncols, figsizefigsize)if nrows * ncols 1:self.axes [self.axes, ]# 使用lambda函数捕获参数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, fmtsdef add(self, x, y):# 向图表中添加多个数据点if not hasattr(y, __len__):y [y]n len(y)if not hasattr(x, __len__):x [x] * nif 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(waitTrue)
14.训练函数
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater): 训练模型定义见第3章animator Animator(xlabelepoch, xlim[1, num_epochs], ylim[0.3, 0.9],legend[train loss, train acc, test acc])# num_epochs训练次数for epoch in range(num_epochs):# train_epoch_ch3训练模型返回准确率和错误度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,))train_loss, train_acc train_metrics
15.小批量随机梯度下降来优化模型的损失函数
lr 0.1def updater(batch_size):return d2l.sgd([W, b], lr, batch_size)
16.模型训练10个迭代周期
num_epochs 10if __name__ __main__:train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater) 17.预测
def predict_ch3(net, test_iter, n6): 预测标签for X, y in test_iter:breaktrues d2l.get_fashion_mnist_labels(y) # 实际标签preds d2l.get_fashion_mnist_labels(net(X).argmax(axis1)) #预测标签取最大化概率titles [true \n pred for true, pred in zip(trues, preds)]d2l.show_images(X[0:n].reshape((n, 28, 28)), 1, n, titlestitles[0:n])# predict_ch3(net, test_iter)if __name__ __main__:predict_ch3(net, test_iter) 3.Softmax简洁实现
import torch
from torch import nn
from d2l import torch as d2lbatch_size 256
train_iter, test_iter d2l.load_data_fashion_mnist(batch_size)
train_iter.num_workers 0
test_iter.num_workers 01.softmax回归的输出层是一个全连接层
# PyTorch不会隐式地调整输入的形状
# 因此我们定义了展平层 在线形层前调整网络输入的形状
net nn.Sequential(nn.Flatten(), nn.Linear(784, 10))def init_weights(m):if type(m) nn.Linear:nn.init.normal_(m.weight, std0.01)net.apply(init_weights);2.在交叉熵损失函数中传递未归一化的预测并同时计算softmax及其对数
loss nn.CrossEntropyLoss(reductionnone)3.使用学习率为0.1的小批量随机梯度下降作为优化算法
trainer torch.optim.SGD(net.parameters(), lr0.1)
num_epoches 10
train_ch3(net, train_iter, test_iter, loss, num_epoches, trainer)【相关总结】
torch.sum()
(1)torch.sum(input, *, dtypeNone):返回输入张量input所有元素的和。 (2)torch.sum(input,dim,keepdimFalse, *,dtypeNone):返回指定维度进行求和
import torch
x torch.ones((2, 3))x_sum torch.sum(a)
x_0 torch.sum(a, dim0)
x_1 torch.sum(a, dim1)print(x)
print(x_0)
print(x_1)tensor([[1., 1., 1.], [1., 1., 1.]]) tensor([2., 2., 2.]) tensor([3., 3.])
torch.argmax()
import torch
x torch.rand(3, 2)
print(x)
y0 torch.argmax(x, dim0) #dim0,返回每一列最大值的索引
print(y0)
y1 torch.argmax(x, dim1) #dim1,返回每一行最大值的索引
print(y1)tensor([[0.9407, 0.8543], [0.4057, 0.6790], [0.0154, 0.3698]]) tensor([0, 0]) tensor([0, 1, 1])
isinstance():[python]
函数isinstance()可以判断一个变量的类型。
