From cb046156b53cf41f1c478db07460e6b200d1c4d9 Mon Sep 17 00:00:00 2001 From: Vadim Pushtaev Date: Wed, 1 Mar 2023 01:07:10 +0200 Subject: [PATCH] pushtaev: part 2 solution --- ...ural Networks in PyTorch (Exercises).ipynb | 323 ++++++++++++++---- 1 file changed, 249 insertions(+), 74 deletions(-) diff --git a/intro-to-pytorch/Part 2 - Neural Networks in PyTorch (Exercises).ipynb b/intro-to-pytorch/Part 2 - Neural Networks in PyTorch (Exercises).ipynb index b6591c9c21..51584566b0 100644 --- a/intro-to-pytorch/Part 2 - Neural Networks in PyTorch (Exercises).ipynb +++ b/intro-to-pytorch/Part 2 - Neural Networks in PyTorch (Exercises).ipynb @@ -11,10 +11,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 38, + "metadata": {}, "outputs": [], "source": [ "# Import necessary packages\n", @@ -46,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ @@ -62,10 +60,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 40, + "metadata": {}, "outputs": [], "source": [ "### Run this cell\n", @@ -98,11 +94,19 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "torch.Size([64, 1, 28, 28])\n", + "torch.Size([64])\n" + ] + } + ], "source": [ "dataiter = iter(trainloader)\n", "images, labels = next(dataiter)\n", @@ -120,13 +124,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "plt.imshow(images[1].numpy().squeeze(), cmap='Greys_r');" + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 413, + "width": 417 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(images[0].numpy().squeeze(), cmap='Greys_r');" ] }, { @@ -144,16 +162,35 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 43, + "metadata": {}, "outputs": [], "source": [ "## Your solution\n", "\n", + "activation = torch.sigmoid\n", + "def activation(x):\n", + " return 1/(1+torch.exp(-x))\n", + "\n", + "features = images.flatten(1,3)\n", + "\n", + "n_input = features.shape[1]\n", + "assert n_input == 28**2\n", + "n_hidden = 256\n", + "n_output = 10\n", + "\n", + "W1 = torch.randn(n_input, n_hidden)\n", + "W2 = torch.randn(n_hidden, n_output)\n", "\n", - "out = # output of your network, should have shape (64,10)" + "# and bias terms for hidden and output layers\n", + "B1 = torch.randn((1, n_hidden))\n", + "B2 = torch.randn((1, n_output))\n", + "\n", + "h = activation(torch.mm(features, W1) + B1)\n", + "out = torch.mm(h, W2) + B2\n", + "assert out.shape == (64, 10)\n", + "\n", + "#out = activation(out)" ] }, { @@ -178,16 +215,36 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([-7.9075, 9.5195, 18.1263, 6.2007, -4.5089, -1.5623, 2.9422, 9.7232,\n", + " 9.1744, -8.7408])\n", + "torch.Size([64, 10])\n", + "tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n", + " 1.0000])\n" + ] + } + ], "source": [ "def softmax(x):\n", - " ## TODO: Implement the softmax function here\n", + " powered = torch.exp(x)\n", + " sums = powered.sum(dim=1)\n", + "\n", + " return powered / sums.view(-1, 1)\n", "\n", "# Here, out should be the output of the network in the previous excercise with shape (64,10)\n", + "print(out[0])\n", "probabilities = softmax(out)\n", "\n", "# Does it have the right shape? Should be (64, 10)\n", @@ -207,10 +264,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 45, + "metadata": {}, "outputs": [], "source": [ "from torch import nn" @@ -218,10 +273,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 46, + "metadata": {}, "outputs": [], "source": [ "class Network(nn.Module):\n", @@ -298,11 +351,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Network(\n", + " (hidden): Linear(in_features=784, out_features=256, bias=True)\n", + " (output): Linear(in_features=256, out_features=10, bias=True)\n", + " (sigmoid): Sigmoid()\n", + " (softmax): Softmax(dim=1)\n", + ")" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Create the network and look at it's text representation\n", "model = Network()\n", @@ -318,10 +385,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, + "execution_count": 48, + "metadata": {}, "outputs": [], "source": [ "import torch.nn.functional as F\n", @@ -371,14 +436,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 57, "metadata": { - "collapsed": true, "scrolled": true }, "outputs": [], "source": [ - "## Your solution here\n" + "## Your solution here\n", + "\n", + "import torch.nn.functional as F\n", + "\n", + "class Network(nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + "\n", + " self.fc1 = nn.Linear(784, 128)\n", + " self.fc2 = nn.Linear(128, 64)\n", + "\n", + " self.output = nn.Linear(64, 10)\n", + " \n", + " def forward(self, x):\n", + " x = F.relu(self.fc1(x))\n", + " x = F.relu(self.fc2(x))\n", + " x = F.softmax(self.output(x), dim=1)\n", + " \n", + " return x\n", + "\n", + "model = Network()" ] }, { @@ -392,11 +476,43 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parameter containing:\n", + "tensor([[ 0.0105, -0.0013, -0.0092, ..., -0.0023, -0.0178, -0.0352],\n", + " [ 0.0048, 0.0287, 0.0294, ..., 0.0232, -0.0255, -0.0322],\n", + " [-0.0139, 0.0075, 0.0034, ..., 0.0348, -0.0094, 0.0197],\n", + " ...,\n", + " [-0.0167, 0.0092, -0.0215, ..., 0.0289, 0.0344, 0.0311],\n", + " [ 0.0155, -0.0285, 0.0071, ..., 0.0184, -0.0025, -0.0077],\n", + " [ 0.0014, 0.0047, 0.0167, ..., -0.0102, -0.0097, 0.0118]],\n", + " requires_grad=True)\n", + "Parameter containing:\n", + "tensor([-0.0229, -0.0226, 0.0121, 0.0352, -0.0314, -0.0083, -0.0334, -0.0350,\n", + " 0.0311, 0.0184, 0.0062, 0.0135, -0.0123, 0.0126, 0.0026, 0.0308,\n", + " 0.0120, -0.0063, 0.0223, -0.0176, -0.0036, 0.0201, -0.0139, 0.0105,\n", + " 0.0162, -0.0293, -0.0044, -0.0162, -0.0230, -0.0153, 0.0238, 0.0036,\n", + " -0.0267, -0.0287, 0.0032, -0.0050, -0.0139, -0.0311, -0.0301, -0.0176,\n", + " -0.0166, -0.0151, -0.0049, 0.0305, -0.0164, 0.0282, 0.0298, -0.0182,\n", + " 0.0038, -0.0195, -0.0289, 0.0145, 0.0017, -0.0275, -0.0071, -0.0109,\n", + " 0.0089, -0.0233, -0.0012, 0.0285, -0.0231, -0.0058, -0.0202, -0.0285,\n", + " 0.0151, -0.0200, -0.0198, 0.0071, 0.0042, 0.0175, 0.0039, 0.0332,\n", + " 0.0140, -0.0102, 0.0064, 0.0331, -0.0142, -0.0276, 0.0207, -0.0094,\n", + " -0.0157, -0.0193, -0.0169, -0.0044, -0.0122, -0.0150, 0.0152, -0.0211,\n", + " -0.0016, 0.0209, 0.0192, -0.0352, -0.0333, 0.0048, -0.0258, -0.0085,\n", + " 0.0161, 0.0189, -0.0346, 0.0029, 0.0233, 0.0129, -0.0234, -0.0270,\n", + " -0.0355, -0.0162, 0.0168, -0.0094, -0.0255, -0.0081, -0.0286, 0.0211,\n", + " 0.0220, 0.0165, 0.0017, -0.0330, -0.0356, 0.0239, 0.0187, -0.0259,\n", + " -0.0198, -0.0064, -0.0151, -0.0130, -0.0071, -0.0210, 0.0152, -0.0220],\n", + " requires_grad=True)\n" + ] + } + ], "source": [ "print(model.fc1.weight)\n", "print(model.fc1.bias)" @@ -411,11 +527,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Set biases to all zeros\n", "model.fc1.bias.data.fill_(0)" @@ -423,11 +553,26 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 0.0034, 0.0019, 0.0018, ..., -0.0059, 0.0088, 0.0077],\n", + " [-0.0070, 0.0020, -0.0101, ..., 0.0247, 0.0036, 0.0191],\n", + " [-0.0121, 0.0007, 0.0132, ..., 0.0019, 0.0058, -0.0043],\n", + " ...,\n", + " [-0.0052, 0.0193, 0.0029, ..., 0.0122, -0.0063, -0.0164],\n", + " [-0.0019, 0.0038, -0.0071, ..., -0.0070, 0.0093, -0.0123],\n", + " [-0.0031, -0.0047, -0.0058, ..., 0.0101, -0.0163, 0.0083]])" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# sample from random normal with standard dev = 0.01\n", "model.fc1.weight.data.normal_(std=0.01)" @@ -444,11 +589,41 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[0.1338, 0.1736, 0.0000, 0.2208, 0.0327, 0.0811, 0.0000, 0.0000, 0.0000,\n", + " 0.0000, 0.0000, 0.0987, 0.2122, 0.0000, 0.0000, 0.1368, 0.0359, 0.2679,\n", + " 0.0340, 0.0125, 0.1386, 0.0000, 0.3572, 0.2343, 0.0000, 0.0000, 0.0306,\n", + " 0.0000, 0.0612, 0.0000, 0.0070, 0.0000, 0.0000, 0.0966, 0.0903, 0.0000,\n", + " 0.0000, 0.2240, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0911,\n", + " 0.1211, 0.0000, 0.0252, 0.0342, 0.0000, 0.0000, 0.0431, 0.0000, 0.1079,\n", + " 0.0000, 0.0000, 0.0000, 0.1856, 0.0709, 0.0453, 0.1310, 0.0000, 0.0119,\n", + " 0.0127]], grad_fn=)\n", + "tensor([[0.0909, 0.1150, 0.1081, 0.0845, 0.0972, 0.0951, 0.1121, 0.1086, 0.0865,\n", + " 0.1019]], grad_fn=)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 327, + "width": 589 + } + }, + "output_type": "display_data" + } + ], "source": [ "# Grab some data \n", "dataiter = iter(trainloader)\n", @@ -582,7 +757,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python [default]", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -596,7 +771,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.8.10" } }, "nbformat": 4,