{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 3.6 softmax回归的从零开始实现"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.4.1\n",
"0.2.1\n"
]
}
],
"source": [
"import torch\n",
"import torchvision\n",
"import numpy as np\n",
"import sys\n",
"sys.path.append(\"..\") # 为了导入上层目录的d2lzh_pytorch\n",
"import d2lzh_pytorch as d2l\n",
"\n",
"print(torch.__version__)\n",
"print(torchvision.__version__)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.6.1 获取和读取数据"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"batch_size = 256\n",
"train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.6.2 初始化模型参数"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"num_inputs = 784\n",
"num_outputs = 10\n",
"\n",
"W = torch.tensor(np.random.normal(0, 0.01, (num_inputs, num_outputs)), dtype=torch.float)\n",
"b = torch.zeros(num_outputs, dtype=torch.float)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], requires_grad=True)"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"W.requires_grad_(requires_grad=True)\n",
"b.requires_grad_(requires_grad=True) "
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([[5, 7, 9]])\n",
"tensor([[ 6],\n",
" [15]])\n"
]
}
],
"source": [
"X = torch.tensor([[1, 2, 3], [4, 5, 6]])\n",
"print(X.sum(dim=0, keepdim=True))\n",
"print(X.sum(dim=1, keepdim=True))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.6.3 实现softmax运算"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def softmax(X):\n",
" X_exp = X.exp()\n",
" partition = X_exp.sum(dim=1, keepdim=True)\n",
" return X_exp / partition # 这里应用了广播机制"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tensor([[0.1195, 0.2642, 0.2857, 0.1721, 0.1585],\n",
" [0.1918, 0.1353, 0.1837, 0.3329, 0.1562]]) tensor([1., 1.])\n"
]
}
],
"source": [
"X = torch.rand((2, 5))\n",
"X_prob = softmax(X)\n",
"print(X_prob, X_prob.sum(dim=1))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.6.4 定义模型"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def net(X):\n",
" return softmax(torch.mm(X.view((-1, num_inputs)), W) + b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.6.5 定义损失函数"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tensor([[0.1000],\n",
" [0.5000]])"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])\n",
"y = torch.LongTensor([0, 2])\n",
"y_hat.gather(1, y.view(-1, 1))"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def cross_entropy(y_hat, y):\n",
" return - torch.log(y_hat.gather(1, y.view(-1, 1)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.6.6 计算分类准确率"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def accuracy(y_hat, y):\n",
" return (y_hat.argmax(dim=1) == y).float().mean().item()"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.5\n"
]
}
],
"source": [
"print(accuracy(y_hat, y))"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# 本函数已保存在d2lzh_pytorch包中方便以后使用。该函数将被逐步改进：它的完整实现将在“图像增广”一节中描述\n",
"def evaluate_accuracy(data_iter, net):\n",
" acc_sum, n = 0.0, 0\n",
" for X, y in data_iter:\n",
" acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()\n",
" n += y.shape[0]\n",
" return acc_sum / n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.0681\n"
]
}
],
"source": [
"print(evaluate_accuracy(test_iter, net))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.6.7 训练模型"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"epoch 1, loss 0.7878, train acc 0.749, test acc 0.794\n",
"epoch 2, loss 0.5702, train acc 0.814, test acc 0.813\n",
"epoch 3, loss 0.5252, train acc 0.827, test acc 0.819\n",
"epoch 4, loss 0.5010, train acc 0.833, test acc 0.824\n",
"epoch 5, loss 0.4858, train acc 0.836, test acc 0.815\n"
]
}
],
"source": [
"num_epochs, lr = 5, 0.1\n",
"\n",
"# 本函数已保存在d2lzh_pytorch包中方便以后使用\n",
"def train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size,\n",
" params=None, lr=None, optimizer=None):\n",
" for epoch in range(num_epochs):\n",
" train_l_sum, train_acc_sum, n = 0.0, 0.0, 0\n",
" for X, y in train_iter:\n",
" y_hat = net(X)\n",
" l = loss(y_hat, y).sum()\n",
" \n",
" # 梯度清零\n",
" if optimizer is not None:\n",
" optimizer.zero_grad()\n",
" elif params is not None and params[0].grad is not None:\n",
" for param in params:\n",
" param.grad.data.zero_()\n",
" \n",
" l.backward()\n",
" if optimizer is None:\n",
" d2l.sgd(params, lr, batch_size)\n",
" else:\n",
" optimizer.step() # “softmax回归的简洁实现”一节将用到\n",
" \n",
" \n",
" train_l_sum += l.item()\n",
" train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()\n",
" n += y.shape[0]\n",
" test_acc = evaluate_accuracy(test_iter, net)\n",
" print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f'\n",
" % (epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc))\n",
"\n",
"train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, batch_size, [W, b], lr)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3.6.8 预测"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"X, y = iter(test_iter).next()\n",
"\n",
"true_labels = d2l.get_fashion_mnist_labels(y.numpy())\n",
"pred_labels = d2l.get_fashion_mnist_labels(net(X).argmax(dim=1).numpy())\n",
"titles = [true + '\\n' + pred for true, pred in zip(true_labels, pred_labels)]\n",
"\n",
"d2l.show_fashion_mnist(X[0:9], titles[0:9])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python [default]",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.6.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}