├── README.md ├── LICENSE ├── .gitignore ├── module03_wine_task.ipynb ├── module04_mnist_fc.ipynb ├── module05_mnist_conv.ipynb ├── module03_wine_prediction.ipynb ├── module01_basics.ipynb └── module03_sin_prediction.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # Neural_Networks_and_CV 2 | 3 | Repo for free online course stepik.org/course/50352 4 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 Igor Slinko 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | *.egg-info/ 24 | .installed.cfg 25 | *.egg 26 | MANIFEST 27 | 28 | # PyInstaller 29 | # Usually these files are written by a python script from a template 30 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 31 | *.manifest 32 | *.spec 33 | 34 | # Installer logs 35 | pip-log.txt 36 | pip-delete-this-directory.txt 37 | 38 | # Unit test / coverage reports 39 | htmlcov/ 40 | .tox/ 41 | .coverage 42 | .coverage.* 43 | .cache 44 | nosetests.xml 45 | coverage.xml 46 | *.cover 47 | .hypothesis/ 48 | .pytest_cache/ 49 | 50 | # Translations 51 | *.mo 52 | *.pot 53 | 54 | # Django stuff: 55 | *.log 56 | local_settings.py 57 | db.sqlite3 58 | 59 | # Flask stuff: 60 | instance/ 61 | .webassets-cache 62 | 63 | # Scrapy stuff: 64 | .scrapy 65 | 66 | # Sphinx documentation 67 | docs/_build/ 68 | 69 | # PyBuilder 70 | target/ 71 | 72 | # Jupyter Notebook 73 | .ipynb_checkpoints 74 | 75 | # pyenv 76 | .python-version 77 | 78 | # celery beat schedule file 79 | celerybeat-schedule 80 | 81 | # SageMath parsed files 82 | *.sage.py 83 | 84 | # Environments 85 | .env 86 | .venv 87 | env/ 88 | venv/ 89 | ENV/ 90 | env.bak/ 91 | venv.bak/ 92 | 93 | # Spyder project settings 94 | .spyderproject 95 | .spyproject 96 | 97 | # Rope project settings 98 | .ropeproject 99 | 100 | # mkdocs documentation 101 | /site 102 | 103 | # mypy 104 | .mypy_cache/ 105 | -------------------------------------------------------------------------------- /module03_wine_task.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import torch\n", 10 | "import random\n", 11 | "import numpy as np\n", 12 | "from sklearn.model_selection import train_test_split\n", 13 | "from sklearn.datasets import load_wine" 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": null, 19 | "metadata": {}, 20 | "outputs": [], 21 | "source": [ 22 | "wine = load_wine()\n", 23 | "features = # use 13 features\n", 24 | "\n", 25 | "X_train, X_test, y_train, y_test = train_test_split(\n", 26 | " wine.data[:, :features], \n", 27 | " wine.target, \n", 28 | " test_size=0.3, \n", 29 | " shuffle=True)\n", 30 | "\n", 31 | "X_train = torch.FloatTensor(X_train)\n", 32 | "X_test = torch.FloatTensor(X_test)\n", 33 | "y_train = torch.LongTensor(y_train)\n", 34 | "y_test = torch.LongTensor(y_test)" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": null, 40 | "metadata": {}, 41 | "outputs": [], 42 | "source": [ 43 | "class WineNet(torch.nn.Module):\n", 44 | " def __init__(self,n_input, n_hidden_neurons):\n", 45 | " super(WineNet, self).__init__()\n", 46 | " self.fc1 = torch.nn.Linear(n_input, n_hidden_neurons)\n", 47 | " # your code here\n", 48 | " self.sm = torch.nn.Softmax(dim=1)\n", 49 | " \n", 50 | " def forward(self, x):\n", 51 | " x = self.fc1(x)\n", 52 | " x = self.activ1(x)\n", 53 | " x = self.fc2(x)\n", 54 | " x = self.activ2(x)\n", 55 | " x = self.fc3(x)\n", 56 | " return x\n", 57 | "\n", 58 | " def inference(self, x):\n", 59 | " x = self.forward(x)\n", 60 | " x = self.sm(x)\n", 61 | " return x\n", 62 | " \n", 63 | "n_input = # choose number of input neurons\n", 64 | "n_hidden = # choose number of hidden neurons\n", 65 | "wine_net = WineNet(n_input, n_hidden)" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "loss = torch.nn.CrossEntropyLoss()\n", 75 | "optimizer = torch.optim.Adam(wine_net.parameters(), lr=1.0e-3)" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "batch_size = # choose different batch sizes\n", 85 | "\n", 86 | "for epoch in range(2000):\n", 87 | " order = np.random.permutation(len(X_train))\n", 88 | " for start_index in range(0, len(X_train), batch_size):\n", 89 | " optimizer.zero_grad()\n", 90 | " \n", 91 | " batch_indexes = order[start_index:start_index+batch_size]\n", 92 | " \n", 93 | " x_batch = X_train[batch_indexes]\n", 94 | " y_batch = y_train[batch_indexes]\n", 95 | " \n", 96 | " preds = wine_net.forward(x_batch) \n", 97 | " \n", 98 | " loss_value = loss(preds, y_batch)\n", 99 | " loss_value.backward()\n", 100 | " \n", 101 | " optimizer.step()\n", 102 | " \n", 103 | " if epoch % 10 == 0:\n", 104 | " test_preds = wine_net.forward(X_test)\n", 105 | " test_preds = test_preds.argmax(dim=1)" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": null, 111 | "metadata": {}, 112 | "outputs": [], 113 | "source": [ 114 | "print(wine_net.fc1.in_features, np.asarray((test_preds == y_test).float().mean()) > 0.8)\n", 115 | "# need to get 13 True" 116 | ] 117 | } 118 | ], 119 | "metadata": { 120 | "kernelspec": { 121 | "display_name": "Python 3", 122 | "language": "python", 123 | "name": "python3" 124 | }, 125 | "language_info": { 126 | "codemirror_mode": { 127 | "name": "ipython", 128 | "version": 3 129 | }, 130 | "file_extension": ".py", 131 | "mimetype": "text/x-python", 132 | "name": "python", 133 | "nbconvert_exporter": "python", 134 | "pygments_lexer": "ipython3", 135 | "version": "3.6.8" 136 | } 137 | }, 138 | "nbformat": 4, 139 | "nbformat_minor": 2 140 | } 141 | -------------------------------------------------------------------------------- /module04_mnist_fc.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": { 7 | "colab": {}, 8 | "colab_type": "code", 9 | "id": "DWr6cvb9pS3J" 10 | }, 11 | "outputs": [], 12 | "source": [ 13 | "import torch\n", 14 | "import random\n", 15 | "import numpy as np\n", 16 | "\n", 17 | "random.seed(0)\n", 18 | "np.random.seed(0)\n", 19 | "torch.manual_seed(0)\n", 20 | "torch.cuda.manual_seed(0)\n", 21 | "torch.backends.cudnn.deterministic = True" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "metadata": { 28 | "colab": {}, 29 | "colab_type": "code", 30 | "id": "MqGQWTDIpS3R" 31 | }, 32 | "outputs": [], 33 | "source": [ 34 | "import torchvision.datasets\n", 35 | "MNIST_train = torchvision.datasets.MNIST('./', download=True, train=True)\n", 36 | "MNIST_test = torchvision.datasets.MNIST('./', download=True, train=False)" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": null, 42 | "metadata": { 43 | "colab": {}, 44 | "colab_type": "code", 45 | "id": "vv_Lz7PYpS3U" 46 | }, 47 | "outputs": [], 48 | "source": [ 49 | "X_train = MNIST_train.train_data\n", 50 | "y_train = MNIST_train.train_labels\n", 51 | "X_test = MNIST_test.test_data\n", 52 | "y_test = MNIST_test.test_labels" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": null, 58 | "metadata": { 59 | "colab": { 60 | "base_uri": "https://localhost:8080/", 61 | "height": 35 62 | }, 63 | "colab_type": "code", 64 | "id": "hMhsAedlrQF5", 65 | "outputId": "ae08bd21-79ff-48da-9886-48996a178110" 66 | }, 67 | "outputs": [], 68 | "source": [ 69 | "X_train.dtype, y_train.dtype" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": null, 75 | "metadata": { 76 | "colab": {}, 77 | "colab_type": "code", 78 | "id": "_yTaVOrPvap6" 79 | }, 80 | "outputs": [], 81 | "source": [ 82 | "X_train = X_train.float()\n", 83 | "X_test = X_test.float()" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": null, 89 | "metadata": { 90 | "colab": { 91 | "base_uri": "https://localhost:8080/", 92 | "height": 35 93 | }, 94 | "colab_type": "code", 95 | "id": "_gfupg4kpS3X", 96 | "outputId": "e72c3ff4-50f7-4695-d5d5-f838e7ac2667" 97 | }, 98 | "outputs": [], 99 | "source": [ 100 | "X_train.shape, X_test.shape" 101 | ] 102 | }, 103 | { 104 | "cell_type": "code", 105 | "execution_count": null, 106 | "metadata": { 107 | "colab": { 108 | "base_uri": "https://localhost:8080/", 109 | "height": 35 110 | }, 111 | "colab_type": "code", 112 | "id": "zEC1RXBEz_SW", 113 | "outputId": "48b9a605-2622-4188-b326-116b675bd499" 114 | }, 115 | "outputs": [], 116 | "source": [ 117 | "y_train.shape, y_test.shape" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": null, 123 | "metadata": { 124 | "colab": { 125 | "base_uri": "https://localhost:8080/", 126 | "height": 365 127 | }, 128 | "colab_type": "code", 129 | "id": "Z1tFXMwJpS3e", 130 | "outputId": "e7c2778b-d6f5-4718-ea28-fc8544f0416c" 131 | }, 132 | "outputs": [], 133 | "source": [ 134 | "import matplotlib.pyplot as plt\n", 135 | "plt.imshow(X_train[0, :, :])\n", 136 | "plt.show()\n", 137 | "print(y_train[0])" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "metadata": { 144 | "colab": {}, 145 | "colab_type": "code", 146 | "id": "IUZgNg7zpS3j" 147 | }, 148 | "outputs": [], 149 | "source": [ 150 | "X_train = X_train.reshape([-1, 28 * 28])\n", 151 | "X_test = X_test.reshape([-1, 28 * 28])" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "metadata": { 158 | "colab": {}, 159 | "colab_type": "code", 160 | "id": "k7l65slppS3l" 161 | }, 162 | "outputs": [], 163 | "source": [ 164 | "class MNISTNet(torch.nn.Module):\n", 165 | " def __init__(self, n_hidden_neurons):\n", 166 | " super(MNISTNet, self).__init__()\n", 167 | " self.fc1 = torch.nn.Linear(28 * 28, n_hidden_neurons)\n", 168 | " self.ac1 = torch.nn.Sigmoid()\n", 169 | " self.fc2 = torch.nn.Linear(n_hidden_neurons, 10) \n", 170 | " \n", 171 | " def forward(self, x):\n", 172 | " x = self.fc1(x)\n", 173 | " x = self.ac1(x)\n", 174 | " x = self.fc2(x)\n", 175 | " return x\n", 176 | " \n", 177 | "mnist_net = MNISTNet(100)" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": null, 183 | "metadata": { 184 | "colab": {}, 185 | "colab_type": "code", 186 | "id": "FJp7t3dR0pC5" 187 | }, 188 | "outputs": [], 189 | "source": [ 190 | "# torch.cuda.is_available()" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "metadata": { 197 | "colab": {}, 198 | "colab_type": "code", 199 | "id": "ShQDv_w-0rz8" 200 | }, 201 | "outputs": [], 202 | "source": [ 203 | "# !nvidia-smi" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": null, 209 | "metadata": { 210 | "colab": {}, 211 | "colab_type": "code", 212 | "id": "iUHy-780po9d" 213 | }, 214 | "outputs": [], 215 | "source": [ 216 | "# device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n", 217 | "# mnist_net = mnist_net.to(device)\n", 218 | "# list(mnist_net.parameters())" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "metadata": { 225 | "colab": {}, 226 | "colab_type": "code", 227 | "id": "00_2j2igpS3o" 228 | }, 229 | "outputs": [], 230 | "source": [ 231 | "loss = torch.nn.CrossEntropyLoss()\n", 232 | "optimizer = torch.optim.Adam(mnist_net.parameters(), lr=1.0e-3)" 233 | ] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": null, 238 | "metadata": { 239 | "colab": {}, 240 | "colab_type": "code", 241 | "id": "wZtqiGvfpS3r" 242 | }, 243 | "outputs": [], 244 | "source": [ 245 | "batch_size = 100\n", 246 | "\n", 247 | "# test_accuracy_history = []\n", 248 | "# test_loss_history = []\n", 249 | "\n", 250 | "# X_test = X_test.to(device)\n", 251 | "# y_test = y_test.to(device)\n", 252 | "\n", 253 | "for epoch in range(10000):\n", 254 | " order = np.random.permutation(len(X_train))\n", 255 | " \n", 256 | " for start_index in range(0, len(X_train), batch_size):\n", 257 | " optimizer.zero_grad()\n", 258 | " \n", 259 | " batch_indexes = order[start_index:start_index+batch_size]\n", 260 | " \n", 261 | " X_batch = X_train[batch_indexes] #.to(device)\n", 262 | " y_batch = y_train[batch_indexes] #.to(device)\n", 263 | " \n", 264 | " preds = mnist_net.forward(X_batch) \n", 265 | " \n", 266 | " loss_value = loss(preds, y_batch)\n", 267 | " loss_value.backward()\n", 268 | " \n", 269 | " optimizer.step()\n", 270 | "\n", 271 | " test_preds = mnist_net.forward(X_test)\n", 272 | "# test_loss_history.append(loss(test_preds, y_test))\n", 273 | " \n", 274 | " accuracy = (test_preds.argmax(dim=1) == y_test).float().mean()\n", 275 | "# test_accuracy_history.append(accuracy)\n", 276 | " print(accuracy)" 277 | ] 278 | }, 279 | { 280 | "cell_type": "code", 281 | "execution_count": null, 282 | "metadata": { 283 | "colab": {}, 284 | "colab_type": "code", 285 | "id": "kLnumX3SpS3u" 286 | }, 287 | "outputs": [], 288 | "source": [ 289 | "plt.plot(test_accuracy_history)\n", 290 | "plt.plot(test_loss_history);" 291 | ] 292 | }, 293 | { 294 | "cell_type": "code", 295 | "execution_count": null, 296 | "metadata": { 297 | "colab": {}, 298 | "colab_type": "code", 299 | "id": "-nu1318JpS3y" 300 | }, 301 | "outputs": [], 302 | "source": [] 303 | } 304 | ], 305 | "metadata": { 306 | "accelerator": "GPU", 307 | "colab": { 308 | "collapsed_sections": [], 309 | "name": "Lesson 5 Digits Recognition Video.ipynb", 310 | "provenance": [], 311 | "version": "0.3.2" 312 | }, 313 | "kernelspec": { 314 | "display_name": "Python 3", 315 | "language": "python", 316 | "name": "python3" 317 | }, 318 | "language_info": { 319 | "codemirror_mode": { 320 | "name": "ipython", 321 | "version": 3 322 | }, 323 | "file_extension": ".py", 324 | "mimetype": "text/x-python", 325 | "name": "python", 326 | "nbconvert_exporter": "python", 327 | "pygments_lexer": "ipython3", 328 | "version": "3.6.8" 329 | } 330 | }, 331 | "nbformat": 4, 332 | "nbformat_minor": 1 333 | } 334 | -------------------------------------------------------------------------------- /module05_mnist_conv.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "colab_type": "text", 7 | "id": "cdjn6pICZMoM" 8 | }, 9 | "source": [ 10 | "![alt text](https://engmrk.com/wp-content/uploads/2018/09/LeNet_Original_Image.jpg)" 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "metadata": { 16 | "colab_type": "text", 17 | "id": "14icu4JgZXqM" 18 | }, 19 | "source": [ 20 | "![alt text](https://engmrk.com/wp-content/uploads/2018/09/LeNEt_Summary_Table.jpg)" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": { 27 | "colab": {}, 28 | "colab_type": "code", 29 | "id": "85_HkTjcNZeg" 30 | }, 31 | "outputs": [], 32 | "source": [ 33 | "import torch\n", 34 | "import random\n", 35 | "import numpy as np\n", 36 | "\n", 37 | "random.seed(0)\n", 38 | "np.random.seed(0)\n", 39 | "torch.manual_seed(0)\n", 40 | "torch.cuda.manual_seed(0)\n", 41 | "torch.backends.cudnn.deterministic = True" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": null, 47 | "metadata": { 48 | "colab": {}, 49 | "colab_type": "code", 50 | "id": "kjPVw9UfNZel" 51 | }, 52 | "outputs": [], 53 | "source": [ 54 | "import torchvision.datasets" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": null, 60 | "metadata": { 61 | "colab": { 62 | "base_uri": "https://localhost:8080/", 63 | "height": 279 64 | }, 65 | "colab_type": "code", 66 | "id": "buWKcUqGNZeo", 67 | "outputId": "f2cb4e72-67cd-4262-da9b-228f9e643afd" 68 | }, 69 | "outputs": [], 70 | "source": [ 71 | "MNIST_train = torchvision.datasets.MNIST('./', download=True, train=True)\n", 72 | "MNIST_test = torchvision.datasets.MNIST('./', download=True, train=False)\n" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": null, 78 | "metadata": { 79 | "colab": { 80 | "base_uri": "https://localhost:8080/", 81 | "height": 155 82 | }, 83 | "colab_type": "code", 84 | "id": "nyrpGOtPNZeq", 85 | "outputId": "128d4d8d-8ebc-44d7-e8ed-04a92cd7dd40" 86 | }, 87 | "outputs": [], 88 | "source": [ 89 | "X_train = MNIST_train.train_data\n", 90 | "y_train = MNIST_train.train_labels\n", 91 | "X_test = MNIST_test.test_data\n", 92 | "y_test = MNIST_test.test_labels" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": null, 98 | "metadata": { 99 | "colab": { 100 | "base_uri": "https://localhost:8080/", 101 | "height": 35 102 | }, 103 | "colab_type": "code", 104 | "id": "f_TmOTWdNZet", 105 | "outputId": "eb87b5af-7e23-4a1f-bc58-cdfc4774d4aa" 106 | }, 107 | "outputs": [], 108 | "source": [ 109 | "len(y_train), len(y_test)" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": { 116 | "colab": { 117 | "base_uri": "https://localhost:8080/", 118 | "height": 286 119 | }, 120 | "colab_type": "code", 121 | "id": "Zd-E4vIpNZe1", 122 | "outputId": "f72d8415-e392-4af7-9c8f-501eddb5cc9c" 123 | }, 124 | "outputs": [], 125 | "source": [ 126 | "import matplotlib.pyplot as plt\n", 127 | "plt.imshow(X_train[0, :, :])\n", 128 | "plt.show()\n", 129 | "print(y_train[0])" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": null, 135 | "metadata": { 136 | "colab": {}, 137 | "colab_type": "code", 138 | "id": "Tf9LiDGuNZe6" 139 | }, 140 | "outputs": [], 141 | "source": [ 142 | "X_train = X_train.unsqueeze(1).float()\n", 143 | "X_test = X_test.unsqueeze(1).float()" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": null, 149 | "metadata": { 150 | "colab": { 151 | "base_uri": "https://localhost:8080/", 152 | "height": 35 153 | }, 154 | "colab_type": "code", 155 | "id": "kxKAhEYHNZe-", 156 | "outputId": "5b8e9d61-4680-4b6c-8fa1-73e76490d019" 157 | }, 158 | "outputs": [], 159 | "source": [ 160 | "X_train.shape" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": null, 166 | "metadata": { 167 | "colab": {}, 168 | "colab_type": "code", 169 | "id": "xhsw9soDODel" 170 | }, 171 | "outputs": [], 172 | "source": [ 173 | "class LeNet5(torch.nn.Module):\n", 174 | " def __init__(self):\n", 175 | " super(LeNet5, self).__init__()\n", 176 | " \n", 177 | " self.conv1 = torch.nn.Conv2d(\n", 178 | " in_channels=1, out_channels=6, kernel_size=5, padding=2)\n", 179 | " self.act1 = torch.nn.Tanh()\n", 180 | " self.pool1 = torch.nn.AvgPool2d(kernel_size=2, stride=2)\n", 181 | " \n", 182 | " self.conv2 = torch.nn.Conv2d(\n", 183 | " in_channels=6, out_channels=16, kernel_size=5, padding=0)\n", 184 | " self.act2 = torch.nn.Tanh()\n", 185 | " self.pool2 = torch.nn.AvgPool2d(kernel_size=2, stride=2)\n", 186 | " \n", 187 | " self.fc1 = torch.nn.Linear(5 * 5 * 16, 120)\n", 188 | " self.act3 = torch.nn.Tanh()\n", 189 | " \n", 190 | " self.fc2 = torch.nn.Linear(120, 84)\n", 191 | " self.act4 = torch.nn.Tanh()\n", 192 | " \n", 193 | " self.fc3 = torch.nn.Linear(84, 10)\n", 194 | " \n", 195 | " def forward(self, x):\n", 196 | " \n", 197 | " x = self.conv1(x)\n", 198 | " x = self.act1(x)\n", 199 | " x = self.pool1(x)\n", 200 | " \n", 201 | " x = self.conv2(x)\n", 202 | " x = self.act2(x)\n", 203 | " x = self.pool2(x)\n", 204 | " \n", 205 | " x = x.view(x.size(0), x.size(1) * x.size(2) * x.size(3))\n", 206 | "\n", 207 | " x = self.fc1(x)\n", 208 | " x = self.act3(x)\n", 209 | " x = self.fc2(x)\n", 210 | " x = self.act4(x)\n", 211 | " x = self.fc3(x)\n", 212 | " \n", 213 | " return x\n", 214 | " \n", 215 | "lenet5 = LeNet5()" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": null, 221 | "metadata": { 222 | "colab": {}, 223 | "colab_type": "code", 224 | "id": "qT-PsO7VNZfB" 225 | }, 226 | "outputs": [], 227 | "source": [ 228 | "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n", 229 | "lenet5 = lenet5.to(device)" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": null, 235 | "metadata": { 236 | "colab": {}, 237 | "colab_type": "code", 238 | "id": "rkK0kv1VNZfL" 239 | }, 240 | "outputs": [], 241 | "source": [ 242 | "loss = torch.nn.CrossEntropyLoss()\n", 243 | "optimizer = torch.optim.Adam(lenet5.parameters(), lr=1.0e-3)" 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": null, 249 | "metadata": { 250 | "colab": { 251 | "base_uri": "https://localhost:8080/", 252 | "height": 399 253 | }, 254 | "colab_type": "code", 255 | "id": "XfA9gqSdNZfQ", 256 | "outputId": "d849c6a3-e134-4935-813b-b05f63a96ed6" 257 | }, 258 | "outputs": [], 259 | "source": [ 260 | "batch_size = 100\n", 261 | "\n", 262 | "test_accuracy_history = []\n", 263 | "test_loss_history = []\n", 264 | "\n", 265 | "X_test = X_test.to(device)\n", 266 | "y_test = y_test.to(device)\n", 267 | "\n", 268 | "for epoch in range(10000):\n", 269 | " order = np.random.permutation(len(X_train))\n", 270 | " for start_index in range(0, len(X_train), batch_size):\n", 271 | " optimizer.zero_grad()\n", 272 | " \n", 273 | " batch_indexes = order[start_index:start_index+batch_size]\n", 274 | " \n", 275 | " X_batch = X_train[batch_indexes].to(device)\n", 276 | " y_batch = y_train[batch_indexes].to(device)\n", 277 | " \n", 278 | " preds = lenet5.forward(X_batch) \n", 279 | " \n", 280 | " loss_value = loss(preds, y_batch)\n", 281 | " loss_value.backward()\n", 282 | " \n", 283 | " optimizer.step()\n", 284 | " \n", 285 | " test_preds = lenet5.forward(X_test)\n", 286 | " test_loss_history.append(loss(test_preds, y_test).data.cpu())\n", 287 | " \n", 288 | " accuracy = (test_preds.argmax(dim=1) == y_test).float().mean().data.cpu()\n", 289 | " test_accuracy_history.append(accuracy)\n", 290 | " \n", 291 | " print(accuracy)" 292 | ] 293 | }, 294 | { 295 | "cell_type": "code", 296 | "execution_count": null, 297 | "metadata": { 298 | "colab": {}, 299 | "colab_type": "code", 300 | "id": "H4hjogO8NZfS" 301 | }, 302 | "outputs": [], 303 | "source": [ 304 | "lenet5.forward(X_test)" 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": null, 310 | "metadata": { 311 | "colab": {}, 312 | "colab_type": "code", 313 | "id": "4FDtagQvNZfU" 314 | }, 315 | "outputs": [], 316 | "source": [ 317 | "# plt.plot(test_accuracy_history);\n", 318 | "plt.plot(test_loss_history);" 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": null, 324 | "metadata": { 325 | "colab": {}, 326 | "colab_type": "code", 327 | "id": "vta37dlSNZfZ" 328 | }, 329 | "outputs": [], 330 | "source": [] 331 | } 332 | ], 333 | "metadata": { 334 | "accelerator": "GPU", 335 | "colab": { 336 | "collapsed_sections": [], 337 | "name": "Lesson 6 Digits Recognition Convolutional Video.ipynb", 338 | "provenance": [], 339 | "version": "0.3.2" 340 | }, 341 | "kernelspec": { 342 | "display_name": "Python 3", 343 | "language": "python", 344 | "name": "python3" 345 | }, 346 | "language_info": { 347 | "codemirror_mode": { 348 | "name": "ipython", 349 | "version": 3 350 | }, 351 | "file_extension": ".py", 352 | "mimetype": "text/x-python", 353 | "name": "python", 354 | "nbconvert_exporter": "python", 355 | "pygments_lexer": "ipython3", 356 | "version": "3.6.8" 357 | } 358 | }, 359 | "nbformat": 4, 360 | "nbformat_minor": 1 361 | } 362 | -------------------------------------------------------------------------------- /module03_wine_prediction.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import torch\n", 10 | "import random\n", 11 | "import numpy as np\n", 12 | "\n", 13 | "random.seed(0)\n", 14 | "np.random.seed(0)\n", 15 | "torch.manual_seed(0)\n", 16 | "torch.cuda.manual_seed(0)\n", 17 | "torch.backends.cudnn.deterministic = True" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 2, 23 | "metadata": {}, 24 | "outputs": [ 25 | { 26 | "data": { 27 | "text/plain": [ 28 | "(178, 13)" 29 | ] 30 | }, 31 | "execution_count": 2, 32 | "metadata": {}, 33 | "output_type": "execute_result" 34 | } 35 | ], 36 | "source": [ 37 | "import sklearn.datasets\n", 38 | "wine = sklearn.datasets.load_wine()\n", 39 | "wine.data.shape" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": 3, 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [ 48 | "from sklearn.model_selection import train_test_split\n", 49 | "\n", 50 | "X_train, X_test, y_train, y_test = train_test_split(\n", 51 | " wine.data[:, :2], \n", 52 | " wine.target, \n", 53 | " test_size=0.3, \n", 54 | " shuffle=True)\n", 55 | "\n", 56 | "X_train = torch.FloatTensor(X_train)\n", 57 | "X_test = torch.FloatTensor(X_test)\n", 58 | "y_train = torch.LongTensor(y_train)\n", 59 | "y_test = torch.LongTensor(y_test)" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": 17, 65 | "metadata": {}, 66 | "outputs": [], 67 | "source": [ 68 | "class WineNet(torch.nn.Module):\n", 69 | " def __init__(self, n_hidden_neurons):\n", 70 | " super(WineNet, self).__init__()\n", 71 | " \n", 72 | " self.fc1 = torch.nn.Linear(2, n_hidden_neurons)\n", 73 | " self.activ1 = torch.nn.Sigmoid()\n", 74 | " self.fc2 = torch.nn.Linear(n_hidden_neurons, n_hidden_neurons)\n", 75 | " self.activ2 = torch.nn.Sigmoid()\n", 76 | " self.fc3 = torch.nn.Linear(n_hidden_neurons, 3)\n", 77 | " self.sm = torch.nn.Softmax(dim=1)\n", 78 | " \n", 79 | " def forward(self, x):\n", 80 | " x = self.fc1(x)\n", 81 | " x = self.activ1(x)\n", 82 | " x = self.fc2(x)\n", 83 | " x = self.activ2(x)\n", 84 | " x = self.fc3(x)\n", 85 | " return x\n", 86 | "\n", 87 | " def inference(self, x):\n", 88 | " x = self.forward(x)\n", 89 | " x = self.sm(x)\n", 90 | " return x\n", 91 | " \n", 92 | "wine_net = WineNet(5)" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": 18, 98 | "metadata": {}, 99 | "outputs": [], 100 | "source": [ 101 | "loss = torch.nn.CrossEntropyLoss()\n", 102 | "\n", 103 | "optimizer = torch.optim.Adam(wine_net.parameters(), \n", 104 | " lr=1.0e-3)" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 19, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "data": { 114 | "text/plain": [ 115 | "array([1, 3, 0, 4, 2])" 116 | ] 117 | }, 118 | "execution_count": 19, 119 | "metadata": {}, 120 | "output_type": "execute_result" 121 | } 122 | ], 123 | "source": [ 124 | "np.random.permutation(5)" 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": 20, 130 | "metadata": { 131 | "scrolled": false 132 | }, 133 | "outputs": [ 134 | { 135 | "name": "stdout", 136 | "output_type": "stream", 137 | "text": [ 138 | "tensor(0.3519)\n", 139 | "tensor(0.3889)\n", 140 | "tensor(0.5000)\n", 141 | "tensor(0.5000)\n", 142 | "tensor(0.5185)\n", 143 | "tensor(0.5370)\n", 144 | "tensor(0.5370)\n", 145 | "tensor(0.5370)\n", 146 | "tensor(0.7593)\n", 147 | "tensor(0.7778)\n", 148 | "tensor(0.8519)\n", 149 | "tensor(0.8519)\n", 150 | "tensor(0.8333)\n", 151 | "tensor(0.8519)\n", 152 | "tensor(0.8519)\n", 153 | "tensor(0.8519)\n", 154 | "tensor(0.8519)\n", 155 | "tensor(0.8704)\n", 156 | "tensor(0.8704)\n", 157 | "tensor(0.8704)\n", 158 | "tensor(0.8704)\n", 159 | "tensor(0.8704)\n", 160 | "tensor(0.8889)\n", 161 | "tensor(0.8704)\n", 162 | "tensor(0.9074)\n", 163 | "tensor(0.8889)\n", 164 | "tensor(0.8704)\n", 165 | "tensor(0.8889)\n", 166 | "tensor(0.8889)\n", 167 | "tensor(0.8704)\n", 168 | "tensor(0.8889)\n", 169 | "tensor(0.8889)\n", 170 | "tensor(0.8889)\n", 171 | "tensor(0.8704)\n", 172 | "tensor(0.9074)\n", 173 | "tensor(0.8889)\n", 174 | "tensor(0.8889)\n", 175 | "tensor(0.8704)\n", 176 | "tensor(0.8704)\n", 177 | "tensor(0.8704)\n", 178 | "tensor(0.8704)\n", 179 | "tensor(0.8704)\n", 180 | "tensor(0.8704)\n", 181 | "tensor(0.9074)\n", 182 | "tensor(0.8704)\n", 183 | "tensor(0.8704)\n", 184 | "tensor(0.8704)\n", 185 | "tensor(0.8704)\n", 186 | "tensor(0.8889)\n", 187 | "tensor(0.8704)\n" 188 | ] 189 | } 190 | ], 191 | "source": [ 192 | "batch_size = 10\n", 193 | "\n", 194 | "for epoch in range(5000):\n", 195 | " order = np.random.permutation(len(X_train))\n", 196 | " for start_index in range(0, len(X_train), batch_size):\n", 197 | " optimizer.zero_grad()\n", 198 | " \n", 199 | " batch_indexes = order[start_index:start_index+batch_size]\n", 200 | " \n", 201 | " x_batch = X_train[batch_indexes]\n", 202 | " y_batch = y_train[batch_indexes]\n", 203 | " \n", 204 | " preds = wine_net.forward(x_batch) \n", 205 | " \n", 206 | " loss_value = loss(preds, y_batch)\n", 207 | " loss_value.backward()\n", 208 | " \n", 209 | " optimizer.step()\n", 210 | " \n", 211 | " if epoch % 100 == 0:\n", 212 | " test_preds = wine_net.forward(X_test)\n", 213 | " test_preds = test_preds.argmax(dim=1)\n", 214 | " print((test_preds == y_test).float().mean())" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": 21, 220 | "metadata": {}, 221 | "outputs": [ 222 | { 223 | "data": { 224 | "image/png": "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\n", 225 | "text/plain": [ 226 | "
" 227 | ] 228 | }, 229 | "metadata": {}, 230 | "output_type": "display_data" 231 | } 232 | ], 233 | "source": [ 234 | "import matplotlib.pyplot as plt\n", 235 | "%matplotlib inline\n", 236 | "\n", 237 | "plt.rcParams['figure.figsize'] = (10, 8)\n", 238 | "\n", 239 | "n_classes = 3\n", 240 | "plot_colors = ['g', 'orange', 'black']\n", 241 | "plot_step = 0.02\n", 242 | "\n", 243 | "x_min, x_max = X_train[:, 0].min() - 1, X_train[:, 0].max() + 1\n", 244 | "y_min, y_max = X_train[:, 1].min() - 1, X_train[:, 1].max() + 1\n", 245 | "\n", 246 | "xx, yy = torch.meshgrid(torch.arange(x_min, x_max, plot_step),\n", 247 | " torch.arange(y_min, y_max, plot_step))\n", 248 | "\n", 249 | "preds = wine_net.inference(\n", 250 | " torch.cat([xx.reshape(-1, 1), yy.reshape(-1, 1)], dim=1))\n", 251 | "\n", 252 | "preds_class = preds.data.numpy().argmax(axis=1)\n", 253 | "preds_class = preds_class.reshape(xx.shape)\n", 254 | "plt.contourf(xx, yy, preds_class, cmap='Accent')\n", 255 | "\n", 256 | "for i, color in zip(range(n_classes), plot_colors):\n", 257 | " indexes = np.where(y_train == i)\n", 258 | " plt.scatter(X_train[indexes, 0], \n", 259 | " X_train[indexes, 1], \n", 260 | " c=color, \n", 261 | " label=wine.target_names[i],\n", 262 | " cmap='Accent')\n", 263 | " plt.xlabel(wine.feature_names[0])\n", 264 | " plt.ylabel(wine.feature_names[1])\n", 265 | " plt.legend()" 266 | ] 267 | }, 268 | { 269 | "cell_type": "code", 270 | "execution_count": null, 271 | "metadata": {}, 272 | "outputs": [], 273 | "source": [] 274 | } 275 | ], 276 | "metadata": { 277 | "anaconda-cloud": {}, 278 | "kernelspec": { 279 | "display_name": "Python 3", 280 | "language": "python", 281 | "name": "python3" 282 | }, 283 | "language_info": { 284 | "codemirror_mode": { 285 | "name": "ipython", 286 | "version": 3 287 | }, 288 | "file_extension": ".py", 289 | "mimetype": "text/x-python", 290 | "name": "python", 291 | "nbconvert_exporter": "python", 292 | "pygments_lexer": "ipython3", 293 | "version": "3.6.8" 294 | } 295 | }, 296 | "nbformat": 4, 297 | "nbformat_minor": 2 298 | } 299 | -------------------------------------------------------------------------------- /module01_basics.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "colab": { 7 | "base_uri": "https://localhost:8080/", 8 | "height": 949 9 | }, 10 | "colab_type": "code", 11 | "executionInfo": { 12 | "elapsed": 1704, 13 | "status": "error", 14 | "timestamp": 1553690684584, 15 | "user": { 16 | "displayName": "Igor Slinko", 17 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 18 | "userId": "00864276345820379450" 19 | }, 20 | "user_tz": -180 21 | }, 22 | "id": "HiASrOWHA930", 23 | "outputId": "9052c75e-70db-47b6-98ad-d76d22fcb18c" 24 | }, 25 | "source": [ 26 | "install pytorch as shown on the official site: https://pytorch.org" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 5, 32 | "metadata": { 33 | "colab": {}, 34 | "colab_type": "code", 35 | "id": "om5sXzJcBC3L" 36 | }, 37 | "outputs": [], 38 | "source": [ 39 | "import torch" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": 6, 45 | "metadata": { 46 | "colab": { 47 | "base_uri": "https://localhost:8080/", 48 | "height": 68 49 | }, 50 | "colab_type": "code", 51 | "executionInfo": { 52 | "elapsed": 8664, 53 | "status": "ok", 54 | "timestamp": 1553687458142, 55 | "user": { 56 | "displayName": "Igor Slinko", 57 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 58 | "userId": "00864276345820379450" 59 | }, 60 | "user_tz": -180 61 | }, 62 | "id": "fiz44QB73Ze6", 63 | "outputId": "e636c3ab-e363-42c8-fdfc-e8f9b3cb2dc3" 64 | }, 65 | "outputs": [ 66 | { 67 | "data": { 68 | "text/plain": [ 69 | "tensor([[0., 0., 0., 0.],\n", 70 | " [0., 0., 0., 0.],\n", 71 | " [0., 0., 0., 0.]])" 72 | ] 73 | }, 74 | "execution_count": 6, 75 | "metadata": {}, 76 | "output_type": "execute_result" 77 | } 78 | ], 79 | "source": [ 80 | "torch.zeros([3, 4])" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 7, 86 | "metadata": { 87 | "colab": { 88 | "base_uri": "https://localhost:8080/", 89 | "height": 255 90 | }, 91 | "colab_type": "code", 92 | "executionInfo": { 93 | "elapsed": 8646, 94 | "status": "ok", 95 | "timestamp": 1553687458144, 96 | "user": { 97 | "displayName": "Igor Slinko", 98 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 99 | "userId": "00864276345820379450" 100 | }, 101 | "user_tz": -180 102 | }, 103 | "id": "j_cGJRUI3eTT", 104 | "outputId": "69b649d7-8c8d-4111-cfd5-57d3682eb723" 105 | }, 106 | "outputs": [ 107 | { 108 | "data": { 109 | "text/plain": [ 110 | "tensor([[[1., 1.],\n", 111 | " [1., 1.],\n", 112 | " [1., 1.],\n", 113 | " [1., 1.]],\n", 114 | "\n", 115 | " [[1., 1.],\n", 116 | " [1., 1.],\n", 117 | " [1., 1.],\n", 118 | " [1., 1.]],\n", 119 | "\n", 120 | " [[1., 1.],\n", 121 | " [1., 1.],\n", 122 | " [1., 1.],\n", 123 | " [1., 1.]]])" 124 | ] 125 | }, 126 | "execution_count": 7, 127 | "metadata": {}, 128 | "output_type": "execute_result" 129 | } 130 | ], 131 | "source": [ 132 | "torch.ones([3, 4, 2])" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": 8, 138 | "metadata": { 139 | "colab": { 140 | "base_uri": "https://localhost:8080/", 141 | "height": 68 142 | }, 143 | "colab_type": "code", 144 | "executionInfo": { 145 | "elapsed": 8614, 146 | "status": "ok", 147 | "timestamp": 1553687458146, 148 | "user": { 149 | "displayName": "Igor Slinko", 150 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 151 | "userId": "00864276345820379450" 152 | }, 153 | "user_tz": -180 154 | }, 155 | "id": "66pYqNDB3fgW", 156 | "outputId": "65582665-f61a-4dcd-b1b5-da9803d17996" 157 | }, 158 | "outputs": [ 159 | { 160 | "data": { 161 | "text/plain": [ 162 | "tensor([[ 1., 2., 3., 4.],\n", 163 | " [ 5., 6., 7., 8.],\n", 164 | " [ 9., 10., 11., 12.]])" 165 | ] 166 | }, 167 | "execution_count": 8, 168 | "metadata": {}, 169 | "output_type": "execute_result" 170 | } 171 | ], 172 | "source": [ 173 | "torch.Tensor([[1, 2, 3, 4],\n", 174 | " [5, 6, 7, 8],\n", 175 | " [9, 10, 11, 12]])" 176 | ] 177 | }, 178 | { 179 | "cell_type": "code", 180 | "execution_count": 9, 181 | "metadata": { 182 | "colab": {}, 183 | "colab_type": "code", 184 | "id": "cuv_uYVK3nJi" 185 | }, 186 | "outputs": [], 187 | "source": [ 188 | "x = torch.Tensor([[1, 2, 3, 4],\n", 189 | " [5, 6, 7, 8],\n", 190 | " [9, 10, 11, 12]])" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": 10, 196 | "metadata": { 197 | "colab": { 198 | "base_uri": "https://localhost:8080/", 199 | "height": 34 200 | }, 201 | "colab_type": "code", 202 | "executionInfo": { 203 | "elapsed": 8591, 204 | "status": "ok", 205 | "timestamp": 1553687458151, 206 | "user": { 207 | "displayName": "Igor Slinko", 208 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 209 | "userId": "00864276345820379450" 210 | }, 211 | "user_tz": -180 212 | }, 213 | "id": "vMcUsd3X3vg-", 214 | "outputId": "487e2919-0875-4df0-ab62-0d1695710a55" 215 | }, 216 | "outputs": [ 217 | { 218 | "data": { 219 | "text/plain": [ 220 | "torch.Size([3, 4])" 221 | ] 222 | }, 223 | "execution_count": 10, 224 | "metadata": {}, 225 | "output_type": "execute_result" 226 | } 227 | ], 228 | "source": [ 229 | "x.size()" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 11, 235 | "metadata": { 236 | "colab": { 237 | "base_uri": "https://localhost:8080/", 238 | "height": 34 239 | }, 240 | "colab_type": "code", 241 | "executionInfo": { 242 | "elapsed": 8570, 243 | "status": "ok", 244 | "timestamp": 1553687458152, 245 | "user": { 246 | "displayName": "Igor Slinko", 247 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 248 | "userId": "00864276345820379450" 249 | }, 250 | "user_tz": -180 251 | }, 252 | "id": "nN6e9os44dK-", 253 | "outputId": "d0bfebe2-c229-4640-c991-9b766ea51a51" 254 | }, 255 | "outputs": [ 256 | { 257 | "data": { 258 | "text/plain": [ 259 | "torch.Size([3, 4])" 260 | ] 261 | }, 262 | "execution_count": 11, 263 | "metadata": {}, 264 | "output_type": "execute_result" 265 | } 266 | ], 267 | "source": [ 268 | "x.shape" 269 | ] 270 | }, 271 | { 272 | "cell_type": "code", 273 | "execution_count": 12, 274 | "metadata": { 275 | "colab": { 276 | "base_uri": "https://localhost:8080/", 277 | "height": 34 278 | }, 279 | "colab_type": "code", 280 | "executionInfo": { 281 | "elapsed": 8567, 282 | "status": "ok", 283 | "timestamp": 1553687458154, 284 | "user": { 285 | "displayName": "Igor Slinko", 286 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 287 | "userId": "00864276345820379450" 288 | }, 289 | "user_tz": -180 290 | }, 291 | "id": "3RRI7chI4Ylr", 292 | "outputId": "a0428536-a285-4921-94ab-ac35973e86e8" 293 | }, 294 | "outputs": [ 295 | { 296 | "data": { 297 | "text/plain": [ 298 | "tensor([1., 2., 3., 4.])" 299 | ] 300 | }, 301 | "execution_count": 12, 302 | "metadata": {}, 303 | "output_type": "execute_result" 304 | } 305 | ], 306 | "source": [ 307 | "x[0]" 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": 13, 313 | "metadata": { 314 | "colab": { 315 | "base_uri": "https://localhost:8080/", 316 | "height": 34 317 | }, 318 | "colab_type": "code", 319 | "executionInfo": { 320 | "elapsed": 8568, 321 | "status": "ok", 322 | "timestamp": 1553687458156, 323 | "user": { 324 | "displayName": "Igor Slinko", 325 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 326 | "userId": "00864276345820379450" 327 | }, 328 | "user_tz": -180 329 | }, 330 | "id": "2Nlpkodx5q9k", 331 | "outputId": "292e8e2d-d31d-4ab3-d1de-9b6079dd48e1" 332 | }, 333 | "outputs": [ 334 | { 335 | "data": { 336 | "text/plain": [ 337 | "tensor([5., 6., 7., 8.])" 338 | ] 339 | }, 340 | "execution_count": 13, 341 | "metadata": {}, 342 | "output_type": "execute_result" 343 | } 344 | ], 345 | "source": [ 346 | "x[1]" 347 | ] 348 | }, 349 | { 350 | "cell_type": "code", 351 | "execution_count": 14, 352 | "metadata": { 353 | "colab": { 354 | "base_uri": "https://localhost:8080/", 355 | "height": 34 356 | }, 357 | "colab_type": "code", 358 | "executionInfo": { 359 | "elapsed": 8568, 360 | "status": "ok", 361 | "timestamp": 1553687458157, 362 | "user": { 363 | "displayName": "Igor Slinko", 364 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 365 | "userId": "00864276345820379450" 366 | }, 367 | "user_tz": -180 368 | }, 369 | "id": "jBL5d47Z5sAk", 370 | "outputId": "70c4e7d2-59b3-4b11-d69e-5ddc83812597" 371 | }, 372 | "outputs": [ 373 | { 374 | "data": { 375 | "text/plain": [ 376 | "tensor(1.)" 377 | ] 378 | }, 379 | "execution_count": 14, 380 | "metadata": {}, 381 | "output_type": "execute_result" 382 | } 383 | ], 384 | "source": [ 385 | "x[0, 0]" 386 | ] 387 | }, 388 | { 389 | "cell_type": "code", 390 | "execution_count": 15, 391 | "metadata": { 392 | "colab": { 393 | "base_uri": "https://localhost:8080/", 394 | "height": 34 395 | }, 396 | "colab_type": "code", 397 | "executionInfo": { 398 | "elapsed": 8568, 399 | "status": "ok", 400 | "timestamp": 1553687458158, 401 | "user": { 402 | "displayName": "Igor Slinko", 403 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 404 | "userId": "00864276345820379450" 405 | }, 406 | "user_tz": -180 407 | }, 408 | "id": "DQjQMUzk4MeM", 409 | "outputId": "acfcaae6-370f-4f5b-f23f-668c4777ad3b" 410 | }, 411 | "outputs": [ 412 | { 413 | "data": { 414 | "text/plain": [ 415 | "tensor([1., 5., 9.])" 416 | ] 417 | }, 418 | "execution_count": 15, 419 | "metadata": {}, 420 | "output_type": "execute_result" 421 | } 422 | ], 423 | "source": [ 424 | "x[:, 0]" 425 | ] 426 | }, 427 | { 428 | "cell_type": "code", 429 | "execution_count": 16, 430 | "metadata": { 431 | "colab": { 432 | "base_uri": "https://localhost:8080/", 433 | "height": 68 434 | }, 435 | "colab_type": "code", 436 | "executionInfo": { 437 | "elapsed": 8567, 438 | "status": "ok", 439 | "timestamp": 1553687458159, 440 | "user": { 441 | "displayName": "Igor Slinko", 442 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 443 | "userId": "00864276345820379450" 444 | }, 445 | "user_tz": -180 446 | }, 447 | "id": "byVTqgRs5FhK", 448 | "outputId": "a55cd10e-dcf2-4257-e889-80b0a2acff24" 449 | }, 450 | "outputs": [ 451 | { 452 | "data": { 453 | "text/plain": [ 454 | "tensor([[11., 12., 13., 14.],\n", 455 | " [15., 16., 17., 18.],\n", 456 | " [19., 20., 21., 22.]])" 457 | ] 458 | }, 459 | "execution_count": 16, 460 | "metadata": {}, 461 | "output_type": "execute_result" 462 | } 463 | ], 464 | "source": [ 465 | "x + 10" 466 | ] 467 | }, 468 | { 469 | "cell_type": "code", 470 | "execution_count": 17, 471 | "metadata": { 472 | "colab": { 473 | "base_uri": "https://localhost:8080/", 474 | "height": 68 475 | }, 476 | "colab_type": "code", 477 | "executionInfo": { 478 | "elapsed": 8567, 479 | "status": "ok", 480 | "timestamp": 1553687458160, 481 | "user": { 482 | "displayName": "Igor Slinko", 483 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 484 | "userId": "00864276345820379450" 485 | }, 486 | "user_tz": -180 487 | }, 488 | "id": "voNgwBHgKSM8", 489 | "outputId": "3251c663-c1af-44b7-e9c3-7e5ff1e1f1ec" 490 | }, 491 | "outputs": [ 492 | { 493 | "data": { 494 | "text/plain": [ 495 | "tensor([[ 1., 4., 9., 16.],\n", 496 | " [ 25., 36., 49., 64.],\n", 497 | " [ 81., 100., 121., 144.]])" 498 | ] 499 | }, 500 | "execution_count": 17, 501 | "metadata": {}, 502 | "output_type": "execute_result" 503 | } 504 | ], 505 | "source": [ 506 | "x ** 2" 507 | ] 508 | }, 509 | { 510 | "cell_type": "code", 511 | "execution_count": 18, 512 | "metadata": { 513 | "colab": {}, 514 | "colab_type": "code", 515 | "id": "mysY9wcSKX3_" 516 | }, 517 | "outputs": [], 518 | "source": [ 519 | "y = torch.Tensor([[12, 11, 10, 9],\n", 520 | " [8, 7, 6, 5],\n", 521 | " [4, 3, 2, 1]])" 522 | ] 523 | }, 524 | { 525 | "cell_type": "code", 526 | "execution_count": 19, 527 | "metadata": { 528 | "colab": { 529 | "base_uri": "https://localhost:8080/", 530 | "height": 68 531 | }, 532 | "colab_type": "code", 533 | "executionInfo": { 534 | "elapsed": 9289, 535 | "status": "ok", 536 | "timestamp": 1553687458885, 537 | "user": { 538 | "displayName": "Igor Slinko", 539 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 540 | "userId": "00864276345820379450" 541 | }, 542 | "user_tz": -180 543 | }, 544 | "id": "hpaaLUopK5mK", 545 | "outputId": "11691b91-26c0-44ec-c7f4-3c55bc48bc1a" 546 | }, 547 | "outputs": [ 548 | { 549 | "data": { 550 | "text/plain": [ 551 | "tensor([[13., 13., 13., 13.],\n", 552 | " [13., 13., 13., 13.],\n", 553 | " [13., 13., 13., 13.]])" 554 | ] 555 | }, 556 | "execution_count": 19, 557 | "metadata": {}, 558 | "output_type": "execute_result" 559 | } 560 | ], 561 | "source": [ 562 | "x + y" 563 | ] 564 | }, 565 | { 566 | "cell_type": "code", 567 | "execution_count": 20, 568 | "metadata": { 569 | "colab": { 570 | "base_uri": "https://localhost:8080/", 571 | "height": 68 572 | }, 573 | "colab_type": "code", 574 | "executionInfo": { 575 | "elapsed": 9290, 576 | "status": "ok", 577 | "timestamp": 1553687458887, 578 | "user": { 579 | "displayName": "Igor Slinko", 580 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 581 | "userId": "00864276345820379450" 582 | }, 583 | "user_tz": -180 584 | }, 585 | "id": "aUw1jh6fK66y", 586 | "outputId": "1b32ded6-521a-4a3f-f52f-a8a64581aa34" 587 | }, 588 | "outputs": [ 589 | { 590 | "data": { 591 | "text/plain": [ 592 | "tensor([[12., 22., 30., 36.],\n", 593 | " [40., 42., 42., 40.],\n", 594 | " [36., 30., 22., 12.]])" 595 | ] 596 | }, 597 | "execution_count": 20, 598 | "metadata": {}, 599 | "output_type": "execute_result" 600 | } 601 | ], 602 | "source": [ 603 | "x * y" 604 | ] 605 | }, 606 | { 607 | "cell_type": "code", 608 | "execution_count": 21, 609 | "metadata": { 610 | "colab": { 611 | "base_uri": "https://localhost:8080/", 612 | "height": 68 613 | }, 614 | "colab_type": "code", 615 | "executionInfo": { 616 | "elapsed": 9290, 617 | "status": "ok", 618 | "timestamp": 1553687458888, 619 | "user": { 620 | "displayName": "Igor Slinko", 621 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 622 | "userId": "00864276345820379450" 623 | }, 624 | "user_tz": -180 625 | }, 626 | "id": "aCaj6e65K8Vi", 627 | "outputId": "e4fa966c-3bbc-4a0b-e1af-b5e4650a5573" 628 | }, 629 | "outputs": [ 630 | { 631 | "data": { 632 | "text/plain": [ 633 | "tensor([[ 0.0833, 0.1818, 0.3000, 0.4444],\n", 634 | " [ 0.6250, 0.8571, 1.1667, 1.6000],\n", 635 | " [ 2.2500, 3.3333, 5.5000, 12.0000]])" 636 | ] 637 | }, 638 | "execution_count": 21, 639 | "metadata": {}, 640 | "output_type": "execute_result" 641 | } 642 | ], 643 | "source": [ 644 | "x / y" 645 | ] 646 | }, 647 | { 648 | "cell_type": "code", 649 | "execution_count": 22, 650 | "metadata": { 651 | "colab": { 652 | "base_uri": "https://localhost:8080/", 653 | "height": 68 654 | }, 655 | "colab_type": "code", 656 | "executionInfo": { 657 | "elapsed": 9289, 658 | "status": "ok", 659 | "timestamp": 1553687458889, 660 | "user": { 661 | "displayName": "Igor Slinko", 662 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 663 | "userId": "00864276345820379450" 664 | }, 665 | "user_tz": -180 666 | }, 667 | "id": "gsbIAdGEK9ZZ", 668 | "outputId": "95eb6e6f-9055-4213-edbd-e8b70a9b059f" 669 | }, 670 | "outputs": [ 671 | { 672 | "data": { 673 | "text/plain": [ 674 | "tensor([[1., 2., 3., 4.],\n", 675 | " [5., 6., 1., 3.],\n", 676 | " [1., 1., 1., 0.]])" 677 | ] 678 | }, 679 | "execution_count": 22, 680 | "metadata": {}, 681 | "output_type": "execute_result" 682 | } 683 | ], 684 | "source": [ 685 | "x % y" 686 | ] 687 | }, 688 | { 689 | "cell_type": "code", 690 | "execution_count": 23, 691 | "metadata": { 692 | "colab": { 693 | "base_uri": "https://localhost:8080/", 694 | "height": 68 695 | }, 696 | "colab_type": "code", 697 | "executionInfo": { 698 | "elapsed": 9289, 699 | "status": "ok", 700 | "timestamp": 1553687458890, 701 | "user": { 702 | "displayName": "Igor Slinko", 703 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 704 | "userId": "00864276345820379450" 705 | }, 706 | "user_tz": -180 707 | }, 708 | "id": "2nyUclPkLDLg", 709 | "outputId": "c9413c9f-5e78-474e-a381-7d85a7e8efb2" 710 | }, 711 | "outputs": [ 712 | { 713 | "data": { 714 | "text/plain": [ 715 | "tensor([[2.7183e+00, 7.3891e+00, 2.0086e+01, 5.4598e+01],\n", 716 | " [1.4841e+02, 4.0343e+02, 1.0966e+03, 2.9810e+03],\n", 717 | " [8.1031e+03, 2.2026e+04, 5.9874e+04, 1.6275e+05]])" 718 | ] 719 | }, 720 | "execution_count": 23, 721 | "metadata": {}, 722 | "output_type": "execute_result" 723 | } 724 | ], 725 | "source": [ 726 | "torch.exp(x)" 727 | ] 728 | }, 729 | { 730 | "cell_type": "code", 731 | "execution_count": 24, 732 | "metadata": { 733 | "colab": { 734 | "base_uri": "https://localhost:8080/", 735 | "height": 68 736 | }, 737 | "colab_type": "code", 738 | "executionInfo": { 739 | "elapsed": 9289, 740 | "status": "ok", 741 | "timestamp": 1553687458891, 742 | "user": { 743 | "displayName": "Igor Slinko", 744 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 745 | "userId": "00864276345820379450" 746 | }, 747 | "user_tz": -180 748 | }, 749 | "id": "VYQEuS8pLT8I", 750 | "outputId": "f6c3345e-4a01-44d3-8bbc-5876affa724b" 751 | }, 752 | "outputs": [ 753 | { 754 | "data": { 755 | "text/plain": [ 756 | "tensor([[0.0000, 0.6931, 1.0986, 1.3863],\n", 757 | " [1.6094, 1.7918, 1.9459, 2.0794],\n", 758 | " [2.1972, 2.3026, 2.3979, 2.4849]])" 759 | ] 760 | }, 761 | "execution_count": 24, 762 | "metadata": {}, 763 | "output_type": "execute_result" 764 | } 765 | ], 766 | "source": [ 767 | "torch.log(x)" 768 | ] 769 | }, 770 | { 771 | "cell_type": "code", 772 | "execution_count": 25, 773 | "metadata": { 774 | "colab": { 775 | "base_uri": "https://localhost:8080/", 776 | "height": 68 777 | }, 778 | "colab_type": "code", 779 | "executionInfo": { 780 | "elapsed": 9288, 781 | "status": "ok", 782 | "timestamp": 1553687458892, 783 | "user": { 784 | "displayName": "Igor Slinko", 785 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 786 | "userId": "00864276345820379450" 787 | }, 788 | "user_tz": -180 789 | }, 790 | "id": "SPZjB3JWLWX-", 791 | "outputId": "f9a723b7-db70-42a8-e592-4ca00e2af86f" 792 | }, 793 | "outputs": [ 794 | { 795 | "data": { 796 | "text/plain": [ 797 | "tensor([[ 0.8415, 0.9093, 0.1411, -0.7568],\n", 798 | " [-0.9589, -0.2794, 0.6570, 0.9894],\n", 799 | " [ 0.4121, -0.5440, -1.0000, -0.5366]])" 800 | ] 801 | }, 802 | "execution_count": 25, 803 | "metadata": {}, 804 | "output_type": "execute_result" 805 | } 806 | ], 807 | "source": [ 808 | "torch.sin(x)" 809 | ] 810 | }, 811 | { 812 | "cell_type": "code", 813 | "execution_count": 26, 814 | "metadata": { 815 | "colab": { 816 | "base_uri": "https://localhost:8080/", 817 | "height": 68 818 | }, 819 | "colab_type": "code", 820 | "executionInfo": { 821 | "elapsed": 9288, 822 | "status": "ok", 823 | "timestamp": 1553687458893, 824 | "user": { 825 | "displayName": "Igor Slinko", 826 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 827 | "userId": "00864276345820379450" 828 | }, 829 | "user_tz": -180 830 | }, 831 | "id": "0BYJe2WALg-t", 832 | "outputId": "623d3433-a258-4f3e-f480-8df7e604b4a0" 833 | }, 834 | "outputs": [ 835 | { 836 | "data": { 837 | "text/plain": [ 838 | "tensor([[0, 0, 0, 1],\n", 839 | " [1, 1, 1, 1],\n", 840 | " [1, 1, 1, 1]], dtype=torch.uint8)" 841 | ] 842 | }, 843 | "execution_count": 26, 844 | "metadata": {}, 845 | "output_type": "execute_result" 846 | } 847 | ], 848 | "source": [ 849 | "x > 3" 850 | ] 851 | }, 852 | { 853 | "cell_type": "code", 854 | "execution_count": 27, 855 | "metadata": { 856 | "colab": {}, 857 | "colab_type": "code", 858 | "id": "-wFJjbhJLjYs" 859 | }, 860 | "outputs": [], 861 | "source": [ 862 | "mask = x > 3" 863 | ] 864 | }, 865 | { 866 | "cell_type": "code", 867 | "execution_count": 28, 868 | "metadata": { 869 | "colab": { 870 | "base_uri": "https://localhost:8080/", 871 | "height": 34 872 | }, 873 | "colab_type": "code", 874 | "executionInfo": { 875 | "elapsed": 8868, 876 | "status": "ok", 877 | "timestamp": 1553687458897, 878 | "user": { 879 | "displayName": "Igor Slinko", 880 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 881 | "userId": "00864276345820379450" 882 | }, 883 | "user_tz": -180 884 | }, 885 | "id": "goCMRtShLpDv", 886 | "outputId": "de64d27c-6b89-4397-cbc4-06fa53495490" 887 | }, 888 | "outputs": [ 889 | { 890 | "data": { 891 | "text/plain": [ 892 | "tensor([ 4., 5., 6., 7., 8., 9., 10., 11., 12.])" 893 | ] 894 | }, 895 | "execution_count": 28, 896 | "metadata": {}, 897 | "output_type": "execute_result" 898 | } 899 | ], 900 | "source": [ 901 | "x[mask]" 902 | ] 903 | }, 904 | { 905 | "cell_type": "code", 906 | "execution_count": 29, 907 | "metadata": { 908 | "colab": { 909 | "base_uri": "https://localhost:8080/", 910 | "height": 34 911 | }, 912 | "colab_type": "code", 913 | "executionInfo": { 914 | "elapsed": 8522, 915 | "status": "ok", 916 | "timestamp": 1553687458899, 917 | "user": { 918 | "displayName": "Igor Slinko", 919 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 920 | "userId": "00864276345820379450" 921 | }, 922 | "user_tz": -180 923 | }, 924 | "id": "eG2THgYYLrH4", 925 | "outputId": "4bc73d8d-3edb-4f7b-a6c1-0607e9ffabe2" 926 | }, 927 | "outputs": [ 928 | { 929 | "data": { 930 | "text/plain": [ 931 | "tensor([ 4., 5., 6., 7., 8., 9., 10., 11., 12.])" 932 | ] 933 | }, 934 | "execution_count": 29, 935 | "metadata": {}, 936 | "output_type": "execute_result" 937 | } 938 | ], 939 | "source": [ 940 | "x[x > 3]" 941 | ] 942 | }, 943 | { 944 | "cell_type": "code", 945 | "execution_count": 30, 946 | "metadata": { 947 | "colab": { 948 | "base_uri": "https://localhost:8080/", 949 | "height": 119 950 | }, 951 | "colab_type": "code", 952 | "executionInfo": { 953 | "elapsed": 8095, 954 | "status": "ok", 955 | "timestamp": 1553687458901, 956 | "user": { 957 | "displayName": "Igor Slinko", 958 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 959 | "userId": "00864276345820379450" 960 | }, 961 | "user_tz": -180 962 | }, 963 | "id": "fdwVdDnmLzd2", 964 | "outputId": "513c155a-e0c8-4ac4-e906-a1f568658127" 965 | }, 966 | "outputs": [ 967 | { 968 | "name": "stdout", 969 | "output_type": "stream", 970 | "text": [ 971 | "tensor([[999., 2., 3., 4.],\n", 972 | " [ 5., 6., 7., 8.],\n", 973 | " [ 9., 10., 11., 12.]])\n", 974 | "tensor([[999., 2., 3., 4.],\n", 975 | " [ 5., 6., 7., 8.],\n", 976 | " [ 9., 10., 11., 12.]])\n" 977 | ] 978 | } 979 | ], 980 | "source": [ 981 | "y = x\n", 982 | "y[0, 0] = 999\n", 983 | "print(x)\n", 984 | "print(y)" 985 | ] 986 | }, 987 | { 988 | "cell_type": "code", 989 | "execution_count": 31, 990 | "metadata": { 991 | "colab": {}, 992 | "colab_type": "code", 993 | "id": "KZA2-dvvMk1P" 994 | }, 995 | "outputs": [], 996 | "source": [ 997 | "x = torch.Tensor([[1, 2, 3, 4],\n", 998 | " [5, 6, 7, 8],\n", 999 | " [9, 10, 11, 12]])" 1000 | ] 1001 | }, 1002 | { 1003 | "cell_type": "code", 1004 | "execution_count": 32, 1005 | "metadata": { 1006 | "colab": { 1007 | "base_uri": "https://localhost:8080/", 1008 | "height": 119 1009 | }, 1010 | "colab_type": "code", 1011 | "executionInfo": { 1012 | "elapsed": 7222, 1013 | "status": "ok", 1014 | "timestamp": 1553687458906, 1015 | "user": { 1016 | "displayName": "Igor Slinko", 1017 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 1018 | "userId": "00864276345820379450" 1019 | }, 1020 | "user_tz": -180 1021 | }, 1022 | "id": "lgePj3UPMRUA", 1023 | "outputId": "40f0c065-29df-4fb0-c344-3e6ceedb004d" 1024 | }, 1025 | "outputs": [ 1026 | { 1027 | "name": "stdout", 1028 | "output_type": "stream", 1029 | "text": [ 1030 | "tensor([[ 1., 2., 3., 4.],\n", 1031 | " [ 5., 6., 7., 8.],\n", 1032 | " [ 9., 10., 11., 12.]])\n", 1033 | "tensor([[999., 2., 3., 4.],\n", 1034 | " [ 5., 6., 7., 8.],\n", 1035 | " [ 9., 10., 11., 12.]])\n" 1036 | ] 1037 | } 1038 | ], 1039 | "source": [ 1040 | "y = x.clone()\n", 1041 | "y[0, 0] = 999\n", 1042 | "print(x)\n", 1043 | "print(y)" 1044 | ] 1045 | }, 1046 | { 1047 | "cell_type": "code", 1048 | "execution_count": 33, 1049 | "metadata": { 1050 | "colab": { 1051 | "base_uri": "https://localhost:8080/", 1052 | "height": 34 1053 | }, 1054 | "colab_type": "code", 1055 | "executionInfo": { 1056 | "elapsed": 6941, 1057 | "status": "ok", 1058 | "timestamp": 1553687458908, 1059 | "user": { 1060 | "displayName": "Igor Slinko", 1061 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 1062 | "userId": "00864276345820379450" 1063 | }, 1064 | "user_tz": -180 1065 | }, 1066 | "id": "qvbFh7jqOLZQ", 1067 | "outputId": "8ad47ea8-bf18-4dd6-967b-f9d351edb798" 1068 | }, 1069 | "outputs": [ 1070 | { 1071 | "data": { 1072 | "text/plain": [ 1073 | "torch.float32" 1074 | ] 1075 | }, 1076 | "execution_count": 33, 1077 | "metadata": {}, 1078 | "output_type": "execute_result" 1079 | } 1080 | ], 1081 | "source": [ 1082 | "x.dtype" 1083 | ] 1084 | }, 1085 | { 1086 | "cell_type": "code", 1087 | "execution_count": 34, 1088 | "metadata": { 1089 | "colab": { 1090 | "base_uri": "https://localhost:8080/", 1091 | "height": 170 1092 | }, 1093 | "colab_type": "code", 1094 | "executionInfo": { 1095 | "elapsed": 6421, 1096 | "status": "ok", 1097 | "timestamp": 1553687458909, 1098 | "user": { 1099 | "displayName": "Igor Slinko", 1100 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 1101 | "userId": "00864276345820379450" 1102 | }, 1103 | "user_tz": -180 1104 | }, 1105 | "id": "hgbQ5DimN52l", 1106 | "outputId": "dccd15ac-7662-4856-8925-f2bb192c4978" 1107 | }, 1108 | "outputs": [ 1109 | { 1110 | "name": "stdout", 1111 | "output_type": "stream", 1112 | "text": [ 1113 | "tensor([[ 1., 2., 3., 4.],\n", 1114 | " [ 5., 6., 7., 8.],\n", 1115 | " [ 9., 10., 11., 12.]], dtype=torch.float64)\n", 1116 | "tensor([[ 1, 2, 3, 4],\n", 1117 | " [ 5, 6, 7, 8],\n", 1118 | " [ 9, 10, 11, 12]], dtype=torch.int32)\n", 1119 | "tensor([[ 1., 2., 3., 4.],\n", 1120 | " [ 5., 6., 7., 8.],\n", 1121 | " [ 9., 10., 11., 12.]])\n" 1122 | ] 1123 | } 1124 | ], 1125 | "source": [ 1126 | "x = x.double()\n", 1127 | "print(x)\n", 1128 | "x = x.int()\n", 1129 | "print(x)\n", 1130 | "x = x.float()\n", 1131 | "print(x)" 1132 | ] 1133 | }, 1134 | { 1135 | "cell_type": "code", 1136 | "execution_count": 35, 1137 | "metadata": { 1138 | "colab": { 1139 | "base_uri": "https://localhost:8080/", 1140 | "height": 51 1141 | }, 1142 | "colab_type": "code", 1143 | "executionInfo": { 1144 | "elapsed": 6234, 1145 | "status": "ok", 1146 | "timestamp": 1553687458910, 1147 | "user": { 1148 | "displayName": "Igor Slinko", 1149 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 1150 | "userId": "00864276345820379450" 1151 | }, 1152 | "user_tz": -180 1153 | }, 1154 | "id": "MEYxh-ZVOVZC", 1155 | "outputId": "0d9e926e-ddcb-43aa-c467-1d5da612dbcb" 1156 | }, 1157 | "outputs": [ 1158 | { 1159 | "data": { 1160 | "text/plain": [ 1161 | "array([[1, 2, 3, 4],\n", 1162 | " [4, 3, 2, 1]])" 1163 | ] 1164 | }, 1165 | "execution_count": 35, 1166 | "metadata": {}, 1167 | "output_type": "execute_result" 1168 | } 1169 | ], 1170 | "source": [ 1171 | "import numpy as np\n", 1172 | "x = np.array([[1, 2, 3, 4],\n", 1173 | " [4, 3, 2, 1]])\n", 1174 | "x" 1175 | ] 1176 | }, 1177 | { 1178 | "cell_type": "code", 1179 | "execution_count": 36, 1180 | "metadata": { 1181 | "colab": { 1182 | "base_uri": "https://localhost:8080/", 1183 | "height": 51 1184 | }, 1185 | "colab_type": "code", 1186 | "executionInfo": { 1187 | "elapsed": 5952, 1188 | "status": "ok", 1189 | "timestamp": 1553687458912, 1190 | "user": { 1191 | "displayName": "Igor Slinko", 1192 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 1193 | "userId": "00864276345820379450" 1194 | }, 1195 | "user_tz": -180 1196 | }, 1197 | "id": "oCwKn4RMOei2", 1198 | "outputId": "e2e0ad7a-c68e-42a5-9d70-f1433f28fddb" 1199 | }, 1200 | "outputs": [ 1201 | { 1202 | "data": { 1203 | "text/plain": [ 1204 | "tensor([[1, 2, 3, 4],\n", 1205 | " [4, 3, 2, 1]])" 1206 | ] 1207 | }, 1208 | "execution_count": 36, 1209 | "metadata": {}, 1210 | "output_type": "execute_result" 1211 | } 1212 | ], 1213 | "source": [ 1214 | "x = torch.from_numpy(x)\n", 1215 | "x" 1216 | ] 1217 | }, 1218 | { 1219 | "cell_type": "code", 1220 | "execution_count": 37, 1221 | "metadata": { 1222 | "colab": { 1223 | "base_uri": "https://localhost:8080/", 1224 | "height": 51 1225 | }, 1226 | "colab_type": "code", 1227 | "executionInfo": { 1228 | "elapsed": 5766, 1229 | "status": "ok", 1230 | "timestamp": 1553687458914, 1231 | "user": { 1232 | "displayName": "Igor Slinko", 1233 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 1234 | "userId": "00864276345820379450" 1235 | }, 1236 | "user_tz": -180 1237 | }, 1238 | "id": "dGooyQjtOi9k", 1239 | "outputId": "4f73f842-c7d8-4dfe-ccc6-d462e92d93d9" 1240 | }, 1241 | "outputs": [ 1242 | { 1243 | "data": { 1244 | "text/plain": [ 1245 | "array([[1, 2, 3, 4],\n", 1246 | " [4, 3, 2, 1]])" 1247 | ] 1248 | }, 1249 | "execution_count": 37, 1250 | "metadata": {}, 1251 | "output_type": "execute_result" 1252 | } 1253 | ], 1254 | "source": [ 1255 | "x = x.numpy()\n", 1256 | "x" 1257 | ] 1258 | }, 1259 | { 1260 | "cell_type": "code", 1261 | "execution_count": 38, 1262 | "metadata": { 1263 | "colab": {}, 1264 | "colab_type": "code", 1265 | "id": "tFDksYpTPSJb" 1266 | }, 1267 | "outputs": [], 1268 | "source": [ 1269 | "x = torch.rand([2000,3000])\n", 1270 | "# x" 1271 | ] 1272 | }, 1273 | { 1274 | "cell_type": "code", 1275 | "execution_count": 40, 1276 | "metadata": {}, 1277 | "outputs": [ 1278 | { 1279 | "data": { 1280 | "text/plain": [ 1281 | "True" 1282 | ] 1283 | }, 1284 | "execution_count": 40, 1285 | "metadata": {}, 1286 | "output_type": "execute_result" 1287 | } 1288 | ], 1289 | "source": [ 1290 | "torch.cuda.is_available()" 1291 | ] 1292 | }, 1293 | { 1294 | "cell_type": "code", 1295 | "execution_count": 0, 1296 | "metadata": { 1297 | "colab": { 1298 | "base_uri": "https://localhost:8080/", 1299 | "height": 34 1300 | }, 1301 | "colab_type": "code", 1302 | "executionInfo": { 1303 | "elapsed": 5053, 1304 | "status": "ok", 1305 | "timestamp": 1553687458919, 1306 | "user": { 1307 | "displayName": "Igor Slinko", 1308 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 1309 | "userId": "00864276345820379450" 1310 | }, 1311 | "user_tz": -180 1312 | }, 1313 | "id": "z1JH-OzURJgm", 1314 | "outputId": "dc9ca01d-9508-404e-d0fc-cb91882531ee" 1315 | }, 1316 | "outputs": [ 1317 | { 1318 | "data": { 1319 | "text/plain": [ 1320 | "device(type='cuda', index=0)" 1321 | ] 1322 | }, 1323 | "execution_count": 37, 1324 | "metadata": { 1325 | "tags": [] 1326 | }, 1327 | "output_type": "execute_result" 1328 | } 1329 | ], 1330 | "source": [ 1331 | "torch.device('cuda:0')" 1332 | ] 1333 | }, 1334 | { 1335 | "cell_type": "code", 1336 | "execution_count": 0, 1337 | "metadata": { 1338 | "colab": { 1339 | "base_uri": "https://localhost:8080/", 1340 | "height": 34 1341 | }, 1342 | "colab_type": "code", 1343 | "executionInfo": { 1344 | "elapsed": 4909, 1345 | "status": "ok", 1346 | "timestamp": 1553687458920, 1347 | "user": { 1348 | "displayName": "Igor Slinko", 1349 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 1350 | "userId": "00864276345820379450" 1351 | }, 1352 | "user_tz": -180 1353 | }, 1354 | "id": "KopsvEhWRVCG", 1355 | "outputId": "6bc2305f-bc76-49ec-8154-0808fc492ff5" 1356 | }, 1357 | "outputs": [ 1358 | { 1359 | "data": { 1360 | "text/plain": [ 1361 | "device(type='cpu')" 1362 | ] 1363 | }, 1364 | "execution_count": 38, 1365 | "metadata": { 1366 | "tags": [] 1367 | }, 1368 | "output_type": "execute_result" 1369 | } 1370 | ], 1371 | "source": [ 1372 | "torch.device('cpu')" 1373 | ] 1374 | }, 1375 | { 1376 | "cell_type": "code", 1377 | "execution_count": 0, 1378 | "metadata": { 1379 | "colab": { 1380 | "base_uri": "https://localhost:8080/", 1381 | "height": 34 1382 | }, 1383 | "colab_type": "code", 1384 | "executionInfo": { 1385 | "elapsed": 4760, 1386 | "status": "ok", 1387 | "timestamp": 1553687458921, 1388 | "user": { 1389 | "displayName": "Igor Slinko", 1390 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 1391 | "userId": "00864276345820379450" 1392 | }, 1393 | "user_tz": -180 1394 | }, 1395 | "id": "brlr6kp-Owrp", 1396 | "outputId": "80c44c6e-aab2-4719-9c33-183c85c00db0" 1397 | }, 1398 | "outputs": [ 1399 | { 1400 | "data": { 1401 | "text/plain": [ 1402 | "device(type='cuda', index=0)" 1403 | ] 1404 | }, 1405 | "execution_count": 39, 1406 | "metadata": { 1407 | "tags": [] 1408 | }, 1409 | "output_type": "execute_result" 1410 | } 1411 | ], 1412 | "source": [ 1413 | "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n", 1414 | "device" 1415 | ] 1416 | }, 1417 | { 1418 | "cell_type": "code", 1419 | "execution_count": 0, 1420 | "metadata": { 1421 | "colab": {}, 1422 | "colab_type": "code", 1423 | "id": "No2Aa20APGi7" 1424 | }, 1425 | "outputs": [], 1426 | "source": [ 1427 | "x_cuda = x.to(device)\n", 1428 | "# x_cuda" 1429 | ] 1430 | }, 1431 | { 1432 | "cell_type": "code", 1433 | "execution_count": 0, 1434 | "metadata": { 1435 | "colab": { 1436 | "base_uri": "https://localhost:8080/", 1437 | "height": 51 1438 | }, 1439 | "colab_type": "code", 1440 | "executionInfo": { 1441 | "elapsed": 13603, 1442 | "status": "ok", 1443 | "timestamp": 1553687468407, 1444 | "user": { 1445 | "displayName": "Igor Slinko", 1446 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 1447 | "userId": "00864276345820379450" 1448 | }, 1449 | "user_tz": -180 1450 | }, 1451 | "id": "b8jHgcD6Puhl", 1452 | "outputId": "bd6ef6ee-f442-4747-c486-535aba1e010e" 1453 | }, 1454 | "outputs": [ 1455 | { 1456 | "name": "stdout", 1457 | "output_type": "stream", 1458 | "text": [ 1459 | "CPU times: user 24.6 ms, sys: 33.9 ms, total: 58.5 ms\n", 1460 | "Wall time: 61.7 ms\n" 1461 | ] 1462 | } 1463 | ], 1464 | "source": [ 1465 | "%time y = (x - x + x * 10.0) ** 2" 1466 | ] 1467 | }, 1468 | { 1469 | "cell_type": "code", 1470 | "execution_count": 0, 1471 | "metadata": { 1472 | "colab": { 1473 | "base_uri": "https://localhost:8080/", 1474 | "height": 51 1475 | }, 1476 | "colab_type": "code", 1477 | "executionInfo": { 1478 | "elapsed": 13370, 1479 | "status": "ok", 1480 | "timestamp": 1553687468409, 1481 | "user": { 1482 | "displayName": "Igor Slinko", 1483 | "photoUrl": "https://lh4.googleusercontent.com/-KYuH_A0wMqY/AAAAAAAAAAI/AAAAAAAAA70/CFLH5ufF32M/s64/photo.jpg", 1484 | "userId": "00864276345820379450" 1485 | }, 1486 | "user_tz": -180 1487 | }, 1488 | "id": "TxydcYheP3tQ", 1489 | "outputId": "0b5f5d57-d689-46c5-e470-3e4b57bd64b0" 1490 | }, 1491 | "outputs": [ 1492 | { 1493 | "name": "stdout", 1494 | "output_type": "stream", 1495 | "text": [ 1496 | "CPU times: user 1.55 ms, sys: 1.86 ms, total: 3.41 ms\n", 1497 | "Wall time: 24.9 ms\n" 1498 | ] 1499 | } 1500 | ], 1501 | "source": [ 1502 | "%time y_cuda = (x_cuda - x_cuda + x_cuda * 10.0) ** 2" 1503 | ] 1504 | }, 1505 | { 1506 | "cell_type": "code", 1507 | "execution_count": 0, 1508 | "metadata": { 1509 | "colab": {}, 1510 | "colab_type": "code", 1511 | "id": "Lbl4j-4fQGNi" 1512 | }, 1513 | "outputs": [], 1514 | "source": [] 1515 | } 1516 | ], 1517 | "metadata": { 1518 | "accelerator": "GPU", 1519 | "colab": { 1520 | "collapsed_sections": [], 1521 | "name": "Seminar1.ipynb", 1522 | "provenance": [], 1523 | "version": "0.3.2" 1524 | }, 1525 | "kernelspec": { 1526 | "display_name": "Python 3", 1527 | "language": "python", 1528 | "name": "python3" 1529 | }, 1530 | "language_info": { 1531 | "codemirror_mode": { 1532 | "name": "ipython", 1533 | "version": 3 1534 | }, 1535 | "file_extension": ".py", 1536 | "mimetype": "text/x-python", 1537 | "name": "python", 1538 | "nbconvert_exporter": "python", 1539 | "pygments_lexer": "ipython3", 1540 | "version": "3.6.8" 1541 | } 1542 | }, 1543 | "nbformat": 4, 1544 | "nbformat_minor": 1 1545 | } 1546 | -------------------------------------------------------------------------------- /module03_sin_prediction.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import torch\n", 10 | "import matplotlib.pyplot as plt" 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": 2, 16 | "metadata": {}, 17 | "outputs": [], 18 | "source": [ 19 | "import matplotlib\n", 20 | "matplotlib.rcParams['figure.figsize'] = (13.0, 5.0)" 21 | ] 22 | }, 23 | { 24 | "cell_type": "markdown", 25 | "metadata": {}, 26 | "source": [ 27 | "# Train dataset" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": 3, 33 | "metadata": {}, 34 | "outputs": [ 35 | { 36 | "data": { 37 | "image/png": "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\n", 38 | "text/plain": [ 39 | "
" 40 | ] 41 | }, 42 | "metadata": {}, 43 | "output_type": "display_data" 44 | } 45 | ], 46 | "source": [ 47 | "x_train = torch.rand(100)\n", 48 | "x_train = x_train * 20.0 - 10.0\n", 49 | "\n", 50 | "y_train = torch.sin(x_train)\n", 51 | "\n", 52 | "plt.plot(x_train.numpy(), y_train.numpy(), 'o')\n", 53 | "plt.title('$y = sin(x)$');" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 4, 59 | "metadata": {}, 60 | "outputs": [ 61 | { 62 | "data": { 63 | "image/png": "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\n", 64 | "text/plain": [ 65 | "
" 66 | ] 67 | }, 68 | "metadata": {}, 69 | "output_type": "display_data" 70 | } 71 | ], 72 | "source": [ 73 | "noise = torch.randn(y_train.shape) / 5.\n", 74 | "\n", 75 | "plt.plot(x_train.numpy(), noise.numpy(), 'o')\n", 76 | "plt.axis([-10, 10, -1, 1])\n", 77 | "plt.title('Gaussian noise');" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 5, 83 | "metadata": {}, 84 | "outputs": [ 85 | { 86 | "data": { 87 | "image/png": "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\n", 88 | "text/plain": [ 89 | "
" 90 | ] 91 | }, 92 | "metadata": {}, 93 | "output_type": "display_data" 94 | } 95 | ], 96 | "source": [ 97 | "y_train = y_train + noise\n", 98 | "plt.plot(x_train.numpy(), y_train.numpy(), 'o')\n", 99 | "plt.title('noisy sin(x)')\n", 100 | "plt.xlabel('x_train')\n", 101 | "plt.ylabel('y_train');" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 6, 107 | "metadata": {}, 108 | "outputs": [], 109 | "source": [ 110 | "x_train.unsqueeze_(1)\n", 111 | "y_train.unsqueeze_(1);" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": 7, 117 | "metadata": { 118 | "scrolled": true 119 | }, 120 | "outputs": [ 121 | { 122 | "name": "stdout", 123 | "output_type": "stream", 124 | "text": [ 125 | "tensor([1., 2., 3.])\n", 126 | "tensor([[1.],\n", 127 | " [2.],\n", 128 | " [3.]])\n" 129 | ] 130 | } 131 | ], 132 | "source": [ 133 | "tmp = torch.Tensor([1,2,3])\n", 134 | "print(tmp)\n", 135 | "print(tmp.unsqueeze(1))" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": {}, 141 | "source": [ 142 | "# Validation dataset" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": 8, 148 | "metadata": {}, 149 | "outputs": [ 150 | { 151 | "data": { 152 | "image/png": "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\n", 153 | "text/plain": [ 154 | "
" 155 | ] 156 | }, 157 | "metadata": {}, 158 | "output_type": "display_data" 159 | } 160 | ], 161 | "source": [ 162 | "x_validation = torch.linspace(-10, 10, 100)\n", 163 | "y_validation = torch.sin(x_validation.data)\n", 164 | "plt.plot(x_validation.numpy(), y_validation.numpy(), 'o')\n", 165 | "plt.title('sin(x)')\n", 166 | "plt.xlabel('x_validation')\n", 167 | "plt.ylabel('y_validation');" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 9, 173 | "metadata": {}, 174 | "outputs": [], 175 | "source": [ 176 | "x_validation.unsqueeze_(1)\n", 177 | "y_validation.unsqueeze_(1);" 178 | ] 179 | }, 180 | { 181 | "cell_type": "markdown", 182 | "metadata": {}, 183 | "source": [ 184 | "# Model construction" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": 10, 190 | "metadata": {}, 191 | "outputs": [], 192 | "source": [ 193 | "class SineNet(torch.nn.Module):\n", 194 | " def __init__(self, n_hidden_neurons):\n", 195 | " super(SineNet, self).__init__()\n", 196 | " self.fc1 = torch.nn.Linear(1, n_hidden_neurons)\n", 197 | " self.act1 = torch.nn.Sigmoid()\n", 198 | " self.fc2 = torch.nn.Linear(n_hidden_neurons, 1)\n", 199 | "\n", 200 | " def forward(self, x):\n", 201 | " x = self.fc1(x)\n", 202 | " x = self.act1(x)\n", 203 | " x = self.fc2(x)\n", 204 | " return x\n", 205 | "\n", 206 | "sine_net = SineNet(3)" 207 | ] 208 | }, 209 | { 210 | "cell_type": "markdown", 211 | "metadata": {}, 212 | "source": [ 213 | "# Prediction" 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": 11, 219 | "metadata": {}, 220 | "outputs": [ 221 | { 222 | "data": { 223 | "image/png": "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\n", 224 | "text/plain": [ 225 | "
" 226 | ] 227 | }, 228 | "metadata": {}, 229 | "output_type": "display_data" 230 | } 231 | ], 232 | "source": [ 233 | "def predict(net, x, y):\n", 234 | " y_pred = net.forward(x)\n", 235 | "\n", 236 | " plt.plot(x.numpy(), y.numpy(), 'o', label='Groud truth')\n", 237 | " plt.plot(x.numpy(), y_pred.data.numpy(), 'o', c='r', label='Prediction');\n", 238 | " plt.legend(loc='upper left')\n", 239 | " plt.xlabel('$x$')\n", 240 | " plt.ylabel('$y$')\n", 241 | "\n", 242 | "predict(sine_net, x_validation, y_validation)" 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "# Optimizer" 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": 12, 255 | "metadata": {}, 256 | "outputs": [], 257 | "source": [ 258 | "optimizer = torch.optim.Adam(sine_net.parameters(), lr=0.01)" 259 | ] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": {}, 264 | "source": [ 265 | "# Loss function" 266 | ] 267 | }, 268 | { 269 | "cell_type": "code", 270 | "execution_count": 13, 271 | "metadata": {}, 272 | "outputs": [], 273 | "source": [ 274 | "def loss(pred, target):\n", 275 | " squares = (pred - target) ** 2\n", 276 | " return squares.mean()" 277 | ] 278 | }, 279 | { 280 | "cell_type": "markdown", 281 | "metadata": {}, 282 | "source": [ 283 | "# Training procedure" 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": 14, 289 | "metadata": {}, 290 | "outputs": [ 291 | { 292 | "data": { 293 | "image/png": "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\n", 294 | "text/plain": [ 295 | "
" 296 | ] 297 | }, 298 | "metadata": {}, 299 | "output_type": "display_data" 300 | } 301 | ], 302 | "source": [ 303 | "for epoch_index in range(2000):\n", 304 | " optimizer.zero_grad()\n", 305 | "\n", 306 | " y_pred = sine_net.forward(x_train)\n", 307 | " loss_val = loss(y_pred, y_train)\n", 308 | "\n", 309 | " loss_val.backward()\n", 310 | "\n", 311 | " optimizer.step()\n", 312 | "\n", 313 | "predict(sine_net, x_validation, y_validation)" 314 | ] 315 | }, 316 | { 317 | "cell_type": "code", 318 | "execution_count": null, 319 | "metadata": {}, 320 | "outputs": [], 321 | "source": [] 322 | }, 323 | { 324 | "cell_type": "code", 325 | "execution_count": null, 326 | "metadata": {}, 327 | "outputs": [], 328 | "source": [] 329 | }, 330 | { 331 | "cell_type": "code", 332 | "execution_count": null, 333 | "metadata": {}, 334 | "outputs": [], 335 | "source": [] 336 | }, 337 | { 338 | "cell_type": "code", 339 | "execution_count": null, 340 | "metadata": {}, 341 | "outputs": [], 342 | "source": [] 343 | }, 344 | { 345 | "cell_type": "code", 346 | "execution_count": null, 347 | "metadata": {}, 348 | "outputs": [], 349 | "source": [] 350 | } 351 | ], 352 | "metadata": { 353 | "anaconda-cloud": {}, 354 | "kernelspec": { 355 | "display_name": "Python 3", 356 | "language": "python", 357 | "name": "python3" 358 | }, 359 | "language_info": { 360 | "codemirror_mode": { 361 | "name": "ipython", 362 | "version": 3 363 | }, 364 | "file_extension": ".py", 365 | "mimetype": "text/x-python", 366 | "name": "python", 367 | "nbconvert_exporter": "python", 368 | "pygments_lexer": "ipython3", 369 | "version": "3.6.8" 370 | } 371 | }, 372 | "nbformat": 4, 373 | "nbformat_minor": 2 374 | } 375 | --------------------------------------------------------------------------------