{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "86b62c48-7f5e-4af5-bb60-056698ee7854",
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/jovyan/work/d2l/notebooks/d2l.py:119: SyntaxWarning: assertion is always true, perhaps remove parentheses?\n",
" assert(self, 'net'), 'Neural network is defined'\n",
"/home/jovyan/work/d2l/notebooks/d2l.py:123: SyntaxWarning: assertion is always true, perhaps remove parentheses?\n",
" assert(self, 'trainer'), 'trainer is not inited'\n"
]
}
],
"source": [
"import random\n",
"import torch\n",
"import d2l\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import torch.nn as nn\n",
"\n",
"\n",
"class LinearRegression(d2l.Module):\n",
" def __init__(self, lr):\n",
" super().__init__()\n",
" self.save_hyperparameters()\n",
" self.net = nn.LazyLinear(1)\n",
" self.net.weight.data.normal_(0, 0.01)\n",
" self.net.bias.data.fill_(0)\n",
" \n",
" def forward(self, X):\n",
" return self.net(X)\n",
" \n",
" def loss(self, y_hat, y):\n",
" fn = nn.MSELoss(reduction='mean')\n",
" return fn(y_hat, y)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "c9b5115f-e68c-4f4b-9c3e-a34c0fdc6a07",
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([[ 1.9981, -3.3884]], requires_grad=True),\n",
" Parameter containing:\n",
" tensor([4.1935], requires_grad=True))"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"data = d2l.SyntheticRegressionData(w=torch.tensor([2, -3.4]), b=4.2)\n",
"model = LinearRegression(lr=0.03)\n",
"trainer = d2l.Trainer(max_epochs=3)\n",
"trainer.fit(model, data)\n",
"model.net.weight,model.net.bias"
]
},
{
"cell_type": "markdown",
"id": "b72e5923-6bfa-489f-8274-48c2fff02d97",
"metadata": {},
"source": [
"# 3.5.6. Exercises"
]
},
{
"cell_type": "markdown",
"id": "d8dcb1ae-6d81-4c91-8b67-9b14b0ebe3f8",
"metadata": {},
"source": [
"## 1. How would you need to change the learning rate if you replace the aggregate loss over the minibatch with an average over the loss on the minibatch?"
]
},
{
"cell_type": "markdown",
"id": "fa0fcc52-4060-45fd-a0fe-fb3dbb613b6b",
"metadata": {},
"source": [
"When you calculate the average loss over the minibatch instead of the aggregate loss, the scale of the loss becomes smaller. As a result, the gradients used for parameter updates are also smaller. To compensate for this, you typically increase the learning rate to achieve similar step sizes for parameter updates.\n",
"\n",
"The adjustment can be made by dividing the original learning rate by the batch size. This helps scale the gradients appropriately to match the change in loss scaling. "
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "c153fe3c-99e3-426e-8dc3-b6d44f76eafe",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"class LinearRegressionAggLoss(d2l.Module):\n",
" def __init__(self, lr):\n",
" super().__init__()\n",
" self.save_hyperparameters()\n",
" self.net = nn.LazyLinear(1)\n",
" self.net.weight.data.normal_(0, 0.01)\n",
" self.net.bias.data.fill_(0)\n",
" \n",
" def forward(self, X):\n",
" return self.net(X)\n",
" \n",
" def loss(self, y_hat, y):\n",
" fn = nn.MSELoss(reduction='sum')\n",
" return fn(y_hat, y)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "bc7247a2-8d22-43b8-b673-915d5385982b",
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([[ 1.9405, -3.4046]], requires_grad=True),\n",
" Parameter containing:\n",
" tensor([4.2016], requires_grad=True))"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model = LinearRegressionAggLoss(lr=0.03)\n",
"trainer = d2l.Trainer(max_epochs=3)\n",
"trainer.fit(model, data)\n",
"model.net.weight,model.net.bias"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "a4748c02-9478-416b-87ed-6c66eec8780c",
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([[ 1.9954, -3.3869]], requires_grad=True),\n",
" Parameter containing:\n",
" tensor([4.1921], requires_grad=True))"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model = LinearRegressionAggLoss(lr=0.03/32)\n",
"trainer = d2l.Trainer(max_epochs=3)\n",
"trainer.fit(model, data)\n",
"model.net.weight,model.net.bias"
]
},
{
"cell_type": "markdown",
"id": "5490b6ee-406d-43d6-a69d-4146a978ac58",
"metadata": {},
"source": [
"## 2. Review the framework documentation to see which loss functions are provided. In particular, replace the squared loss with Huber’s robust loss function. That is, use the loss function\n",
"\n",
"$L_{\\delta}=\n",
" \\left\\{\\begin{matrix}\n",
" \\frac{1}{2}(y - \\hat{y})^{2} & if \\left | (y - \\hat{y}) \\right | < \\delta\\\\\n",
" \\delta ((y - \\hat{y}) - \\frac1 2 \\delta) & otherwise\n",
" \\end{matrix}\\right.$\n"
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "cc98043f-de3a-4353-872c-4cb4f4192849",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"class LinearRegressionHuberLoss(d2l.Module):\n",
" def __init__(self, lr):\n",
" super().__init__()\n",
" self.save_hyperparameters()\n",
" self.net = nn.LazyLinear(1)\n",
" self.net.weight.data.normal_(0,0.01)\n",
" self.net.bias.data.fill_(0)\n",
" \n",
" def forward(self, X):\n",
" return self.net(X)\n",
" \n",
" def loss(self, y_hat, y):\n",
" fn = nn.HuberLoss()\n",
" return fn(y_hat, y)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"id": "c5fb3ce8-d398-4060-9abe-41ad34726161",
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"(Parameter containing:\n",
" tensor([[ 2.0007, -3.4017]], requires_grad=True),\n",
" Parameter containing:\n",
" tensor([4.1984], requires_grad=True))"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model = LinearRegressionHuberLoss(lr=0.3)\n",
"trainer = d2l.Trainer(max_epochs=3)\n",
"trainer.fit(model, data)\n",
"model.net.weight,model.net.bias"
]
},
{
"cell_type": "markdown",
"id": "36f1c210-4a38-4360-9301-d5d3f973330a",
"metadata": {},
"source": [
"## 3. How do you access the gradient of the weights of the model?"
]
},
{
"cell_type": "code",
"execution_count": 31,
"id": "67e153ba-f5fb-4c9d-bce8-5deb85bb45de",
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"(tensor([[-0.0023, 0.0042]]), tensor([0.0040]))"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model.net.weight.grad,model.net.bias.grad"
]
},
{
"cell_type": "markdown",
"id": "9cb64b85-6d23-41ce-92e0-a8398cc86c2e",
"metadata": {},
"source": [
"## 4. What is the effect on the solution if you change the learning rate and the number of epochs? Does it keep on improving?"
]
},
{
"cell_type": "markdown",
"id": "61e25374-bcc8-492d-a76c-534619096e6b",
"metadata": {},
"source": [
"We make some experienmts with lr in [0.003,0.03,0.3,3] with epoch=3\n",
"\n",
"when lr is small (such as 0.003), the loss function drops very slow, and the error can be reduced by increasing epoch\n",
"when lr increases, the loss function drops faster, and if it convergences, increasing epoch will not help too.\n",
"when lr is much larger (such as 3), the loss function blows up, and there is no need to increase epoch"
]
},
{
"cell_type": "markdown",
"id": "dbc420d8-fa68-479d-b67c-0b0b44e91dc3",
"metadata": {},
"source": [
"## 5. How does the solution change as you vary the amount of data generated?\n",
"\n",
"* Plot the estimation error for $\\hat{w}-w$ and $\\hat{b}-b$ as a function of the amount of data. Hint: increase the amount of data logarithmically rather than linearly, i.e., 5, 10, 20, 50, …, 10,000 rather than 1000, 2000, …, 10,000.\n",
"* Why is the suggestion in the hint appropriate?"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "ed1a5f79-be51-4f72-834a-8328a18e684d",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"def stat_bias(n):\n",
" w = torch.tensor([2, -3.4])\n",
" b = torch.tensor([4])\n",
" data = d2l.SyntheticRegressionData(w=w, b=b, num_train=n, num_val=n)\n",
" model = LinearRegression(lr=0.03)\n",
" trainer = d2l.Trainer(max_epochs=3, plot_flag=False)\n",
" trainer.fit(model, data)\n",
" bias_w = torch.abs(w-model.net.weight).detach().numpy()\n",
" bias_b = torch.abs(b-model.net.bias).detach().numpy().reshape(1, -1)\n",
" return np.concatenate([bias_w, bias_b], axis=1)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "6db52a05-fd88-4ff6-a850-33ae84aca379",
"metadata": {
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Logarithmic Growth Sequence: [5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560, 5120, 10240]\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/jovyan/.local/lib/python3.11/site-packages/torch/nn/modules/lazy.py:180: UserWarning: Lazy modules are a new feature under heavy development so changes to the API or functionality can happen at any moment.\n",
" warnings.warn('Lazy modules are a new feature under heavy development '\n",
"/opt/conda/envs/d2l/lib/python3.11/site-packages/IPython/core/pylabtools.py:152: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"orientation\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
" fig.canvas.print_figure(bytes_io, **kw)\n",
"/opt/conda/envs/d2l/lib/python3.11/site-packages/IPython/core/pylabtools.py:152: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"facecolor\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
" fig.canvas.print_figure(bytes_io, **kw)\n",
"/opt/conda/envs/d2l/lib/python3.11/site-packages/IPython/core/pylabtools.py:152: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"edgecolor\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
" fig.canvas.print_figure(bytes_io, **kw)\n",
"/opt/conda/envs/d2l/lib/python3.11/site-packages/IPython/core/pylabtools.py:152: MatplotlibDeprecationWarning: savefig() got unexpected keyword argument \"bbox_inches_restore\" which is no longer supported as of 3.3 and will become an error two minor releases later\n",
" fig.canvas.print_figure(bytes_io, **kw)\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"initial_value = 5\n",
"growth_factor = 2\n",
"num_elements = 12\n",
"# Generate the logarithmic growth sequence\n",
"nums = [initial_value * growth_factor**i for i in range(num_elements)]\n",
"print(\"Logarithmic Growth Sequence:\", nums)\n",
"bias = np.empty((1, 3), dtype=float)\n",
"for i in range(len(nums)):\n",
" temp = stat_bias(nums[i])\n",
" bias = np.concatenate([bias, temp], axis=0)\n",
"for i in range(3):\n",
" plt.plot(nums[:], bias[1:,i], label=i)\n",
"plt.legend()\n",
"plt.show()"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python [conda env:d2l]",
"language": "python",
"name": "conda-env-d2l-py"
},
"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.11.4"
}
},
"nbformat": 4,
"nbformat_minor": 5
}