├── PyTorch ├── .ipynb_checkpoints │ ├── Linear Regression-checkpoint.ipynb │ └── Untitled1-checkpoint.ipynb ├── Basics.ipynb ├── Linear Regression.ipynb ├── Logistic + NN.ipynb ├── img │ ├── auto.png │ └── lr.jpg └── linear_regression_torch_cpu.py ├── Python ├── NumPy.ipynb ├── Pandas.ipynb ├── Python.ipynb └── Welcome to Python.ipynb └── README.md /PyTorch/.ipynb_checkpoints/Linear Regression-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Linear Regression\n", 8 | "\n", 9 | "In this tutorial, we'll try the classic Linear Regression Algorithm\n", 10 | "\n", 11 | "![Linear Regression](img/lr.jpg)\n", 12 | "\n", 13 | "Linear Regression involves creating a best fit linear line such the distance between the y' points on line and real values is minimum (the summation of the distance is known as our loss)\n" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "Import Libraries" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": { 27 | "collapsed": true 28 | }, 29 | "outputs": [], 30 | "source": [ 31 | "import torch\n", 32 | "import torch.nn as nn\n", 33 | "from torch.autograd import Variable\n", 34 | "import numpy as np\n", 35 | "import matplotlib.pyplot as plt" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "Initializing Seed for consistent results everytime" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": null, 48 | "metadata": { 49 | "collapsed": true 50 | }, 51 | "outputs": [], 52 | "source": [ 53 | "np.random.seed(42)\n", 54 | "pts = 50" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "Creating a Dataset of 50 points" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": { 68 | "collapsed": true 69 | }, 70 | "outputs": [], 71 | "source": [ 72 | "x_vals = np.random.rand(50)\n", 73 | "x_train = np.asarray(x_vals,dtype=np.float32).reshape(-1,1)\n", 74 | "m = 1\n", 75 | "alpha = np.random.rand(1)\n", 76 | "beta = np.random.rand(1)\n", 77 | "y_correct = np.asarray([2*i+m for i in x_vals], dtype=np.float32).reshape(-1,1)" 78 | ] 79 | }, 80 | { 81 | "cell_type": "markdown", 82 | "metadata": {}, 83 | "source": [ 84 | "### PyTorch Models\n", 85 | "\n", 86 | "1. Create a Class\n", 87 | "2. Declare your Forward Pass\n", 88 | "3. Tune the HyperParameters" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": { 95 | "collapsed": true 96 | }, 97 | "outputs": [], 98 | "source": [ 99 | "class LinearRegressionModel(nn.Module):\n", 100 | "\n", 101 | " def __init__(self, input_dim, output_dim):\n", 102 | "\n", 103 | " super(LinearRegressionModel, self).__init__() \n", 104 | " # Calling Super Class's constructor\n", 105 | " self.linear = nn.Linear(input_dim, output_dim)\n", 106 | " # nn.linear is defined in nn.Module\n", 107 | "\n", 108 | " def forward(self, x):\n", 109 | " # Here the forward pass is simply a linear function\n", 110 | "\n", 111 | " out = self.linear(x)\n", 112 | " return out\n", 113 | "\n", 114 | "input_dim = 1\n", 115 | "output_dim = 1" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": {}, 121 | "source": [ 122 | "### Steps\n", 123 | "1. Create instance of model\n", 124 | "2. Select Loss Criterion\n", 125 | "3. Choose Hyper Parameters" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": { 132 | "collapsed": true 133 | }, 134 | "outputs": [], 135 | "source": [ 136 | "model = LinearRegressionModel(input_dim,output_dim)# create our model just as we do in Scikit-Learn / C / C++//\n", 137 | "\n", 138 | "criterion = nn.MSELoss()# Mean Squared Loss\n", 139 | "l_rate = 0.01\n", 140 | "optimiser = torch.optim.SGD(model.parameters(), lr = l_rate) #Stochastic Gradient Descent\n", 141 | "\n", 142 | "epochs = 2000" 143 | ] 144 | }, 145 | { 146 | "cell_type": "markdown", 147 | "metadata": {}, 148 | "source": [ 149 | "### Train the Model" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": null, 155 | "metadata": { 156 | "collapsed": true 157 | }, 158 | "outputs": [], 159 | "source": [ 160 | "for epoch in range(epochs):\n", 161 | "\n", 162 | " epoch +=1\n", 163 | " inputs = Variable(torch.from_numpy(x_train))\n", 164 | " labels = Variable(torch.from_numpy(y_correct))\n", 165 | "\n", 166 | " #clear grads\n", 167 | " optimiser.zero_grad()\n", 168 | " #forward to get predicted values\n", 169 | " outputs = model.forward(inputs)\n", 170 | " loss = criterion(outputs, labels)\n", 171 | " loss.backward()# back props\n", 172 | " optimiser.step()# update the parameters\n", 173 | " print('epoch {}, loss {}'.format(epoch,loss.data[0]))" 174 | ] 175 | }, 176 | { 177 | "cell_type": "markdown", 178 | "metadata": {}, 179 | "source": [ 180 | "### Printing the Predictions" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": null, 186 | "metadata": { 187 | "collapsed": true 188 | }, 189 | "outputs": [], 190 | "source": [ 191 | "predicted = model.forward(Variable(torch.from_numpy(x_train))).data.numpy()\n", 192 | "\n", 193 | "plt.plot(x_train, y_correct, 'go', label = 'from data', alpha = .5)\n", 194 | "plt.plot(x_train, predicted, label = 'prediction', alpha = 0.5)\n", 195 | "plt.legend()\n", 196 | "plt.show()\n", 197 | "print(model.state_dict())" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "metadata": {}, 203 | "source": [ 204 | "### Example to Use GPU" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": null, 210 | "metadata": { 211 | "collapsed": true 212 | }, 213 | "outputs": [], 214 | "source": [ 215 | "import torch\n", 216 | "import torch.nn as nn\n", 217 | "from torch.autograd import Variable\n", 218 | "import numpy as np\n", 219 | "\n", 220 | "x_values = [i for i in range(11)]\n", 221 | "x_train = np.array(x_values, dtype=np.float32)\n", 222 | "x_train = x_train.reshape(-1, 1)\n", 223 | "\n", 224 | "y_values = [2*i + 1 for i in x_values]\n", 225 | "y_train = np.array(y_values, dtype=np.float32)\n", 226 | "y_train = y_train.reshape(-1, 1)\n", 227 | "\n", 228 | "'''\n", 229 | "CREATE MODEL CLASS\n", 230 | "'''\n", 231 | "class LinearRegressionModel(nn.Module):\n", 232 | " def __init__(self, input_dim, output_dim):\n", 233 | " super(LinearRegressionModel, self).__init__()\n", 234 | " self.linear = nn.Linear(input_dim, output_dim) \n", 235 | " \n", 236 | " def forward(self, x):\n", 237 | " out = self.linear(x)\n", 238 | " return out\n", 239 | "\n", 240 | "'''\n", 241 | "INSTANTIATE MODEL CLASS\n", 242 | "'''\n", 243 | "input_dim = 1\n", 244 | "output_dim = 1\n", 245 | "\n", 246 | "model = LinearRegressionModel(input_dim, output_dim)\n", 247 | "\n", 248 | "\n", 249 | "\n", 250 | "model.cuda()\n", 251 | "\n", 252 | "'''\n", 253 | "INSTANTIATE LOSS CLASS\n", 254 | "'''\n", 255 | "\n", 256 | "criterion = nn.MSELoss()\n", 257 | "\n", 258 | "\n", 259 | "learning_rate = 0.01\n", 260 | "\n", 261 | "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n", 262 | "\n", 263 | "\n", 264 | "epochs = 100\n", 265 | "for epoch in range(epochs):\n", 266 | " epoch += 1\n", 267 | "\n", 268 | " \n", 269 | " if torch.cuda.is_available():\n", 270 | " inputs = Variable(torch.from_numpy(x_train).cuda())\n", 271 | "\n", 272 | " \n", 273 | " if torch.cuda.is_available():\n", 274 | " labels = Variable(torch.from_numpy(y_train).cuda())\n", 275 | " \n", 276 | "\n", 277 | " optimizer.zero_grad() \n", 278 | " \n", 279 | "\n", 280 | " outputs = model(inputs)\n", 281 | "\n", 282 | " loss = criterion(outputs, labels)\n", 283 | " \n", 284 | "\n", 285 | " loss.backward()\n", 286 | " \n", 287 | "\n", 288 | " optimizer.step()\n", 289 | " \n", 290 | "\n", 291 | " print('epoch {}, loss {}'.format(epoch, loss.data[0]))\n" 292 | ] 293 | }, 294 | { 295 | "cell_type": "markdown", 296 | "metadata": {}, 297 | "source": [ 298 | "Sources:\n", 299 | "http://github.com/pytorch/examples\n", 300 | "\n", 301 | "http://github.com/ritchieng/the-incredible-pytorch" 302 | ] 303 | } 304 | ], 305 | "metadata": { 306 | "kernelspec": { 307 | "display_name": "Python 3", 308 | "language": "python", 309 | "name": "python3" 310 | }, 311 | "language_info": { 312 | "codemirror_mode": { 313 | "name": "ipython", 314 | "version": 3 315 | }, 316 | "file_extension": ".py", 317 | "mimetype": "text/x-python", 318 | "name": "python", 319 | "nbconvert_exporter": "python", 320 | "pygments_lexer": "ipython3", 321 | "version": "3.6.1" 322 | } 323 | }, 324 | "nbformat": 4, 325 | "nbformat_minor": 2 326 | } 327 | -------------------------------------------------------------------------------- /PyTorch/.ipynb_checkpoints/Untitled1-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## PyTorch Fundamentals" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "ename": "ModuleNotFoundError", 17 | "evalue": "No module named 'torch'", 18 | "output_type": "error", 19 | "traceback": [ 20 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 21 | "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", 22 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 23 | "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'torch'" 24 | ] 25 | } 26 | ], 27 | "source": [ 28 | "import torch\n", 29 | "import numpy as np" 30 | ] 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "metadata": {}, 35 | "source": [ 36 | "Matrices" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": null, 42 | "metadata": { 43 | "collapsed": true 44 | }, 45 | "outputs": [], 46 | "source": [ 47 | "x = torch.Tensor(5, 3)\n", 48 | "print(x)" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "Random Initialisation" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": null, 61 | "metadata": { 62 | "collapsed": true 63 | }, 64 | "outputs": [], 65 | "source": [ 66 | "x = torch.rand(5, 3)\n", 67 | "print(x)" 68 | ] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "Size" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": { 81 | "collapsed": true 82 | }, 83 | "outputs": [], 84 | "source": [ 85 | "print(x.size())" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "Addition" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": null, 98 | "metadata": { 99 | "collapsed": true 100 | }, 101 | "outputs": [], 102 | "source": [ 103 | "y = torch.rand(5, 3)\n", 104 | "print(x + y)\n", 105 | "\n", 106 | "print(torch.add(x, y))" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "Getting Result as a Tensor\n", 114 | "\n", 115 | "This will return the sum into result variable" 116 | ] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": null, 121 | "metadata": { 122 | "collapsed": true 123 | }, 124 | "outputs": [], 125 | "source": [ 126 | "result = torch.Tensor(5, 3)\n", 127 | "torch.add(x, y, out=result)\n", 128 | "print(result)" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "In Place Addition\n", 136 | "\n", 137 | "In place functions are followed by an _" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "metadata": { 144 | "collapsed": true 145 | }, 146 | "outputs": [], 147 | "source": [ 148 | "y.add_(x)\n", 149 | "print(y)" 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": {}, 155 | "source": [ 156 | "Indexing, Slicing" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": { 163 | "collapsed": true 164 | }, 165 | "outputs": [], 166 | "source": [ 167 | "print(x[:, 1])" 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "### Numpy Bridge" 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": null, 180 | "metadata": { 181 | "collapsed": true 182 | }, 183 | "outputs": [], 184 | "source": [ 185 | "a = torch.ones(5)\n", 186 | "b = a.numpy()\n", 187 | "print(b)" 188 | ] 189 | }, 190 | { 191 | "cell_type": "markdown", 192 | "metadata": {}, 193 | "source": [ 194 | "The torch Tensor and numpy array will share their underlying memory locations, and changing one will change the other." 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": null, 200 | "metadata": { 201 | "collapsed": true 202 | }, 203 | "outputs": [], 204 | "source": [ 205 | "a.add_(1)\n", 206 | "print(a)\n", 207 | "print(b)" 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": {}, 213 | "source": [ 214 | "### PyTorch Bridge" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": null, 220 | "metadata": { 221 | "collapsed": true 222 | }, 223 | "outputs": [], 224 | "source": [ 225 | "a = np.ones(5)\n", 226 | "b = torch.from_numpy(a)\n", 227 | "np.add(a, 1, out=a)\n", 228 | "print(a)\n", 229 | "print(b)" 230 | ] 231 | }, 232 | { 233 | "cell_type": "markdown", 234 | "metadata": {}, 235 | "source": [ 236 | "### Using GPU\n", 237 | "Moving the Tensors to GPU" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": 3, 243 | "metadata": {}, 244 | "outputs": [ 245 | { 246 | "ename": "NameError", 247 | "evalue": "name 'torch' is not defined", 248 | "output_type": "error", 249 | "traceback": [ 250 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 251 | "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", 252 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_available\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 253 | "\u001b[0;31mNameError\u001b[0m: name 'torch' is not defined" 254 | ] 255 | } 256 | ], 257 | "source": [ 258 | "if torch.cuda.is_available():\n", 259 | " x = x.cuda()\n", 260 | " y = y.cuda()\n", 261 | " x + y" 262 | ] 263 | }, 264 | { 265 | "cell_type": "markdown", 266 | "metadata": {}, 267 | "source": [ 268 | "The autograd package provides automatic differentiation for all operations on Tensors. It is a define-by-run framework, which means that your backprop is defined by how your code is run, and that every single iteration can be different.\n", 269 | "\n", 270 | "autograd.Variable is the central class of the package. It wraps a Tensor, and supports nearly all of operations defined on it. Once you finish your computation you can call .backward() and have all the gradients computed automatically.\n", 271 | "\n", 272 | "You can access the raw tensor through the .data attribute, while the gradient w.r.t. this variable is accumulated into .grad.\n", 273 | "\n", 274 | "![](img/auto.png)" 275 | ] 276 | }, 277 | { 278 | "cell_type": "code", 279 | "execution_count": null, 280 | "metadata": { 281 | "collapsed": true 282 | }, 283 | "outputs": [], 284 | "source": [] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": null, 289 | "metadata": { 290 | "collapsed": true 291 | }, 292 | "outputs": [], 293 | "source": [ 294 | "import torch\n", 295 | "from torch.autograd import Variable\n", 296 | "\n", 297 | "x_data = [1.0, 2.0, 3.0]\n", 298 | "y_data = [2.0, 4.0, 6.0]\n", 299 | "\n", 300 | "w = Variable(torch.Tensor([1.0]), requires_grad=True) # Any random value\n", 301 | "\n", 302 | "# our model forward pass\n", 303 | "\n", 304 | "\n", 305 | "def forward(x):\n", 306 | " return x * w\n", 307 | "\n", 308 | "# Loss function\n", 309 | "\n", 310 | "\n", 311 | "def loss(x, y):\n", 312 | " y_pred = forward(x)\n", 313 | " return (y_pred - y) * (y_pred - y)\n", 314 | "\n", 315 | "# Before training\n", 316 | "print(\"predict (before training)\", 4, forward(4).data[0])\n", 317 | "\n", 318 | "# Training loop\n", 319 | "for epoch in range(10):\n", 320 | " for x_val, y_val in zip(x_data, y_data):\n", 321 | " l = loss(x_val, y_val)\n", 322 | " l.backward()\n", 323 | " print(\"\\tgrad: \", x_val, y_val, w.grad.data[0])\n", 324 | " w.data = w.data - 0.01 * w.grad.data\n", 325 | "\n", 326 | " # Manually zero the gradients after updating weights\n", 327 | " w.grad.data.zero_()\n", 328 | "\n", 329 | " print(\"progress:\", epoch, l.data[0])\n", 330 | "\n", 331 | "# After training\n", 332 | "print(\"predict (after training)\", 4, forward(4).data[0])" 333 | ] 334 | }, 335 | { 336 | "cell_type": "code", 337 | "execution_count": null, 338 | "metadata": { 339 | "collapsed": true 340 | }, 341 | "outputs": [], 342 | "source": [] 343 | }, 344 | { 345 | "cell_type": "code", 346 | "execution_count": null, 347 | "metadata": { 348 | "collapsed": true 349 | }, 350 | "outputs": [], 351 | "source": [ 352 | "PyTorch Tutorial\n", 353 | "MILA, November 2017\n", 354 | "By Sandeep Subramanian\n", 355 | "1. Introduction to the torch tensor library\n", 356 | "Torch's numpy equivalent with GPU support\n", 357 | "In [2]:\n", 358 | "import numpy as np\n", 359 | "from __future__ import print_function\n", 360 | "In [3]:\n", 361 | "import torch\n", 362 | "Initialize a random tensor\n", 363 | "In [4]:\n", 364 | "torch.Tensor(5, 3)\n", 365 | "Out[4]:\n", 366 | " 2.4878e+04 4.5692e-41 2.4878e+04\n", 367 | " 4.5692e-41 -2.9205e+19 4.5691e-41\n", 368 | " 1.2277e-02 4.5692e-41 -4.0170e+19\n", 369 | " 4.5691e-41 1.2277e-02 4.5692e-41\n", 370 | " 0.0000e+00 0.0000e+00 0.0000e+00\n", 371 | "[torch.FloatTensor of size 5x3]\n", 372 | "From a uniform distribution\n", 373 | "In [5]:\n", 374 | "torch.Tensor(5, 3).uniform_(-1, 1)\n", 375 | "Out[5]:\n", 376 | "-0.2767 -0.1082 -0.1339\n", 377 | "-0.6477 0.3098 0.1642\n", 378 | "-0.1125 -0.2104 0.8962\n", 379 | "-0.6573 0.9669 -0.3806\n", 380 | " 0.8008 -0.3860 0.6816\n", 381 | "[torch.FloatTensor of size 5x3]\n", 382 | "Get it's shape\n", 383 | "In [6]:\n", 384 | "x = torch.Tensor(5, 3).uniform_(-1, 1)\n", 385 | "print(x.size())\n", 386 | "torch.Size([5, 3])\n", 387 | "Tensor Types\n", 388 | "source: http://pytorch.org/docs/master/tensors.html\n", 389 | "Data type\tTensor\n", 390 | "32-bit floating point\ttorch.FloatTensor\n", 391 | "64-bit floating point\ttorch.DoubleTensor\n", 392 | "16-bit floating point\ttorch.HalfTensor\n", 393 | "8-bit integer (unsigned)\ttorch.ByteTensor\n", 394 | "8-bit integer (signed)\ttorch.CharTensor\n", 395 | "16-bit integer (signed)\ttorch.ShortTensor\n", 396 | "32-bit integer (signed)\ttorch.IntTensor\n", 397 | "64-bit integer (signed)\ttorch.LongTensor\n", 398 | "Creation from lists & numpy\n", 399 | "In [7]:\n", 400 | "z = torch.LongTensor([[1, 3], [2, 9]])\n", 401 | "print(z.type())\n", 402 | "# Cast to numpy ndarray\n", 403 | "print(z.numpy().dtype)\n", 404 | "torch.LongTensor\n", 405 | "int64\n", 406 | "In [8]:\n", 407 | "# Data type inferred from numpy\n", 408 | "print(torch.from_numpy(np.random.rand(5, 3)).type())\n", 409 | "print(torch.from_numpy(np.random.rand(5, 3).astype(np.float32)).type())\n", 410 | "torch.DoubleTensor\n", 411 | "torch.FloatTensor\n", 412 | "Simple mathematical operations\n", 413 | "In [9]:\n", 414 | "y = x * torch.randn(5, 3)\n", 415 | "print(y)\n", 416 | " 0.2200 -0.0368 0.4494\n", 417 | "-0.2577 -0.0343 0.1587\n", 418 | "-0.7503 -0.1729 0.0453\n", 419 | " 0.9296 -0.1067 -0.6402\n", 420 | "-0.3276 0.0158 -0.0552\n", 421 | "[torch.FloatTensor of size 5x3]\n", 422 | "\n", 423 | "In [10]:\n", 424 | "y = x / torch.sqrt(torch.randn(5, 3) ** 2)\n", 425 | "print(y)\n", 426 | " 0.2820 -0.1633 -4.4346\n", 427 | "-1.6809 0.2066 -0.8261\n", 428 | "-0.6464 0.9758 0.2542\n", 429 | " 0.5789 0.1890 -0.4662\n", 430 | " 5.3183 0.0236 -0.1403\n", 431 | "[torch.FloatTensor of size 5x3]\n", 432 | "\n", 433 | "Broadcasting\n", 434 | "In [11]:\n", 435 | "print (x.size())\n", 436 | "y = x + torch.randn(5, 1)\n", 437 | "print(y)\n", 438 | "torch.Size([5, 3])\n", 439 | "\n", 440 | " 0.1919 -0.5006 -1.2410\n", 441 | "-0.8080 0.1407 -0.6193\n", 442 | "-1.6629 -0.1580 -0.3921\n", 443 | " 1.0395 0.7069 -0.1459\n", 444 | " 1.9027 1.4343 1.2299\n", 445 | "[torch.FloatTensor of size 5x3]\n", 446 | "\n", 447 | "Reshape\n", 448 | "In [12]:\n", 449 | "y = torch.randn(5, 10, 15)\n", 450 | "print(y.size())\n", 451 | "print(y.view(-1, 15).size()) # Same as doing y.view(50, 15)\n", 452 | "print(y.view(-1, 15).unsqueeze(1).size()) # Adds a dimension at index 1.\n", 453 | "print(y.view(-1, 15).unsqueeze(1).squeeze().size())\n", 454 | "# If input is of shape: (Ax1xBxCx1xD)(Ax1xBxCx1xD) then the out Tensor will be of shape: (AxBxCxD)(AxBxCxD)\n", 455 | "print()\n", 456 | "print(y.transpose(0, 1).size())\n", 457 | "print(y.transpose(1, 2).size())\n", 458 | "print(y.transpose(0, 1).transpose(1, 2).size())\n", 459 | "print(y.permute(1, 2, 0).size())\n", 460 | "torch.Size([5, 10, 15])\n", 461 | "torch.Size([50, 15])\n", 462 | "torch.Size([50, 1, 15])\n", 463 | "torch.Size([50, 15])\n", 464 | "\n", 465 | "torch.Size([10, 5, 15])\n", 466 | "torch.Size([5, 15, 10])\n", 467 | "torch.Size([10, 15, 5])\n", 468 | "torch.Size([10, 15, 5])\n", 469 | "Repeat\n", 470 | "In [13]:\n", 471 | "print(y.view(-1, 15).unsqueeze(1).expand(50, 100, 15).size())\n", 472 | "print(y.view(-1, 15).unsqueeze(1).expand_as(torch.randn(50, 100, 15)).size())\n", 473 | "torch.Size([50, 100, 15])\n", 474 | "torch.Size([50, 100, 15])\n", 475 | "Concatenate\n", 476 | "In [14]:\n", 477 | "# 2 is the dimension over which the tensors are concatenated\n", 478 | "print(torch.cat([y, y], 2).size())\n", 479 | "# stack concatenates the sequence of tensors along a new dimension.\n", 480 | "print(torch.stack([y, y], 0).size())\n", 481 | "torch.Size([5, 10, 30])\n", 482 | "torch.Size([2, 5, 10, 15])\n", 483 | "Advanced Indexing\n", 484 | "In [15]:\n", 485 | "y = torch.randn(2, 3, 4)\n", 486 | "print(y[[1, 0, 1, 1]].size())\n", 487 | "\n", 488 | "# PyTorch doesn't support negative strides yet so ::-1 does not work.\n", 489 | "rev_idx = torch.arange(1, -1, -1).long()\n", 490 | "print(y[rev_idx].size())\n", 491 | "torch.Size([4, 3, 4])\n", 492 | "torch.Size([2, 3, 4])\n", 493 | "GPU support\n", 494 | "In [16]:\n", 495 | "x = torch.cuda.HalfTensor(5, 3).uniform_(-1, 1)\n", 496 | "y = torch.cuda.HalfTensor(3, 5).uniform_(-1, 1)\n", 497 | "torch.matmul(x, y)\n", 498 | "Out[16]:\n", 499 | " 0.2456 1.1543 0.5376 0.4358 -0.0369\n", 500 | " 0.8247 -0.4143 -0.7188 0.3953 0.2573\n", 501 | "-0.1346 0.7329 0.5156 0.0864 -0.1349\n", 502 | "-0.3555 0.3135 0.3921 -0.1428 -0.1368\n", 503 | "-0.4385 0.5601 0.6533 -0.2793 -0.5220\n", 504 | "[torch.cuda.HalfTensor of size 5x5 (GPU 0)]\n", 505 | "Move tensors on the CPU -> GPU\n", 506 | "In [17]:\n", 507 | "x = torch.FloatTensor(5, 3).uniform_(-1, 1)\n", 508 | "print(x)\n", 509 | "x = x.cuda(device=0)\n", 510 | "print(x)\n", 511 | "x = x.cpu()\n", 512 | "print(x)\n", 513 | "-0.3758 -0.1090 0.7911\n", 514 | " 0.2839 -0.9136 0.1070\n", 515 | " 0.9184 0.5113 -0.8040\n", 516 | "-0.3412 -0.8895 -0.5780\n", 517 | "-0.0992 0.0983 0.6074\n", 518 | "[torch.FloatTensor of size 5x3]\n", 519 | "\n", 520 | "\n", 521 | "-0.3758 -0.1090 0.7911\n", 522 | " 0.2839 -0.9136 0.1070\n", 523 | " 0.9184 0.5113 -0.8040\n", 524 | "-0.3412 -0.8895 -0.5780\n", 525 | "-0.0992 0.0983 0.6074\n", 526 | "[torch.cuda.FloatTensor of size 5x3 (GPU 0)]\n", 527 | "\n", 528 | "\n", 529 | "-0.3758 -0.1090 0.7911\n", 530 | " 0.2839 -0.9136 0.1070\n", 531 | " 0.9184 0.5113 -0.8040\n", 532 | "-0.3412 -0.8895 -0.5780\n", 533 | "-0.0992 0.0983 0.6074\n", 534 | "[torch.FloatTensor of size 5x3]\n", 535 | "\n", 536 | "Contiguity in memory\n", 537 | "In [18]:\n", 538 | "x = torch.FloatTensor(5, 3).uniform_(-1, 1)\n", 539 | "print(x)\n", 540 | "x = x.cuda(device=0)\n", 541 | "print(x)\n", 542 | "print('Contiguity : %s ' % (x.is_contiguous()))\n", 543 | "x = x.unsqueeze(0).expand(30, 5, 3)\n", 544 | "print('Contiguity : %s ' % (x.is_contiguous()))\n", 545 | "x = x.contiguous()\n", 546 | "print('Contiguity : %s ' % (x.is_contiguous()))\n", 547 | " 0.4740 -0.9209 0.4143\n", 548 | "-0.3473 0.4474 -0.8159\n", 549 | "-0.7654 -0.0956 0.6145\n", 550 | "-0.0846 -0.6239 0.8609\n", 551 | "-0.8142 0.9289 -0.7020\n", 552 | "[torch.FloatTensor of size 5x3]\n", 553 | "\n", 554 | "\n", 555 | " 0.4740 -0.9209 0.4143\n", 556 | "-0.3473 0.4474 -0.8159\n", 557 | "-0.7654 -0.0956 0.6145\n", 558 | "-0.0846 -0.6239 0.8609\n", 559 | "-0.8142 0.9289 -0.7020\n", 560 | "[torch.cuda.FloatTensor of size 5x3 (GPU 0)]\n", 561 | "\n", 562 | "Contiguity : True \n", 563 | "Contiguity : False \n", 564 | "Contiguity : True " 565 | ] 566 | }, 567 | { 568 | "cell_type": "code", 569 | "execution_count": null, 570 | "metadata": { 571 | "collapsed": true 572 | }, 573 | "outputs": [], 574 | "source": [] 575 | }, 576 | { 577 | "cell_type": "code", 578 | "execution_count": null, 579 | "metadata": { 580 | "collapsed": true 581 | }, 582 | "outputs": [], 583 | "source": [ 584 | "a = torch.IntTensor([2, 3, 4])\n", 585 | "b = torch.IntTensor([3, 4, 5])\n", 586 | "m = a * b # element-wise product\n", 587 | "print(m.numpy()) # convert to the numpy array [ 6 12 20]" 588 | ] 589 | }, 590 | { 591 | "cell_type": "markdown", 592 | "metadata": {}, 593 | "source": [ 594 | "https://github.com/vinhkhuc/PyTorch-Mini-Tutorials/blob/master/0_multiply.py" 595 | ] 596 | }, 597 | { 598 | "cell_type": "code", 599 | "execution_count": null, 600 | "metadata": { 601 | "collapsed": true 602 | }, 603 | "outputs": [], 604 | "source": [] 605 | } 606 | ], 607 | "metadata": { 608 | "kernelspec": { 609 | "display_name": "Python 3", 610 | "language": "python", 611 | "name": "python3" 612 | }, 613 | "language_info": { 614 | "codemirror_mode": { 615 | "name": "ipython", 616 | "version": 3 617 | }, 618 | "file_extension": ".py", 619 | "mimetype": "text/x-python", 620 | "name": "python", 621 | "nbconvert_exporter": "python", 622 | "pygments_lexer": "ipython3", 623 | "version": "3.6.1" 624 | } 625 | }, 626 | "nbformat": 4, 627 | "nbformat_minor": 2 628 | } 629 | -------------------------------------------------------------------------------- /PyTorch/Basics.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## PyTorch Fundamentals" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": { 13 | "heading_collapsed": true 14 | }, 15 | "source": [ 16 | "### Tensor Basics" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": { 23 | "hidden": true 24 | }, 25 | "outputs": [], 26 | "source": [ 27 | "import torch\n", 28 | "import numpy as np" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": { 34 | "hidden": true 35 | }, 36 | "source": [ 37 | "Tensors (Multi-Dimensional Matrices)" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 5, 43 | "metadata": { 44 | "hidden": true 45 | }, 46 | "outputs": [ 47 | { 48 | "name": "stdout", 49 | "output_type": "stream", 50 | "text": [ 51 | "\n", 52 | " 0.1949 0.0000 0.1949\n", 53 | " 0.0000 0.0000 0.0000\n", 54 | " 0.0000 0.0000 0.0000\n", 55 | " 0.0000 0.0000 0.0000\n", 56 | " 0.0000 0.0000 0.0000\n", 57 | "[torch.FloatTensor of size 5x3]\n", 58 | "\n" 59 | ] 60 | } 61 | ], 62 | "source": [ 63 | "x = torch.Tensor(5, 3)\n", 64 | "# OR \n", 65 | "# x = torch.rand(5, 3)\n", 66 | "print(x)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": { 72 | "hidden": true 73 | }, 74 | "source": [ 75 | "Creating a Uniform Distribution" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 16, 81 | "metadata": { 82 | "hidden": true 83 | }, 84 | "outputs": [ 85 | { 86 | "data": { 87 | "text/plain": [ 88 | "\n", 89 | " 0.0405 0.6277 0.5522\n", 90 | " 0.9683 0.7477 -0.6963\n", 91 | " 0.0499 -0.1973 -0.1760\n", 92 | " 0.5687 0.5238 0.4893\n", 93 | " 0.6741 0.4687 0.5762\n", 94 | "[torch.FloatTensor of size 5x3]" 95 | ] 96 | }, 97 | "execution_count": 16, 98 | "metadata": {}, 99 | "output_type": "execute_result" 100 | } 101 | ], 102 | "source": [ 103 | "torch.Tensor(5, 3).uniform_(-1, 1)" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": { 109 | "hidden": true 110 | }, 111 | "source": [ 112 | "Size" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 6, 118 | "metadata": { 119 | "hidden": true 120 | }, 121 | "outputs": [ 122 | { 123 | "name": "stdout", 124 | "output_type": "stream", 125 | "text": [ 126 | "torch.Size([5, 3])\n" 127 | ] 128 | } 129 | ], 130 | "source": [ 131 | "print(x.size())" 132 | ] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "metadata": { 137 | "hidden": true 138 | }, 139 | "source": [ 140 | "Addition" 141 | ] 142 | }, 143 | { 144 | "cell_type": "code", 145 | "execution_count": 7, 146 | "metadata": { 147 | "hidden": true 148 | }, 149 | "outputs": [ 150 | { 151 | "name": "stdout", 152 | "output_type": "stream", 153 | "text": [ 154 | "\n", 155 | " 0.3524 0.9941 0.5052\n", 156 | " 0.8402 0.4396 0.2559\n", 157 | " 0.1516 0.3136 0.8176\n", 158 | " 0.8022 0.2979 0.1485\n", 159 | " 0.0600 0.8662 0.5225\n", 160 | "[torch.FloatTensor of size 5x3]\n", 161 | "\n", 162 | "\n", 163 | " 0.3524 0.9941 0.5052\n", 164 | " 0.8402 0.4396 0.2559\n", 165 | " 0.1516 0.3136 0.8176\n", 166 | " 0.8022 0.2979 0.1485\n", 167 | " 0.0600 0.8662 0.5225\n", 168 | "[torch.FloatTensor of size 5x3]\n", 169 | "\n" 170 | ] 171 | } 172 | ], 173 | "source": [ 174 | "y = torch.rand(5, 3)\n", 175 | "print(x + y)\n", 176 | "\n", 177 | "print(torch.add(x, y))" 178 | ] 179 | }, 180 | { 181 | "cell_type": "markdown", 182 | "metadata": { 183 | "hidden": true 184 | }, 185 | "source": [ 186 | "Getting Result as a Tensor\n", 187 | "\n", 188 | "This will return the sum into result variable" 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": 8, 194 | "metadata": { 195 | "hidden": true 196 | }, 197 | "outputs": [ 198 | { 199 | "name": "stdout", 200 | "output_type": "stream", 201 | "text": [ 202 | "\n", 203 | " 0.3524 0.9941 0.5052\n", 204 | " 0.8402 0.4396 0.2559\n", 205 | " 0.1516 0.3136 0.8176\n", 206 | " 0.8022 0.2979 0.1485\n", 207 | " 0.0600 0.8662 0.5225\n", 208 | "[torch.FloatTensor of size 5x3]\n", 209 | "\n" 210 | ] 211 | } 212 | ], 213 | "source": [ 214 | "result = torch.Tensor(5, 3)\n", 215 | "torch.add(x, y, out=result)\n", 216 | "print(result)" 217 | ] 218 | }, 219 | { 220 | "cell_type": "markdown", 221 | "metadata": { 222 | "hidden": true 223 | }, 224 | "source": [ 225 | "In Place Addition\n", 226 | "\n", 227 | "In place functions are followed by an _" 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": 9, 233 | "metadata": { 234 | "hidden": true 235 | }, 236 | "outputs": [ 237 | { 238 | "name": "stdout", 239 | "output_type": "stream", 240 | "text": [ 241 | "\n", 242 | " 0.3524 0.9941 0.5052\n", 243 | " 0.8402 0.4396 0.2559\n", 244 | " 0.1516 0.3136 0.8176\n", 245 | " 0.8022 0.2979 0.1485\n", 246 | " 0.0600 0.8662 0.5225\n", 247 | "[torch.FloatTensor of size 5x3]\n", 248 | "\n" 249 | ] 250 | } 251 | ], 252 | "source": [ 253 | "y.add_(x)\n", 254 | "print(y)" 255 | ] 256 | }, 257 | { 258 | "cell_type": "markdown", 259 | "metadata": { 260 | "hidden": true 261 | }, 262 | "source": [ 263 | "Indexing, Slicing" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": 11, 269 | "metadata": { 270 | "hidden": true 271 | }, 272 | "outputs": [ 273 | { 274 | "name": "stdout", 275 | "output_type": "stream", 276 | "text": [ 277 | "\n", 278 | "1.00000e-41 *\n", 279 | " 4.5595\n", 280 | " 0.0000\n", 281 | " 0.0000\n", 282 | " 0.0000\n", 283 | " 0.0000\n", 284 | "[torch.FloatTensor of size 5]\n", 285 | "\n" 286 | ] 287 | } 288 | ], 289 | "source": [ 290 | "print(x[:, 1])\n", 291 | "# Excercise: Try other slicing techniques here" 292 | ] 293 | }, 294 | { 295 | "cell_type": "markdown", 296 | "metadata": { 297 | "hidden": true 298 | }, 299 | "source": [ 300 | "Reshaping" 301 | ] 302 | }, 303 | { 304 | "cell_type": "code", 305 | "execution_count": 41, 306 | "metadata": { 307 | "hidden": true 308 | }, 309 | "outputs": [ 310 | { 311 | "name": "stdout", 312 | "output_type": "stream", 313 | "text": [ 314 | "torch.Size([5, 10, 15])\n", 315 | "torch.Size([50, 15])\n", 316 | "torch.Size([50, 1, 15])\n" 317 | ] 318 | } 319 | ], 320 | "source": [ 321 | "y = torch.randn(5, 10, 15)\n", 322 | "print(y.size())\n", 323 | "print(y.view(-1, 15).size()) # OR y.view(50, 15)\n", 324 | "print(y.view(-1, 15).unsqueeze(1).size()) # Adds a dimension at index 1." 325 | ] 326 | }, 327 | { 328 | "cell_type": "markdown", 329 | "metadata": { 330 | "heading_collapsed": true 331 | }, 332 | "source": [ 333 | "### Tensor Types\n" 334 | ] 335 | }, 336 | { 337 | "cell_type": "markdown", 338 | "metadata": { 339 | "hidden": true 340 | }, 341 | "source": [ 342 | "source: http://pytorch.org/docs/master/tensors.html\n", 343 | "\n", 344 | "|Data|type|Tensor|\n", 345 | "|--- |:--:| ----:|\n", 346 | "|32-bit|floating point|torch.FloatTensor|\n", 347 | "|64-bit|floating point|torch.DoubleTensor|\n", 348 | "|16-bit|floating point|torch.HalfTensor|\n", 349 | "|8-bit|integer (unsigned)|torch.ByteTensor|\n", 350 | "|8-bit|integer (signed)|torch.CharTensor|\n", 351 | "|16-bit|integer (signed)|torch.ShortTensorb|\n", 352 | "|32-bit|integer (signed)|torch.IntTensor|\n", 353 | "|64-bit|integer (signed)|torch.LongTensor|" 354 | ] 355 | }, 356 | { 357 | "cell_type": "code", 358 | "execution_count": 37, 359 | "metadata": { 360 | "hidden": true 361 | }, 362 | "outputs": [ 363 | { 364 | "data": { 365 | "text/plain": [ 366 | "\n", 367 | " 1.0449e+09 3.2538e+04\n", 368 | " 5.7330e+07 0.0000e+00\n", 369 | "[torch.IntTensor of size 2x2]" 370 | ] 371 | }, 372 | "execution_count": 37, 373 | "metadata": {}, 374 | "output_type": "execute_result" 375 | } 376 | ], 377 | "source": [ 378 | "int_tensor = torch.IntTensor(2,2)\n", 379 | "int_tensor" 380 | ] 381 | }, 382 | { 383 | "cell_type": "code", 384 | "execution_count": 38, 385 | "metadata": { 386 | "hidden": true 387 | }, 388 | "outputs": [ 389 | { 390 | "data": { 391 | "text/plain": [ 392 | "\n", 393 | " 0.1949 0.0000\n", 394 | " 0.0000 0.0000\n", 395 | "[torch.FloatTensor of size 2x2]" 396 | ] 397 | }, 398 | "execution_count": 38, 399 | "metadata": {}, 400 | "output_type": "execute_result" 401 | } 402 | ], 403 | "source": [ 404 | "float_tensor = torch.FloatTensor(2,2)\n", 405 | "float_tensor" 406 | ] 407 | }, 408 | { 409 | "cell_type": "code", 410 | "execution_count": 39, 411 | "metadata": { 412 | "hidden": true 413 | }, 414 | "outputs": [ 415 | { 416 | "data": { 417 | "text/plain": [ 418 | "\n", 419 | " 136 155\n", 420 | " 71 62\n", 421 | "[torch.ByteTensor of size 2x2]" 422 | ] 423 | }, 424 | "execution_count": 39, 425 | "metadata": {}, 426 | "output_type": "execute_result" 427 | } 428 | ], 429 | "source": [ 430 | "byte_tensor = torch.ByteTensor(2,2)\n", 431 | "byte_tensor" 432 | ] 433 | }, 434 | { 435 | "cell_type": "code", 436 | "execution_count": 24, 437 | "metadata": { 438 | "hidden": true 439 | }, 440 | "outputs": [ 441 | { 442 | "data": { 443 | "text/plain": [ 444 | "\n", 445 | " 1 1\n", 446 | " 1 1\n", 447 | "[torch.IntTensor of size 2x2]" 448 | ] 449 | }, 450 | "execution_count": 24, 451 | "metadata": {}, 452 | "output_type": "execute_result" 453 | } 454 | ], 455 | "source": [ 456 | "a = np.ones((2,2),dtype=np.int32)\n", 457 | "a_torch = torch.from_numpy(a)\n", 458 | "a_torch" 459 | ] 460 | }, 461 | { 462 | "cell_type": "markdown", 463 | "metadata": { 464 | "heading_collapsed": true 465 | }, 466 | "source": [ 467 | "### Numpy Bridge" 468 | ] 469 | }, 470 | { 471 | "cell_type": "code", 472 | "execution_count": 12, 473 | "metadata": { 474 | "hidden": true 475 | }, 476 | "outputs": [ 477 | { 478 | "name": "stdout", 479 | "output_type": "stream", 480 | "text": [ 481 | "[ 1. 1. 1. 1. 1.]\n" 482 | ] 483 | } 484 | ], 485 | "source": [ 486 | "a = torch.ones(5)\n", 487 | "b = a.numpy()\n", 488 | "print(b)" 489 | ] 490 | }, 491 | { 492 | "cell_type": "markdown", 493 | "metadata": { 494 | "hidden": true 495 | }, 496 | "source": [ 497 | "The torch Tensor and numpy array will share their underlying memory locations, and changing one will change the other." 498 | ] 499 | }, 500 | { 501 | "cell_type": "code", 502 | "execution_count": 13, 503 | "metadata": { 504 | "hidden": true 505 | }, 506 | "outputs": [ 507 | { 508 | "name": "stdout", 509 | "output_type": "stream", 510 | "text": [ 511 | "\n", 512 | " 2\n", 513 | " 2\n", 514 | " 2\n", 515 | " 2\n", 516 | " 2\n", 517 | "[torch.FloatTensor of size 5]\n", 518 | "\n", 519 | "[ 2. 2. 2. 2. 2.]\n" 520 | ] 521 | } 522 | ], 523 | "source": [ 524 | "a.add_(1)\n", 525 | "print(a)\n", 526 | "print(b)" 527 | ] 528 | }, 529 | { 530 | "cell_type": "markdown", 531 | "metadata": { 532 | "heading_collapsed": true 533 | }, 534 | "source": [ 535 | "### PyTorch Bridge" 536 | ] 537 | }, 538 | { 539 | "cell_type": "code", 540 | "execution_count": 14, 541 | "metadata": { 542 | "hidden": true 543 | }, 544 | "outputs": [ 545 | { 546 | "name": "stdout", 547 | "output_type": "stream", 548 | "text": [ 549 | "[ 2. 2. 2. 2. 2.]\n", 550 | "\n", 551 | " 2\n", 552 | " 2\n", 553 | " 2\n", 554 | " 2\n", 555 | " 2\n", 556 | "[torch.DoubleTensor of size 5]\n", 557 | "\n" 558 | ] 559 | } 560 | ], 561 | "source": [ 562 | "a = np.ones(5)\n", 563 | "b = torch.from_numpy(a)\n", 564 | "np.add(a, 1, out=a)\n", 565 | "print(a)\n", 566 | "print(b)" 567 | ] 568 | }, 569 | { 570 | "cell_type": "markdown", 571 | "metadata": { 572 | "heading_collapsed": true 573 | }, 574 | "source": [ 575 | "### Using GPU\n", 576 | "Moving the Tensors to GPU" 577 | ] 578 | }, 579 | { 580 | "cell_type": "code", 581 | "execution_count": 15, 582 | "metadata": { 583 | "hidden": true 584 | }, 585 | "outputs": [], 586 | "source": [ 587 | "if torch.cuda.is_available():\n", 588 | " x = x.cuda()\n", 589 | " y = y.cuda()\n", 590 | " x + y" 591 | ] 592 | }, 593 | { 594 | "cell_type": "markdown", 595 | "metadata": { 596 | "heading_collapsed": true 597 | }, 598 | "source": [ 599 | "### Autograd" 600 | ] 601 | }, 602 | { 603 | "cell_type": "markdown", 604 | "metadata": { 605 | "hidden": true 606 | }, 607 | "source": [ 608 | "The autograd package provides automatic differentiation for all operations on Tensors. It is a define-by-run framework, which means that your backprop is defined by how your code is run, and that every single iteration can be different.\n", 609 | "\n", 610 | "autograd.Variable is the central class of the package. It wraps a Tensor, and supports nearly all of operations defined on it. Once you finish your computation you can call .backward() and have all the gradients computed automatically.\n", 611 | "\n", 612 | "You can access the raw tensor through the .data attribute, while the gradient w.r.t. this variable is accumulated into .grad.\n", 613 | "\n", 614 | "![](img/auto.png)" 615 | ] 616 | }, 617 | { 618 | "cell_type": "code", 619 | "execution_count": 25, 620 | "metadata": { 621 | "hidden": true 622 | }, 623 | "outputs": [], 624 | "source": [ 625 | "import torch\n", 626 | "from torch.autograd import Variable" 627 | ] 628 | }, 629 | { 630 | "cell_type": "code", 631 | "execution_count": 26, 632 | "metadata": { 633 | "hidden": true 634 | }, 635 | "outputs": [], 636 | "source": [ 637 | "x_data = [1.0, 2.0, 3.0]\n", 638 | "y_data = [2.0, 4.0, 6.0]\n", 639 | "\n", 640 | "w = Variable(torch.Tensor([1.0]), requires_grad=True) " 641 | ] 642 | }, 643 | { 644 | "cell_type": "markdown", 645 | "metadata": { 646 | "hidden": true 647 | }, 648 | "source": [ 649 | "Requires grad = Allows us to Calculate Gradients" 650 | ] 651 | }, 652 | { 653 | "cell_type": "markdown", 654 | "metadata": { 655 | "hidden": true 656 | }, 657 | "source": [ 658 | "Implement Forward Pass\n", 659 | "\n", 660 | "Multiply the Input Tensor X with the weight Tensor W" 661 | ] 662 | }, 663 | { 664 | "cell_type": "code", 665 | "execution_count": 29, 666 | "metadata": { 667 | "hidden": true 668 | }, 669 | "outputs": [ 670 | { 671 | "name": "stdout", 672 | "output_type": "stream", 673 | "text": [ 674 | "\tgrad: 1.0 2.0 -2.0\n", 675 | "\tgrad: 2.0 4.0 -7.840000152587891\n", 676 | "\tgrad: 3.0 6.0 -16.228801727294922\n", 677 | "progress: 0 7.315943717956543\n", 678 | "\tgrad: 1.0 2.0 -1.478623867034912\n", 679 | "\tgrad: 2.0 4.0 -5.796205520629883\n", 680 | "\tgrad: 3.0 6.0 -11.998146057128906\n", 681 | "progress: 1 3.9987640380859375\n", 682 | "\tgrad: 1.0 2.0 -1.0931644439697266\n", 683 | "\tgrad: 2.0 4.0 -4.285204887390137\n", 684 | "\tgrad: 3.0 6.0 -8.870372772216797\n", 685 | "progress: 2 2.1856532096862793\n", 686 | "\tgrad: 1.0 2.0 -0.8081896305084229\n", 687 | "\tgrad: 2.0 4.0 -3.1681032180786133\n", 688 | "\tgrad: 3.0 6.0 -6.557973861694336\n", 689 | "progress: 3 1.1946394443511963\n", 690 | "\tgrad: 1.0 2.0 -0.5975041389465332\n", 691 | "\tgrad: 2.0 4.0 -2.3422164916992188\n", 692 | "\tgrad: 3.0 6.0 -4.848389625549316\n", 693 | "progress: 4 0.6529689431190491\n", 694 | "\tgrad: 1.0 2.0 -0.4417421817779541\n", 695 | "\tgrad: 2.0 4.0 -1.7316293716430664\n", 696 | "\tgrad: 3.0 6.0 -3.58447265625\n", 697 | "progress: 5 0.35690122842788696\n", 698 | "\tgrad: 1.0 2.0 -0.3265852928161621\n", 699 | "\tgrad: 2.0 4.0 -1.2802143096923828\n", 700 | "\tgrad: 3.0 6.0 -2.650045394897461\n", 701 | "progress: 6 0.195076122879982\n", 702 | "\tgrad: 1.0 2.0 -0.24144840240478516\n", 703 | "\tgrad: 2.0 4.0 -0.9464778900146484\n", 704 | "\tgrad: 3.0 6.0 -1.9592113494873047\n", 705 | "progress: 7 0.10662525147199631\n", 706 | "\tgrad: 1.0 2.0 -0.17850565910339355\n", 707 | "\tgrad: 2.0 4.0 -0.699742317199707\n", 708 | "\tgrad: 3.0 6.0 -1.4484672546386719\n", 709 | "progress: 8 0.0582793727517128\n", 710 | "\tgrad: 1.0 2.0 -0.1319713592529297\n", 711 | "\tgrad: 2.0 4.0 -0.5173273086547852\n", 712 | "\tgrad: 3.0 6.0 -1.070866584777832\n", 713 | "progress: 9 0.03185431286692619\n", 714 | "predict (after training) 4 7.804864406585693\n" 715 | ] 716 | } 717 | ], 718 | "source": [ 719 | "def forward(x):\n", 720 | " return x * w\n", 721 | "\n", 722 | "# After training\n", 723 | "print(\"predict (after training)\", 4, forward(4).data[0])" 724 | ] 725 | }, 726 | { 727 | "cell_type": "markdown", 728 | "metadata": { 729 | "hidden": true 730 | }, 731 | "source": [ 732 | "Loss\n", 733 | "\n", 734 | "Loss is defined as the difference of prediction and our Estimate" 735 | ] 736 | }, 737 | { 738 | "cell_type": "code", 739 | "execution_count": 30, 740 | "metadata": { 741 | "hidden": true 742 | }, 743 | "outputs": [], 744 | "source": [ 745 | "def loss(x, y):\n", 746 | " y_pred = forward(x)\n", 747 | " return (y_pred - y) * (y_pred - y)" 748 | ] 749 | }, 750 | { 751 | "cell_type": "markdown", 752 | "metadata": { 753 | "hidden": true 754 | }, 755 | "source": [ 756 | "Training our NN\n", 757 | "\n", 758 | "Training a NN involves calculating Gradients and changing weights based on Backpropagation" 759 | ] 760 | }, 761 | { 762 | "cell_type": "code", 763 | "execution_count": 35, 764 | "metadata": { 765 | "hidden": true 766 | }, 767 | "outputs": [ 768 | { 769 | "name": "stdout", 770 | "output_type": "stream", 771 | "text": [ 772 | "progress epoch Losst 0 2.3283064365386963e-10\n", 773 | "progress epoch Losst 1 1.2028067430946976e-10\n", 774 | "progress epoch Losst 2 5.820766091346741e-11\n", 775 | "progress epoch Losst 3 3.842615114990622e-11\n", 776 | "progress epoch Losst 4 2.2737367544323206e-11\n", 777 | "progress epoch Losst 5 1.4551915228366852e-11\n", 778 | "progress epoch Losst 6 5.6843418860808015e-12\n", 779 | "progress epoch Losst 7 3.637978807091713e-12\n", 780 | "progress epoch Losst 8 3.637978807091713e-12\n", 781 | "progress epoch Losst 9 2.0463630789890885e-12\n" 782 | ] 783 | } 784 | ], 785 | "source": [ 786 | "for epoch in range(10):\n", 787 | " for x_val, y_val in zip(x_data, y_data):\n", 788 | " l = loss(x_val, y_val)\n", 789 | " l.backward()\n", 790 | " #print(\"grad: \", x_val, y_val, w.grad.data[0])\n", 791 | " w.data = w.data - 0.01 * w.grad.data\n", 792 | "\n", 793 | " # Manually zero the gradients after updating weights\n", 794 | " w.grad.data.zero_()\n", 795 | "\n", 796 | " print(\"progress epoch Losst\", epoch, l.data[0])" 797 | ] 798 | }, 799 | { 800 | "cell_type": "markdown", 801 | "metadata": { 802 | "hidden": true 803 | }, 804 | "source": [ 805 | "Credits:\n", 806 | "\n", 807 | "http://github.com/pytorch/examples\n", 808 | "\n", 809 | "https://github.com/vinhkhuc/PyTorch-Mini-Tutorials/blob/master/0_multiply.py" 810 | ] 811 | }, 812 | { 813 | "cell_type": "code", 814 | "execution_count": null, 815 | "metadata": { 816 | "collapsed": true, 817 | "hidden": true 818 | }, 819 | "outputs": [], 820 | "source": [] 821 | } 822 | ], 823 | "metadata": { 824 | "kernelspec": { 825 | "display_name": "Python 3", 826 | "language": "python", 827 | "name": "python3" 828 | }, 829 | "language_info": { 830 | "codemirror_mode": { 831 | "name": "ipython", 832 | "version": 3 833 | }, 834 | "file_extension": ".py", 835 | "mimetype": "text/x-python", 836 | "name": "python", 837 | "nbconvert_exporter": "python", 838 | "pygments_lexer": "ipython3", 839 | "version": "3.6.3" 840 | } 841 | }, 842 | "nbformat": 4, 843 | "nbformat_minor": 2 844 | } 845 | -------------------------------------------------------------------------------- /PyTorch/Linear Regression.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Linear Regression\n", 8 | "\n", 9 | "In this tutorial, we'll try the classic Linear Regression Algorithm\n", 10 | "\n", 11 | "![Linear Regression](img/lr.jpg)\n", 12 | "\n", 13 | "Linear Regression involves creating a best fit linear line such the distance between the y' points on line and real values is minimum (the summation of the distance is known as our loss)\n" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "Import Libraries" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": { 27 | "collapsed": true 28 | }, 29 | "outputs": [], 30 | "source": [ 31 | "import torch\n", 32 | "import torch.nn as nn\n", 33 | "from torch.autograd import Variable\n", 34 | "import numpy as np\n", 35 | "import matplotlib.pyplot as plt" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "Initializing Seed for consistent results everytime" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": null, 48 | "metadata": { 49 | "collapsed": true 50 | }, 51 | "outputs": [], 52 | "source": [ 53 | "np.random.seed(42)\n", 54 | "pts = 50" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "Creating a Dataset of 50 points" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": { 68 | "collapsed": true 69 | }, 70 | "outputs": [], 71 | "source": [ 72 | "x_vals = np.random.rand(50)\n", 73 | "x_train = np.asarray(x_vals,dtype=np.float32).reshape(-1,1)\n", 74 | "m = 1\n", 75 | "alpha = np.random.rand(1)\n", 76 | "beta = np.random.rand(1)\n", 77 | "y_correct = np.asarray([2*i+m for i in x_vals], dtype=np.float32).reshape(-1,1)" 78 | ] 79 | }, 80 | { 81 | "cell_type": "markdown", 82 | "metadata": {}, 83 | "source": [ 84 | "### PyTorch Models\n", 85 | "\n", 86 | "1. Create a Class\n", 87 | "2. Declare your Forward Pass\n", 88 | "3. Tune the HyperParameters" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": { 95 | "collapsed": true 96 | }, 97 | "outputs": [], 98 | "source": [ 99 | "class LinearRegressionModel(nn.Module):\n", 100 | "\n", 101 | " def __init__(self, input_dim, output_dim):\n", 102 | "\n", 103 | " super(LinearRegressionModel, self).__init__() \n", 104 | " # Calling Super Class's constructor\n", 105 | " self.linear = nn.Linear(input_dim, output_dim)\n", 106 | " # nn.linear is defined in nn.Module\n", 107 | "\n", 108 | " def forward(self, x):\n", 109 | " # Here the forward pass is simply a linear function\n", 110 | "\n", 111 | " out = self.linear(x)\n", 112 | " return out\n", 113 | "\n", 114 | "input_dim = 1\n", 115 | "output_dim = 1" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": {}, 121 | "source": [ 122 | "### Steps\n", 123 | "1. Create instance of model\n", 124 | "2. Select Loss Criterion\n", 125 | "3. Choose Hyper Parameters" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": { 132 | "collapsed": true 133 | }, 134 | "outputs": [], 135 | "source": [ 136 | "model = LinearRegressionModel(input_dim,output_dim)# create our model just as we do in Scikit-Learn / C / C++//\n", 137 | "\n", 138 | "criterion = nn.MSELoss()# Mean Squared Loss\n", 139 | "l_rate = 0.01\n", 140 | "optimiser = torch.optim.SGD(model.parameters(), lr = l_rate) #Stochastic Gradient Descent\n", 141 | "\n", 142 | "epochs = 2000" 143 | ] 144 | }, 145 | { 146 | "cell_type": "markdown", 147 | "metadata": {}, 148 | "source": [ 149 | "### Train the Model" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": null, 155 | "metadata": { 156 | "collapsed": true 157 | }, 158 | "outputs": [], 159 | "source": [ 160 | "for epoch in range(epochs):\n", 161 | "\n", 162 | " epoch +=1\n", 163 | " inputs = Variable(torch.from_numpy(x_train))\n", 164 | " labels = Variable(torch.from_numpy(y_correct))\n", 165 | "\n", 166 | " #clear grads\n", 167 | " optimiser.zero_grad()\n", 168 | " #forward to get predicted values\n", 169 | " outputs = model.forward(inputs)\n", 170 | " loss = criterion(outputs, labels)\n", 171 | " loss.backward()# back props\n", 172 | " optimiser.step()# update the parameters\n", 173 | " print('epoch {}, loss {}'.format(epoch,loss.data[0]))" 174 | ] 175 | }, 176 | { 177 | "cell_type": "markdown", 178 | "metadata": {}, 179 | "source": [ 180 | "### Printing the Predictions" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": null, 186 | "metadata": { 187 | "collapsed": true 188 | }, 189 | "outputs": [], 190 | "source": [ 191 | "predicted = model.forward(Variable(torch.from_numpy(x_train))).data.numpy()\n", 192 | "\n", 193 | "plt.plot(x_train, y_correct, 'go', label = 'from data', alpha = .5)\n", 194 | "plt.plot(x_train, predicted, label = 'prediction', alpha = 0.5)\n", 195 | "plt.legend()\n", 196 | "plt.show()\n", 197 | "print(model.state_dict())" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "metadata": {}, 203 | "source": [ 204 | "### Example to Use GPU" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": null, 210 | "metadata": { 211 | "collapsed": true 212 | }, 213 | "outputs": [], 214 | "source": [ 215 | "import torch\n", 216 | "import torch.nn as nn\n", 217 | "from torch.autograd import Variable\n", 218 | "import numpy as np\n", 219 | "\n", 220 | "x_values = [i for i in range(11)]\n", 221 | "x_train = np.array(x_values, dtype=np.float32)\n", 222 | "x_train = x_train.reshape(-1, 1)\n", 223 | "\n", 224 | "y_values = [2*i + 1 for i in x_values]\n", 225 | "y_train = np.array(y_values, dtype=np.float32)\n", 226 | "y_train = y_train.reshape(-1, 1)\n", 227 | "\n", 228 | "'''\n", 229 | "CREATE MODEL CLASS\n", 230 | "'''\n", 231 | "class LinearRegressionModel(nn.Module):\n", 232 | " def __init__(self, input_dim, output_dim):\n", 233 | " super(LinearRegressionModel, self).__init__()\n", 234 | " self.linear = nn.Linear(input_dim, output_dim) \n", 235 | " \n", 236 | " def forward(self, x):\n", 237 | " out = self.linear(x)\n", 238 | " return out\n", 239 | "\n", 240 | "'''\n", 241 | "INSTANTIATE MODEL CLASS\n", 242 | "'''\n", 243 | "input_dim = 1\n", 244 | "output_dim = 1\n", 245 | "\n", 246 | "model = LinearRegressionModel(input_dim, output_dim)\n", 247 | "\n", 248 | "\n", 249 | "\n", 250 | "model.cuda()\n", 251 | "\n", 252 | "'''\n", 253 | "INSTANTIATE LOSS CLASS\n", 254 | "'''\n", 255 | "\n", 256 | "criterion = nn.MSELoss()\n", 257 | "\n", 258 | "\n", 259 | "learning_rate = 0.01\n", 260 | "\n", 261 | "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n", 262 | "\n", 263 | "\n", 264 | "epochs = 100\n", 265 | "for epoch in range(epochs):\n", 266 | " epoch += 1\n", 267 | "\n", 268 | " \n", 269 | " if torch.cuda.is_available():\n", 270 | " inputs = Variable(torch.from_numpy(x_train).cuda())\n", 271 | "\n", 272 | " \n", 273 | " if torch.cuda.is_available():\n", 274 | " labels = Variable(torch.from_numpy(y_train).cuda())\n", 275 | " \n", 276 | "\n", 277 | " optimizer.zero_grad() \n", 278 | " \n", 279 | "\n", 280 | " outputs = model(inputs)\n", 281 | "\n", 282 | " loss = criterion(outputs, labels)\n", 283 | " \n", 284 | "\n", 285 | " loss.backward()\n", 286 | " \n", 287 | "\n", 288 | " optimizer.step()\n", 289 | " \n", 290 | "\n", 291 | " print('epoch {}, loss {}'.format(epoch, loss.data[0]))\n" 292 | ] 293 | }, 294 | { 295 | "cell_type": "markdown", 296 | "metadata": {}, 297 | "source": [ 298 | "Sources:\n", 299 | "http://github.com/pytorch/examples\n", 300 | "\n", 301 | "http://github.com/ritchieng/the-incredible-pytorch" 302 | ] 303 | } 304 | ], 305 | "metadata": { 306 | "kernelspec": { 307 | "display_name": "Python 3", 308 | "language": "python", 309 | "name": "python3" 310 | }, 311 | "language_info": { 312 | "codemirror_mode": { 313 | "name": "ipython", 314 | "version": 3 315 | }, 316 | "file_extension": ".py", 317 | "mimetype": "text/x-python", 318 | "name": "python", 319 | "nbconvert_exporter": "python", 320 | "pygments_lexer": "ipython3", 321 | "version": "3.6.1" 322 | } 323 | }, 324 | "nbformat": 4, 325 | "nbformat_minor": 2 326 | } 327 | -------------------------------------------------------------------------------- /PyTorch/Logistic + NN.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Logistic Regression" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## Imports" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 1, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "import torch\n", 24 | "import torch.nn as nn\n", 25 | "import torchvision.transforms as transforms\n", 26 | "import torchvision.datasets as dsets\n", 27 | "from torch.autograd import Variable" 28 | ] 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "metadata": {}, 33 | "source": [ 34 | "## Loading The DataSet (from PyTorch webpage)" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 2, 40 | "metadata": {}, 41 | "outputs": [], 42 | "source": [ 43 | "#LOADING DATASET\n", 44 | "\n", 45 | "train_dataset = dsets.MNIST(root='./data', \n", 46 | " train=True, \n", 47 | " transform=transforms.ToTensor(),\n", 48 | " download=True)\n", 49 | "\n", 50 | "test_dataset = dsets.MNIST(root='./data', \n", 51 | " train=False, \n", 52 | " transform=transforms.ToTensor())" 53 | ] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "metadata": {}, 58 | "source": [ 59 | "## Doing Some Pre-processing" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": 3, 65 | "metadata": {}, 66 | "outputs": [], 67 | "source": [ 68 | "#MAKING DATASET ITERABLE\n", 69 | "\n", 70 | "batch_size = 100\n", 71 | "n_iters = 3000\n", 72 | "num_epochs = n_iters // (len(train_dataset) // batch_size)\n", 73 | "all_loss = []\n", 74 | "all_accuracy = []\n", 75 | "## From The Docs..." 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 4, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, \n", 85 | " batch_size=batch_size, \n", 86 | " shuffle=True)\n", 87 | "\n", 88 | "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, \n", 89 | " batch_size=batch_size, \n", 90 | " shuffle=False)" 91 | ] 92 | }, 93 | { 94 | "cell_type": "markdown", 95 | "metadata": {}, 96 | "source": [ 97 | "## Create The Model Class" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": 5, 103 | "metadata": {}, 104 | "outputs": [], 105 | "source": [ 106 | "#CREATE THE CLASS\n", 107 | "class LogisticRegressionModel(nn.Module):\n", 108 | "\n", 109 | " def __init__(self, input_dim, output_dim):\n", 110 | " \n", 111 | " super(LogisticRegressionModel, self).__init__()\n", 112 | " self.linear = nn.Linear(input_dim, output_dim)\n", 113 | " \n", 114 | " def forward(self, x):\n", 115 | " out = self.linear(x)\n", 116 | " return out" 117 | ] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "## Instantiaing The Class" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": 6, 129 | "metadata": {}, 130 | "outputs": [ 131 | { 132 | "name": "stdout", 133 | "output_type": "stream", 134 | "text": [ 135 | "Running On GPU\n" 136 | ] 137 | } 138 | ], 139 | "source": [ 140 | "input_dim = 28*28\n", 141 | "output_dim = 10\n", 142 | "\n", 143 | "model = LogisticRegressionModel(input_dim, output_dim)\n", 144 | "\n", 145 | "# USE GPU FOR MODEL\n", 146 | "\n", 147 | "if torch.cuda.is_available():\n", 148 | " model.cuda()\n", 149 | " print(\"Running On GPU\")\n", 150 | "\n", 151 | "#LOSS CLASS\n", 152 | "criterion = nn.CrossEntropyLoss()\n", 153 | "#OPTIMIZER CLASS\n", 154 | "learning_rate = 0.001\n", 155 | "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)" 156 | ] 157 | }, 158 | { 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "## Trainig Begins.....(took around 80secs on my Machine(GPU Enabled))" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 7, 168 | "metadata": {}, 169 | "outputs": [ 170 | { 171 | "name": "stdout", 172 | "output_type": "stream", 173 | "text": [ 174 | "Iteration: 500. Loss: 1.8182646036148071. Accuracy: 67.63\n", 175 | "Iteration: 1000. Loss: 1.6447023153305054. Accuracy: 75.38\n", 176 | "Iteration: 1500. Loss: 1.2641823291778564. Accuracy: 78.36\n", 177 | "Iteration: 2000. Loss: 1.222143292427063. Accuracy: 80.45\n", 178 | "Iteration: 2500. Loss: 1.0849171876907349. Accuracy: 81.72\n", 179 | "Iteration: 3000. Loss: 1.045166254043579. Accuracy: 82.76\n" 180 | ] 181 | } 182 | ], 183 | "source": [ 184 | "#TRAIN THE MODEL\n", 185 | "iter = 0\n", 186 | "%timeit\n", 187 | "for epoch in range(num_epochs):\n", 188 | " for i, (images, labels) in enumerate(train_loader):\n", 189 | " \n", 190 | " # USE GPU FOR MODEL\n", 191 | " \n", 192 | " if torch.cuda.is_available():\n", 193 | " images = Variable(images.view(-1, 28*28).cuda())\n", 194 | " labels = Variable(labels.cuda())\n", 195 | " else:\n", 196 | " images = Variable(images.view(-1, 28*28))\n", 197 | " labels = Variable(labels)\n", 198 | " \n", 199 | " # Clear gradients w.r.t. parameters\n", 200 | " optimizer.zero_grad()\n", 201 | " \n", 202 | " # Forward pass to get output/logits\n", 203 | " outputs = model(images)\n", 204 | " \n", 205 | " # Calculate Loss: softmax --> cross entropy loss\n", 206 | " loss = criterion(outputs, labels)\n", 207 | " \n", 208 | " # Getting gradients w.r.t. parameters\n", 209 | " loss.backward()\n", 210 | " \n", 211 | " # Updating parameters\n", 212 | " optimizer.step()\n", 213 | " \n", 214 | " iter += 1\n", 215 | " \n", 216 | " if iter % 500 == 0:\n", 217 | "\n", 218 | " # Calculate Accuracy \n", 219 | " correct = 0\n", 220 | " total = 0\n", 221 | " # Iterate through test dataset\n", 222 | " \n", 223 | " for images, labels in test_loader:\n", 224 | "\n", 225 | " # USE GPU FOR MODEL #\n", 226 | " images = Variable(images.view(-1, 28*28).cuda())\n", 227 | " \n", 228 | " # Forward pass only to get logits/output\n", 229 | " outputs = model(images)\n", 230 | " \n", 231 | " # Get predictions from the maximum value\n", 232 | " _, predicted = torch.max(outputs.data, 1)\n", 233 | " \n", 234 | " # Total number of labels\n", 235 | " total += labels.size(0)\n", 236 | " \n", 237 | " # USE GPU FOR MODEL #\n", 238 | " \n", 239 | " # Total correct predictions\n", 240 | "\n", 241 | " correct += (predicted.cpu() == labels.cpu()).sum()\n", 242 | " \n", 243 | " accuracy = 100 * correct / total\n", 244 | " \n", 245 | " all_loss.append(loss.data[0])\n", 246 | " all_accuracy.append(accuracy)\n", 247 | " \n", 248 | " # Print Loss\n", 249 | " print('Iteration: {}. Loss: {}. Accuracy: {}'.format(iter, loss.data[0], accuracy))" 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": 8, 255 | "metadata": { 256 | "scrolled": true 257 | }, 258 | "outputs": [ 259 | { 260 | "data": { 261 | "text/plain": [ 262 | "([1.8182646036148071,\n", 263 | " 1.6447023153305054,\n", 264 | " 1.2641823291778564,\n", 265 | " 1.222143292427063,\n", 266 | " 1.0849171876907349,\n", 267 | " 1.045166254043579],\n", 268 | " [67.63, 75.38, 78.36, 80.45, 81.72, 82.76])" 269 | ] 270 | }, 271 | "execution_count": 8, 272 | "metadata": {}, 273 | "output_type": "execute_result" 274 | } 275 | ], 276 | "source": [ 277 | "all_loss , all_accuracy" 278 | ] 279 | }, 280 | { 281 | "cell_type": "code", 282 | "execution_count": 9, 283 | "metadata": {}, 284 | "outputs": [ 285 | { 286 | "data": { 287 | "text/plain": [ 288 | "[]" 289 | ] 290 | }, 291 | "execution_count": 9, 292 | "metadata": {}, 293 | "output_type": "execute_result" 294 | }, 295 | { 296 | "data": { 297 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAecAAAHiCAYAAADSwATnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", 298 | "text/plain": [ 299 | "" 300 | ] 301 | }, 302 | "metadata": {}, 303 | "output_type": "display_data" 304 | } 305 | ], 306 | "source": [ 307 | "%matplotlib inline\n", 308 | "import matplotlib.pyplot as plt\n", 309 | "plt.figure(figsize=(8,8))\n", 310 | "plt.title(s = 'Loss And Accuracy')\n", 311 | "plt.xlabel('Accuracy')\n", 312 | "plt.ylabel('Loss')\n", 313 | "plt.plot(all_accuracy, all_loss)" 314 | ] 315 | }, 316 | { 317 | "cell_type": "markdown", 318 | "metadata": {}, 319 | "source": [ 320 | "# A Very Simple Neural Net On A Very Simple Dataset" 321 | ] 322 | }, 323 | { 324 | "cell_type": "markdown", 325 | "metadata": {}, 326 | "source": [ 327 | "## Creating The Class" 328 | ] 329 | }, 330 | { 331 | "cell_type": "code", 332 | "execution_count": 10, 333 | "metadata": {}, 334 | "outputs": [], 335 | "source": [ 336 | "class FeedforwardNeuralNetModel(nn.Module):\n", 337 | " \n", 338 | " def __init__(self, input_dim, hidden_dim, output_dim):\n", 339 | " \n", 340 | " super(FeedforwardNeuralNetModel, self).__init__()\n", 341 | " \n", 342 | " # Linear function 1: 784 --> 100\n", 343 | " self.fc1 = nn.Linear(input_dim, hidden_dim) \n", 344 | " # Non-linearity 1\n", 345 | " self.relu1 = nn.ReLU()\n", 346 | " \n", 347 | " # Linear function 2: 100 --> 100\n", 348 | " self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n", 349 | " # Non-linearity 2\n", 350 | " self.relu2 = nn.ReLU()\n", 351 | " \n", 352 | " # Linear function 3: 100 --> 64\n", 353 | " self.fc3 = nn.Linear(hidden_dim, 64)\n", 354 | " # Non-linearity 3\n", 355 | " self.relu3 = nn.ReLU()\n", 356 | " \n", 357 | " # Linear function 4 (readout): 64 --> 10\n", 358 | " self.fc4 = nn.Linear(64, output_dim) \n", 359 | " \n", 360 | " def forward(self, x):\n", 361 | " \n", 362 | " # Linear function 1\n", 363 | " out = self.fc1(x)\n", 364 | " # Non-linearity 1\n", 365 | " out = self.relu1(out)\n", 366 | " \n", 367 | " # Linear function 2\n", 368 | " out = self.fc2(out)\n", 369 | " # Non-linearity 2\n", 370 | " out = self.relu2(out)\n", 371 | " \n", 372 | " # Linear function 2\n", 373 | " out = self.fc3(out)\n", 374 | " # Non-linearity 2\n", 375 | " out = self.relu3(out)\n", 376 | " \n", 377 | " # Linear function 4 (readout)\n", 378 | " out = self.fc4(out)\n", 379 | " return out" 380 | ] 381 | }, 382 | { 383 | "cell_type": "code", 384 | "execution_count": 11, 385 | "metadata": {}, 386 | "outputs": [], 387 | "source": [ 388 | "input_dim = 28*28\n", 389 | "hidden_dim = 100\n", 390 | "output_dim = 10\n", 391 | "\n", 392 | "model_nn = FeedforwardNeuralNetModel(input_dim, hidden_dim, output_dim)" 393 | ] 394 | }, 395 | { 396 | "cell_type": "code", 397 | "execution_count": 12, 398 | "metadata": {}, 399 | "outputs": [ 400 | { 401 | "data": { 402 | "text/plain": [ 403 | "" 412 | ] 413 | }, 414 | "execution_count": 12, 415 | "metadata": {}, 416 | "output_type": "execute_result" 417 | } 418 | ], 419 | "source": [ 420 | "model_nn.parameters" 421 | ] 422 | }, 423 | { 424 | "cell_type": "code", 425 | "execution_count": 13, 426 | "metadata": {}, 427 | "outputs": [], 428 | "source": [ 429 | "if torch.cuda.is_available():\n", 430 | " model_nn.cuda()\n", 431 | "criterion = nn.CrossEntropyLoss()\n", 432 | "learning_rate = 0.1\n", 433 | "optimizer = torch.optim.SGD(model_nn.parameters(), lr=learning_rate)" 434 | ] 435 | }, 436 | { 437 | "cell_type": "markdown", 438 | "metadata": {}, 439 | "source": [ 440 | "## TRAIN THE MODEL" 441 | ] 442 | }, 443 | { 444 | "cell_type": "code", 445 | "execution_count": 14, 446 | "metadata": {}, 447 | "outputs": [ 448 | { 449 | "name": "stdout", 450 | "output_type": "stream", 451 | "text": [ 452 | "Iteration: 500. Loss: 0.3472854197025299. Accuracy: 89.92\n", 453 | "Iteration: 1000. Loss: 0.2566245198249817. Accuracy: 93.88\n", 454 | "Iteration: 1500. Loss: 0.18336555361747742. Accuracy: 95.26\n", 455 | "Iteration: 2000. Loss: 0.08581666648387909. Accuracy: 96.03\n", 456 | "Iteration: 2500. Loss: 0.059236761182546616. Accuracy: 96.05\n", 457 | "Iteration: 3000. Loss: 0.11973541229963303. Accuracy: 97.01\n" 458 | ] 459 | } 460 | ], 461 | "source": [ 462 | "iter = 0\n", 463 | "all_accuracy = []\n", 464 | "all_loss = []\n", 465 | "\n", 466 | "for epoch in range(num_epochs):\n", 467 | " for i, (images, labels) in enumerate(train_loader):\n", 468 | " \n", 469 | " if torch.cuda.is_available():\n", 470 | " images = Variable(images.view(-1, 28*28).cuda())\n", 471 | " labels = Variable(labels.cuda())\n", 472 | " else:\n", 473 | " images = Variable(images.view(-1, 28*28))\n", 474 | " labels = Variable(labels)\n", 475 | " \n", 476 | " # Clear gradients w.r.t. parameters\n", 477 | " optimizer.zero_grad()\n", 478 | " \n", 479 | " # Forward pass to get output/logits\n", 480 | " outputs = model_nn(images)\n", 481 | " \n", 482 | " # Calculate Loss: softmax --> cross entropy loss\n", 483 | " loss = criterion(outputs, labels)\n", 484 | " \n", 485 | " # Getting gradients w.r.t. parameters\n", 486 | " loss.backward()\n", 487 | " \n", 488 | " # Updating parameters\n", 489 | " optimizer.step()\n", 490 | " \n", 491 | " iter += 1\n", 492 | " \n", 493 | " if iter % 500 == 0:\n", 494 | " # Calculate Accuracy \n", 495 | " correct = 0\n", 496 | " total = 0\n", 497 | " # Iterate through test dataset\n", 498 | " for images, labels in test_loader:\n", 499 | " \n", 500 | " images = Variable(images.view(-1, 28*28).cuda())\n", 501 | " \n", 502 | " # Forward pass only to get logits/output\n", 503 | " outputs = model_nn(images)\n", 504 | " \n", 505 | " # Get predictions from the maximum value\n", 506 | " _, predicted = torch.max(outputs.data, 1)\n", 507 | " \n", 508 | " # Total number of labels\n", 509 | " total += labels.size(0)\n", 510 | "\n", 511 | " # Total correct predictions\n", 512 | " correct += (predicted.cpu() == labels.cpu()).sum()\n", 513 | " \n", 514 | " accuracy = 100 * correct / total\n", 515 | " all_loss.append(loss.data[0])\n", 516 | " all_accuracy.append(accuracy)\n", 517 | " \n", 518 | " # Print Loss\n", 519 | " print('Iteration: {}. Loss: {}. Accuracy: {}'.format(iter, loss.data[0], accuracy))" 520 | ] 521 | }, 522 | { 523 | "cell_type": "code", 524 | "execution_count": 16, 525 | "metadata": {}, 526 | "outputs": [ 527 | { 528 | "data": { 529 | "text/plain": [ 530 | "[]" 531 | ] 532 | }, 533 | "execution_count": 16, 534 | "metadata": {}, 535 | "output_type": "execute_result" 536 | }, 537 | { 538 | "data": { 539 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfsAAAHwCAYAAAChTMYRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n52RvZmZWcf8At0diHBpCuP8AAAAASUVORK5CYII=\n", 540 | "text/plain": [ 541 | "" 542 | ] 543 | }, 544 | "metadata": {}, 545 | "output_type": "display_data" 546 | } 547 | ], 548 | "source": [ 549 | "plt.figure(figsize=(8,8))\n", 550 | "plt.title(s = 'Loss And Accuracy')\n", 551 | "plt.xlabel('Accuracy')\n", 552 | "plt.ylabel('Loss')\n", 553 | "plt.plot(all_accuracy, all_loss)" 554 | ] 555 | }, 556 | { 557 | "cell_type": "raw", 558 | "metadata": {}, 559 | "source": [ 560 | "##Thanks.." 561 | ] 562 | } 563 | ], 564 | "metadata": { 565 | "kernelspec": { 566 | "display_name": "Python 3", 567 | "language": "python", 568 | "name": "python3" 569 | }, 570 | "language_info": { 571 | "codemirror_mode": { 572 | "name": "ipython", 573 | "version": 3 574 | }, 575 | "file_extension": ".py", 576 | "mimetype": "text/x-python", 577 | "name": "python", 578 | "nbconvert_exporter": "python", 579 | "pygments_lexer": "ipython3", 580 | "version": "3.6.3" 581 | } 582 | }, 583 | "nbformat": 4, 584 | "nbformat_minor": 2 585 | } 586 | -------------------------------------------------------------------------------- /PyTorch/img/auto.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/init27/DL-Toolkit/b0c9aca8bbde104e109ed8fc5bf80a7ca235dda8/PyTorch/img/auto.png -------------------------------------------------------------------------------- /PyTorch/img/lr.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/init27/DL-Toolkit/b0c9aca8bbde104e109ed8fc5bf80a7ca235dda8/PyTorch/img/lr.jpg -------------------------------------------------------------------------------- /PyTorch/linear_regression_torch_cpu.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | from torch.autograd import Variable 4 | import numpy as np 5 | import matplotlib.pyplot as plt 6 | 7 | np.random.seed(42) 8 | pts = 50 9 | 10 | x_vals = np.random.rand(50) 11 | x_train = np.asarray(x_vals,dtype=np.float32).reshape(-1,1) 12 | m = 1 13 | alpha = np.random.rand(1) 14 | beta = np.random.rand(1) 15 | y_correct = np.asarray([2*i+m for i in x_vals], dtype=np.float32).reshape(-1,1) 16 | 17 | # be sure with the dtypes as torch is highly sensitive to it 18 | # adding anotheer dimension to our variables with np.reshape(-1,1) i.e matrix like structure 19 | 20 | 21 | ''' 22 | Always we need to do the following things-: 23 | 1. Create a class (nearly always in Torch) 24 | 2. Write your forward 25 | 3. Decide the epochs, i/p, o/p, loss etc..LinearRegressionModel 26 | Its not always so easy.... 27 | ''' 28 | class LinearRegressionModel(nn.Module): 29 | 30 | def __init__(self, input_dim, output_dim): 31 | 32 | super(LinearRegressionModel, self).__init__() # its just like c++ super in inheritance bringing imp things to out class 33 | self.linear = nn.Linear(input_dim, output_dim) # nn.linear is defined in nn.Module 34 | 35 | def forward(self, x):# here its simple as we want our model to predict the output as what it thinks is correct 36 | 37 | out = self.linear(x) 38 | return out 39 | 40 | input_dim = 1 41 | output_dim = 1 42 | 43 | model = LinearRegressionModel(input_dim,output_dim)# create our model just as we do in Scikit-Learn / C / C++// 44 | 45 | criterion = nn.MSELoss()# Mean Squared Loss 46 | l_rate = 0.01 47 | optimiser = torch.optim.SGD(model.parameters(), lr = l_rate) #Stochastic Gradient Descent 48 | 49 | epochs = 2000 50 | 51 | for epoch in range(epochs): 52 | 53 | epoch +=1 54 | inputs = Variable(torch.from_numpy(x_train)) 55 | labels = Variable(torch.from_numpy(y_correct)) 56 | 57 | #clear grads 58 | optimiser.zero_grad() 59 | #forward to get predicted values 60 | outputs = model.forward(inputs) 61 | loss = criterion(outputs, labels) 62 | loss.backward()# back props 63 | optimiser.step()# update the parameters 64 | print('epoch {}, loss {}'.format(epoch,loss.data[0])) 65 | 66 | 67 | predicted = model.forward(Variable(torch.from_numpy(x_train))).data.numpy() 68 | 69 | plt.plot(x_train, y_correct, 'go', label = 'from data', alpha = .5) 70 | plt.plot(x_train, predicted, label = 'prediction', alpha = 0.5) 71 | plt.legend() 72 | plt.show() 73 | print(model.state_dict()) 74 | ''' this will show 75 | OrderedDict([('linear.weight', 76 | 1.9832 77 | [torch.FloatTensor of size 1x1] 78 | ), ('linear.bias', 79 | 1.0080 80 | [torch.FloatTensor of size 1] 81 | )]) 82 | ''' 83 | -------------------------------------------------------------------------------- /Python /NumPy.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Note: This nb is meant to be semi-self introductory. Some parts that are vague have to be experimented and found out by the user. Feel free to use this notebook as you wish too.\n", 8 | "\n", 9 | "This provides a brief introduction to Numpy. Futher exploration is up to you " 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": { 15 | "collapsed": true 16 | }, 17 | "source": [ 18 | "Import Numpy" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": 1, 24 | "metadata": { 25 | "collapsed": true 26 | }, 27 | "outputs": [], 28 | "source": [ 29 | "import numpy as np" 30 | ] 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "metadata": { 35 | "collapsed": true 36 | }, 37 | "source": [ 38 | "Creating Lists" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 2, 44 | "metadata": {}, 45 | "outputs": [ 46 | { 47 | "data": { 48 | "text/plain": [ 49 | "[1, 2, 3]" 50 | ] 51 | }, 52 | "execution_count": 2, 53 | "metadata": {}, 54 | "output_type": "execute_result" 55 | } 56 | ], 57 | "source": [ 58 | "my_list = [1,2,3]\n", 59 | "my_list" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": { 65 | "collapsed": true 66 | }, 67 | "source": [ 68 | "Convert List to Array" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 3, 74 | "metadata": {}, 75 | "outputs": [ 76 | { 77 | "data": { 78 | "text/plain": [ 79 | "array([1, 2, 3])" 80 | ] 81 | }, 82 | "execution_count": 3, 83 | "metadata": {}, 84 | "output_type": "execute_result" 85 | } 86 | ], 87 | "source": [ 88 | "np.array(my_list)" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": { 94 | "collapsed": true 95 | }, 96 | "source": [ 97 | "Creating multi dimensional vectors" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": 4, 103 | "metadata": {}, 104 | "outputs": [ 105 | { 106 | "data": { 107 | "text/plain": [ 108 | "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]" 109 | ] 110 | }, 111 | "execution_count": 4, 112 | "metadata": {}, 113 | "output_type": "execute_result" 114 | } 115 | ], 116 | "source": [ 117 | "my_matrix = [[1,2,3],[4,5,6],[7,8,9]]\n", 118 | "my_matrix" 119 | ] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "metadata": { 124 | "collapsed": true 125 | }, 126 | "source": [ 127 | "Converting my_matrix to Numpy Array" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": 5, 133 | "metadata": {}, 134 | "outputs": [ 135 | { 136 | "data": { 137 | "text/plain": [ 138 | "array([[1, 2, 3],\n", 139 | " [4, 5, 6],\n", 140 | " [7, 8, 9]])" 141 | ] 142 | }, 143 | "execution_count": 5, 144 | "metadata": {}, 145 | "output_type": "execute_result" 146 | } 147 | ], 148 | "source": [ 149 | "np.array(my_matrix)" 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": { 155 | "collapsed": true 156 | }, 157 | "source": [ 158 | "Arange is used to generate numbers between the range specified\n", 159 | "Mind the single r" 160 | ] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "execution_count": 6, 165 | "metadata": {}, 166 | "outputs": [ 167 | { 168 | "data": { 169 | "text/plain": [ 170 | "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" 171 | ] 172 | }, 173 | "execution_count": 6, 174 | "metadata": {}, 175 | "output_type": "execute_result" 176 | } 177 | ], 178 | "source": [ 179 | "np.arange(0,10)" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": { 185 | "collapsed": true 186 | }, 187 | "source": [ 188 | "Another varient with the step size mentioned" 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": 7, 194 | "metadata": {}, 195 | "outputs": [ 196 | { 197 | "data": { 198 | "text/plain": [ 199 | "array([ 0, 2, 4, 6, 8, 10])" 200 | ] 201 | }, 202 | "execution_count": 7, 203 | "metadata": {}, 204 | "output_type": "execute_result" 205 | } 206 | ], 207 | "source": [ 208 | "np.arange(0,11,2)" 209 | ] 210 | }, 211 | { 212 | "cell_type": "markdown", 213 | "metadata": { 214 | "collapsed": true 215 | }, 216 | "source": [ 217 | "Zeroes is used to create an array with 0 as values" 218 | ] 219 | }, 220 | { 221 | "cell_type": "code", 222 | "execution_count": 8, 223 | "metadata": {}, 224 | "outputs": [ 225 | { 226 | "data": { 227 | "text/plain": [ 228 | "array([ 0., 0., 0.])" 229 | ] 230 | }, 231 | "execution_count": 8, 232 | "metadata": {}, 233 | "output_type": "execute_result" 234 | } 235 | ], 236 | "source": [ 237 | "np.zeros(3)" 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "metadata": { 243 | "collapsed": true 244 | }, 245 | "source": [ 246 | "Multi-dimensional" 247 | ] 248 | }, 249 | { 250 | "cell_type": "code", 251 | "execution_count": 9, 252 | "metadata": {}, 253 | "outputs": [ 254 | { 255 | "data": { 256 | "text/plain": [ 257 | "array([[ 0., 0., 0., 0., 0.],\n", 258 | " [ 0., 0., 0., 0., 0.],\n", 259 | " [ 0., 0., 0., 0., 0.],\n", 260 | " [ 0., 0., 0., 0., 0.],\n", 261 | " [ 0., 0., 0., 0., 0.]])" 262 | ] 263 | }, 264 | "execution_count": 9, 265 | "metadata": {}, 266 | "output_type": "execute_result" 267 | } 268 | ], 269 | "source": [ 270 | "np.zeros((5,5))" 271 | ] 272 | }, 273 | { 274 | "cell_type": "markdown", 275 | "metadata": { 276 | "collapsed": true 277 | }, 278 | "source": [ 279 | "np.ones() is used to create an array with all values set to 1." 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": 10, 285 | "metadata": {}, 286 | "outputs": [ 287 | { 288 | "data": { 289 | "text/plain": [ 290 | "array([ 1., 1., 1.])" 291 | ] 292 | }, 293 | "execution_count": 10, 294 | "metadata": {}, 295 | "output_type": "execute_result" 296 | } 297 | ], 298 | "source": [ 299 | "np.ones(3)" 300 | ] 301 | }, 302 | { 303 | "cell_type": "markdown", 304 | "metadata": { 305 | "collapsed": true 306 | }, 307 | "source": [ 308 | "Multi Dimensional Example" 309 | ] 310 | }, 311 | { 312 | "cell_type": "code", 313 | "execution_count": 11, 314 | "metadata": {}, 315 | "outputs": [ 316 | { 317 | "data": { 318 | "text/plain": [ 319 | "array([[ 1., 1., 1.],\n", 320 | " [ 1., 1., 1.],\n", 321 | " [ 1., 1., 1.]])" 322 | ] 323 | }, 324 | "execution_count": 11, 325 | "metadata": {}, 326 | "output_type": "execute_result" 327 | } 328 | ], 329 | "source": [ 330 | "np.ones((3,3))" 331 | ] 332 | }, 333 | { 334 | "cell_type": "markdown", 335 | "metadata": { 336 | "collapsed": true 337 | }, 338 | "source": [ 339 | "np.linspace() is used to create a linearly spaced array" 340 | ] 341 | }, 342 | { 343 | "cell_type": "code", 344 | "execution_count": 12, 345 | "metadata": {}, 346 | "outputs": [ 347 | { 348 | "data": { 349 | "text/plain": [ 350 | "array([ 0., 5., 10.])" 351 | ] 352 | }, 353 | "execution_count": 12, 354 | "metadata": {}, 355 | "output_type": "execute_result" 356 | } 357 | ], 358 | "source": [ 359 | "np.linspace(0,10,3)" 360 | ] 361 | }, 362 | { 363 | "cell_type": "markdown", 364 | "metadata": { 365 | "collapsed": true 366 | }, 367 | "source": [ 368 | "Multi Dimensional example" 369 | ] 370 | }, 371 | { 372 | "cell_type": "code", 373 | "execution_count": 13, 374 | "metadata": {}, 375 | "outputs": [ 376 | { 377 | "data": { 378 | "text/plain": [ 379 | "array([ 0. , 0.20408163, 0.40816327, 0.6122449 ,\n", 380 | " 0.81632653, 1.02040816, 1.2244898 , 1.42857143,\n", 381 | " 1.63265306, 1.83673469, 2.04081633, 2.24489796,\n", 382 | " 2.44897959, 2.65306122, 2.85714286, 3.06122449,\n", 383 | " 3.26530612, 3.46938776, 3.67346939, 3.87755102,\n", 384 | " 4.08163265, 4.28571429, 4.48979592, 4.69387755,\n", 385 | " 4.89795918, 5.10204082, 5.30612245, 5.51020408,\n", 386 | " 5.71428571, 5.91836735, 6.12244898, 6.32653061,\n", 387 | " 6.53061224, 6.73469388, 6.93877551, 7.14285714,\n", 388 | " 7.34693878, 7.55102041, 7.75510204, 7.95918367,\n", 389 | " 8.16326531, 8.36734694, 8.57142857, 8.7755102 ,\n", 390 | " 8.97959184, 9.18367347, 9.3877551 , 9.59183673,\n", 391 | " 9.79591837, 10. ])" 392 | ] 393 | }, 394 | "execution_count": 13, 395 | "metadata": {}, 396 | "output_type": "execute_result" 397 | } 398 | ], 399 | "source": [ 400 | "np.linspace(0,10,50)" 401 | ] 402 | }, 403 | { 404 | "cell_type": "code", 405 | "execution_count": 14, 406 | "metadata": {}, 407 | "outputs": [ 408 | { 409 | "data": { 410 | "text/plain": [ 411 | "array([[ 1., 0., 0., 0.],\n", 412 | " [ 0., 1., 0., 0.],\n", 413 | " [ 0., 0., 1., 0.],\n", 414 | " [ 0., 0., 0., 1.]])" 415 | ] 416 | }, 417 | "execution_count": 14, 418 | "metadata": {}, 419 | "output_type": "execute_result" 420 | } 421 | ], 422 | "source": [ 423 | "np.eye(4)" 424 | ] 425 | }, 426 | { 427 | "cell_type": "markdown", 428 | "metadata": { 429 | "collapsed": true 430 | }, 431 | "source": [ 432 | "np.random.rand() is used to create random numbered arrays (range from 0-1)" 433 | ] 434 | }, 435 | { 436 | "cell_type": "code", 437 | "execution_count": 15, 438 | "metadata": {}, 439 | "outputs": [ 440 | { 441 | "data": { 442 | "text/plain": [ 443 | "array([ 0.40488309, 0.46652931])" 444 | ] 445 | }, 446 | "execution_count": 15, 447 | "metadata": {}, 448 | "output_type": "execute_result" 449 | } 450 | ], 451 | "source": [ 452 | "np.random.rand(2)" 453 | ] 454 | }, 455 | { 456 | "cell_type": "markdown", 457 | "metadata": { 458 | "collapsed": true 459 | }, 460 | "source": [ 461 | "Multi Dimensional example" 462 | ] 463 | }, 464 | { 465 | "cell_type": "code", 466 | "execution_count": 16, 467 | "metadata": {}, 468 | "outputs": [ 469 | { 470 | "data": { 471 | "text/plain": [ 472 | "array([[ 0.14446842, 0.96479017, 0.37574907, 0.45794865, 0.22639021],\n", 473 | " [ 0.93842155, 0.4054823 , 0.7991733 , 0.08122208, 0.17594805],\n", 474 | " [ 0.04356338, 0.08401733, 0.39358461, 0.0186519 , 0.49576109],\n", 475 | " [ 0.74018895, 0.02937591, 0.32805022, 0.38031188, 0.77648835],\n", 476 | " [ 0.10627713, 0.64205336, 0.7522886 , 0.11934037, 0.12499006]])" 477 | ] 478 | }, 479 | "execution_count": 16, 480 | "metadata": {}, 481 | "output_type": "execute_result" 482 | } 483 | ], 484 | "source": [ 485 | "np.random.rand(5,5)" 486 | ] 487 | }, 488 | { 489 | "cell_type": "markdown", 490 | "metadata": { 491 | "collapsed": true 492 | }, 493 | "source": [ 494 | "np.random.randn()\n", 495 | "Press Shift+tab to find the difference between rand() and randn()" 496 | ] 497 | }, 498 | { 499 | "cell_type": "code", 500 | "execution_count": 17, 501 | "metadata": {}, 502 | "outputs": [ 503 | { 504 | "data": { 505 | "text/plain": [ 506 | "array([ 1.10340351, -0.16465589])" 507 | ] 508 | }, 509 | "execution_count": 17, 510 | "metadata": {}, 511 | "output_type": "execute_result" 512 | } 513 | ], 514 | "source": [ 515 | "np.random.randn(2)" 516 | ] 517 | }, 518 | { 519 | "cell_type": "code", 520 | "execution_count": 18, 521 | "metadata": {}, 522 | "outputs": [ 523 | { 524 | "data": { 525 | "text/plain": [ 526 | "array([[ 0.14118108, -0.56135566, -0.55668215, -1.16960699, 0.18560352],\n", 527 | " [ 1.66672119, 0.07890495, -1.88615004, 2.02244644, 0.03415107],\n", 528 | " [ 0.75191351, -0.89115214, 0.68166528, -0.39473809, -1.45124926],\n", 529 | " [ 0.85715811, -2.87886074, -1.04106559, -0.56522974, -2.42867442],\n", 530 | " [ 1.90411863, -2.18647618, -0.47940531, 1.51818957, 0.37458558]])" 531 | ] 532 | }, 533 | "execution_count": 18, 534 | "metadata": {}, 535 | "output_type": "execute_result" 536 | } 537 | ], 538 | "source": [ 539 | "np.random.randn(5,5)" 540 | ] 541 | }, 542 | { 543 | "cell_type": "markdown", 544 | "metadata": { 545 | "collapsed": true 546 | }, 547 | "source": [ 548 | "randint() returns a random integer from the range specified" 549 | ] 550 | }, 551 | { 552 | "cell_type": "code", 553 | "execution_count": 19, 554 | "metadata": {}, 555 | "outputs": [ 556 | { 557 | "data": { 558 | "text/plain": [ 559 | "80" 560 | ] 561 | }, 562 | "execution_count": 19, 563 | "metadata": {}, 564 | "output_type": "execute_result" 565 | } 566 | ], 567 | "source": [ 568 | "np.random.randint(1,100)" 569 | ] 570 | }, 571 | { 572 | "cell_type": "markdown", 573 | "metadata": { 574 | "collapsed": true 575 | }, 576 | "source": [ 577 | "To return more than one integeres" 578 | ] 579 | }, 580 | { 581 | "cell_type": "code", 582 | "execution_count": 20, 583 | "metadata": {}, 584 | "outputs": [ 585 | { 586 | "data": { 587 | "text/plain": [ 588 | "array([11, 99, 82, 71, 50, 51, 24, 33, 47, 1])" 589 | ] 590 | }, 591 | "execution_count": 20, 592 | "metadata": {}, 593 | "output_type": "execute_result" 594 | } 595 | ], 596 | "source": [ 597 | "np.random.randint(1,100,10)" 598 | ] 599 | }, 600 | { 601 | "cell_type": "code", 602 | "execution_count": 21, 603 | "metadata": { 604 | "collapsed": true 605 | }, 606 | "outputs": [], 607 | "source": [ 608 | "arr = np.arange(25)\n", 609 | "ranarr = np.random.randint(0,50,10)" 610 | ] 611 | }, 612 | { 613 | "cell_type": "code", 614 | "execution_count": 22, 615 | "metadata": {}, 616 | "outputs": [ 617 | { 618 | "data": { 619 | "text/plain": [ 620 | "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", 621 | " 17, 18, 19, 20, 21, 22, 23, 24])" 622 | ] 623 | }, 624 | "execution_count": 22, 625 | "metadata": {}, 626 | "output_type": "execute_result" 627 | } 628 | ], 629 | "source": [ 630 | "arr" 631 | ] 632 | }, 633 | { 634 | "cell_type": "code", 635 | "execution_count": 23, 636 | "metadata": {}, 637 | "outputs": [ 638 | { 639 | "data": { 640 | "text/plain": [ 641 | "array([32, 36, 5, 3, 26, 35, 46, 8, 40, 12])" 642 | ] 643 | }, 644 | "execution_count": 23, 645 | "metadata": {}, 646 | "output_type": "execute_result" 647 | } 648 | ], 649 | "source": [ 650 | "ranarr" 651 | ] 652 | }, 653 | { 654 | "cell_type": "markdown", 655 | "metadata": { 656 | "collapsed": true 657 | }, 658 | "source": [ 659 | "reshape() is used to reshape() the array into the desired shape" 660 | ] 661 | }, 662 | { 663 | "cell_type": "code", 664 | "execution_count": 24, 665 | "metadata": {}, 666 | "outputs": [ 667 | { 668 | "data": { 669 | "text/plain": [ 670 | "array([[ 0, 1, 2, 3, 4],\n", 671 | " [ 5, 6, 7, 8, 9],\n", 672 | " [10, 11, 12, 13, 14],\n", 673 | " [15, 16, 17, 18, 19],\n", 674 | " [20, 21, 22, 23, 24]])" 675 | ] 676 | }, 677 | "execution_count": 24, 678 | "metadata": {}, 679 | "output_type": "execute_result" 680 | } 681 | ], 682 | "source": [ 683 | "arr.reshape(5,5)" 684 | ] 685 | }, 686 | { 687 | "cell_type": "code", 688 | "execution_count": 25, 689 | "metadata": {}, 690 | "outputs": [ 691 | { 692 | "data": { 693 | "text/plain": [ 694 | "array([32, 36, 5, 3, 26, 35, 46, 8, 40, 12])" 695 | ] 696 | }, 697 | "execution_count": 25, 698 | "metadata": {}, 699 | "output_type": "execute_result" 700 | } 701 | ], 702 | "source": [ 703 | "ranarr" 704 | ] 705 | }, 706 | { 707 | "cell_type": "code", 708 | "execution_count": 26, 709 | "metadata": {}, 710 | "outputs": [ 711 | { 712 | "data": { 713 | "text/plain": [ 714 | "46" 715 | ] 716 | }, 717 | "execution_count": 26, 718 | "metadata": {}, 719 | "output_type": "execute_result" 720 | } 721 | ], 722 | "source": [ 723 | "ranarr.max()" 724 | ] 725 | }, 726 | { 727 | "cell_type": "markdown", 728 | "metadata": { 729 | "collapsed": true 730 | }, 731 | "source": [ 732 | "max() and argmax() return the maximum value and it's index" 733 | ] 734 | }, 735 | { 736 | "cell_type": "code", 737 | "execution_count": 27, 738 | "metadata": {}, 739 | "outputs": [ 740 | { 741 | "data": { 742 | "text/plain": [ 743 | "6" 744 | ] 745 | }, 746 | "execution_count": 27, 747 | "metadata": {}, 748 | "output_type": "execute_result" 749 | } 750 | ], 751 | "source": [ 752 | "ranarr.argmax()" 753 | ] 754 | }, 755 | { 756 | "cell_type": "markdown", 757 | "metadata": { 758 | "collapsed": true 759 | }, 760 | "source": [ 761 | "min() is used to return the minimum value" 762 | ] 763 | }, 764 | { 765 | "cell_type": "code", 766 | "execution_count": 28, 767 | "metadata": {}, 768 | "outputs": [ 769 | { 770 | "data": { 771 | "text/plain": [ 772 | "3" 773 | ] 774 | }, 775 | "execution_count": 28, 776 | "metadata": {}, 777 | "output_type": "execute_result" 778 | } 779 | ], 780 | "source": [ 781 | "ranarr.min()" 782 | ] 783 | }, 784 | { 785 | "cell_type": "code", 786 | "execution_count": 29, 787 | "metadata": {}, 788 | "outputs": [ 789 | { 790 | "data": { 791 | "text/plain": [ 792 | "3" 793 | ] 794 | }, 795 | "execution_count": 29, 796 | "metadata": {}, 797 | "output_type": "execute_result" 798 | } 799 | ], 800 | "source": [ 801 | "ranarr.argmin()" 802 | ] 803 | }, 804 | { 805 | "cell_type": "markdown", 806 | "metadata": { 807 | "collapsed": true 808 | }, 809 | "source": [ 810 | ".shape is an attribute of Numpy Objects that is used to display the shape of the object." 811 | ] 812 | }, 813 | { 814 | "cell_type": "code", 815 | "execution_count": 30, 816 | "metadata": {}, 817 | "outputs": [ 818 | { 819 | "data": { 820 | "text/plain": [ 821 | "(25,)" 822 | ] 823 | }, 824 | "execution_count": 30, 825 | "metadata": {}, 826 | "output_type": "execute_result" 827 | } 828 | ], 829 | "source": [ 830 | "# Vector\n", 831 | "arr.shape" 832 | ] 833 | }, 834 | { 835 | "cell_type": "code", 836 | "execution_count": 31, 837 | "metadata": {}, 838 | "outputs": [ 839 | { 840 | "data": { 841 | "text/plain": [ 842 | "array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", 843 | " 17, 18, 19, 20, 21, 22, 23, 24]])" 844 | ] 845 | }, 846 | "execution_count": 31, 847 | "metadata": {}, 848 | "output_type": "execute_result" 849 | } 850 | ], 851 | "source": [ 852 | "# Notice the two sets of brackets\n", 853 | "arr.reshape(1,25)" 854 | ] 855 | }, 856 | { 857 | "cell_type": "code", 858 | "execution_count": 32, 859 | "metadata": {}, 860 | "outputs": [ 861 | { 862 | "data": { 863 | "text/plain": [ 864 | "(1, 25)" 865 | ] 866 | }, 867 | "execution_count": 32, 868 | "metadata": {}, 869 | "output_type": "execute_result" 870 | } 871 | ], 872 | "source": [ 873 | "arr.reshape(1,25).shape" 874 | ] 875 | }, 876 | { 877 | "cell_type": "code", 878 | "execution_count": 33, 879 | "metadata": {}, 880 | "outputs": [ 881 | { 882 | "data": { 883 | "text/plain": [ 884 | "array([[ 0],\n", 885 | " [ 1],\n", 886 | " [ 2],\n", 887 | " [ 3],\n", 888 | " [ 4],\n", 889 | " [ 5],\n", 890 | " [ 6],\n", 891 | " [ 7],\n", 892 | " [ 8],\n", 893 | " [ 9],\n", 894 | " [10],\n", 895 | " [11],\n", 896 | " [12],\n", 897 | " [13],\n", 898 | " [14],\n", 899 | " [15],\n", 900 | " [16],\n", 901 | " [17],\n", 902 | " [18],\n", 903 | " [19],\n", 904 | " [20],\n", 905 | " [21],\n", 906 | " [22],\n", 907 | " [23],\n", 908 | " [24]])" 909 | ] 910 | }, 911 | "execution_count": 33, 912 | "metadata": {}, 913 | "output_type": "execute_result" 914 | } 915 | ], 916 | "source": [ 917 | "arr.reshape(25,1)" 918 | ] 919 | }, 920 | { 921 | "cell_type": "code", 922 | "execution_count": 34, 923 | "metadata": {}, 924 | "outputs": [ 925 | { 926 | "data": { 927 | "text/plain": [ 928 | "(25, 1)" 929 | ] 930 | }, 931 | "execution_count": 34, 932 | "metadata": {}, 933 | "output_type": "execute_result" 934 | } 935 | ], 936 | "source": [ 937 | "arr.reshape(25,1).shape" 938 | ] 939 | }, 940 | { 941 | "cell_type": "markdown", 942 | "metadata": { 943 | "collapsed": true 944 | }, 945 | "source": [ 946 | "You can check the type by checking the .dtype attribute" 947 | ] 948 | }, 949 | { 950 | "cell_type": "code", 951 | "execution_count": 35, 952 | "metadata": {}, 953 | "outputs": [ 954 | { 955 | "data": { 956 | "text/plain": [ 957 | "dtype('int64')" 958 | ] 959 | }, 960 | "execution_count": 35, 961 | "metadata": {}, 962 | "output_type": "execute_result" 963 | } 964 | ], 965 | "source": [ 966 | "arr.dtype" 967 | ] 968 | }, 969 | { 970 | "cell_type": "code", 971 | "execution_count": 36, 972 | "metadata": { 973 | "collapsed": true 974 | }, 975 | "outputs": [], 976 | "source": [ 977 | "#Creating sample array\n", 978 | "arr = np.arange(0,11)" 979 | ] 980 | }, 981 | { 982 | "cell_type": "code", 983 | "execution_count": 37, 984 | "metadata": {}, 985 | "outputs": [ 986 | { 987 | "data": { 988 | "text/plain": [ 989 | "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])" 990 | ] 991 | }, 992 | "execution_count": 37, 993 | "metadata": {}, 994 | "output_type": "execute_result" 995 | } 996 | ], 997 | "source": [ 998 | "arr" 999 | ] 1000 | }, 1001 | { 1002 | "cell_type": "markdown", 1003 | "metadata": { 1004 | "collapsed": true 1005 | }, 1006 | "source": [ 1007 | "Accessing index values" 1008 | ] 1009 | }, 1010 | { 1011 | "cell_type": "code", 1012 | "execution_count": 38, 1013 | "metadata": {}, 1014 | "outputs": [ 1015 | { 1016 | "data": { 1017 | "text/plain": [ 1018 | "8" 1019 | ] 1020 | }, 1021 | "execution_count": 38, 1022 | "metadata": {}, 1023 | "output_type": "execute_result" 1024 | } 1025 | ], 1026 | "source": [ 1027 | "#Get a value at an index\n", 1028 | "arr[8]" 1029 | ] 1030 | }, 1031 | { 1032 | "cell_type": "markdown", 1033 | "metadata": { 1034 | "collapsed": true 1035 | }, 1036 | "source": [ 1037 | "Slicing. starting pos:Finalpos-1" 1038 | ] 1039 | }, 1040 | { 1041 | "cell_type": "code", 1042 | "execution_count": 39, 1043 | "metadata": {}, 1044 | "outputs": [ 1045 | { 1046 | "data": { 1047 | "text/plain": [ 1048 | "array([1, 2, 3, 4])" 1049 | ] 1050 | }, 1051 | "execution_count": 39, 1052 | "metadata": {}, 1053 | "output_type": "execute_result" 1054 | } 1055 | ], 1056 | "source": [ 1057 | "#Get values in a range\n", 1058 | "arr[1:5]" 1059 | ] 1060 | }, 1061 | { 1062 | "cell_type": "code", 1063 | "execution_count": 40, 1064 | "metadata": {}, 1065 | "outputs": [ 1066 | { 1067 | "data": { 1068 | "text/plain": [ 1069 | "array([0, 1, 2, 3, 4])" 1070 | ] 1071 | }, 1072 | "execution_count": 40, 1073 | "metadata": {}, 1074 | "output_type": "execute_result" 1075 | } 1076 | ], 1077 | "source": [ 1078 | "#Get values in a range\n", 1079 | "arr[0:5]" 1080 | ] 1081 | }, 1082 | { 1083 | "cell_type": "code", 1084 | "execution_count": 41, 1085 | "metadata": {}, 1086 | "outputs": [ 1087 | { 1088 | "data": { 1089 | "text/plain": [ 1090 | "array([100, 100, 100, 100, 100, 5, 6, 7, 8, 9, 10])" 1091 | ] 1092 | }, 1093 | "execution_count": 41, 1094 | "metadata": {}, 1095 | "output_type": "execute_result" 1096 | } 1097 | ], 1098 | "source": [ 1099 | "#Setting a value with index range (Broadcasting)\n", 1100 | "arr[0:5]=100\n", 1101 | "\n", 1102 | "#Show\n", 1103 | "arr" 1104 | ] 1105 | }, 1106 | { 1107 | "cell_type": "code", 1108 | "execution_count": 42, 1109 | "metadata": {}, 1110 | "outputs": [ 1111 | { 1112 | "data": { 1113 | "text/plain": [ 1114 | "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])" 1115 | ] 1116 | }, 1117 | "execution_count": 42, 1118 | "metadata": {}, 1119 | "output_type": "execute_result" 1120 | } 1121 | ], 1122 | "source": [ 1123 | "# Reset array, we'll see why I had to reset in a moment\n", 1124 | "arr = np.arange(0,11)\n", 1125 | "\n", 1126 | "#Show\n", 1127 | "arr" 1128 | ] 1129 | }, 1130 | { 1131 | "cell_type": "code", 1132 | "execution_count": 43, 1133 | "metadata": {}, 1134 | "outputs": [ 1135 | { 1136 | "data": { 1137 | "text/plain": [ 1138 | "array([0, 1, 2, 3, 4, 5])" 1139 | ] 1140 | }, 1141 | "execution_count": 43, 1142 | "metadata": {}, 1143 | "output_type": "execute_result" 1144 | } 1145 | ], 1146 | "source": [ 1147 | "#Important notes on Slices\n", 1148 | "slice_of_arr = arr[0:6]\n", 1149 | "\n", 1150 | "#Show slice\n", 1151 | "slice_of_arr" 1152 | ] 1153 | }, 1154 | { 1155 | "cell_type": "code", 1156 | "execution_count": 44, 1157 | "metadata": {}, 1158 | "outputs": [ 1159 | { 1160 | "data": { 1161 | "text/plain": [ 1162 | "array([99, 99, 99, 99, 99, 99])" 1163 | ] 1164 | }, 1165 | "execution_count": 44, 1166 | "metadata": {}, 1167 | "output_type": "execute_result" 1168 | } 1169 | ], 1170 | "source": [ 1171 | "#Change Slice\n", 1172 | "slice_of_arr[:]=99\n", 1173 | "\n", 1174 | "#Show Slice again\n", 1175 | "slice_of_arr" 1176 | ] 1177 | }, 1178 | { 1179 | "cell_type": "code", 1180 | "execution_count": 45, 1181 | "metadata": {}, 1182 | "outputs": [ 1183 | { 1184 | "data": { 1185 | "text/plain": [ 1186 | "array([99, 99, 99, 99, 99, 99, 6, 7, 8, 9, 10])" 1187 | ] 1188 | }, 1189 | "execution_count": 45, 1190 | "metadata": {}, 1191 | "output_type": "execute_result" 1192 | } 1193 | ], 1194 | "source": [ 1195 | "arr" 1196 | ] 1197 | }, 1198 | { 1199 | "cell_type": "code", 1200 | "execution_count": 46, 1201 | "metadata": {}, 1202 | "outputs": [ 1203 | { 1204 | "data": { 1205 | "text/plain": [ 1206 | "array([99, 99, 99, 99, 99, 99, 6, 7, 8, 9, 10])" 1207 | ] 1208 | }, 1209 | "execution_count": 46, 1210 | "metadata": {}, 1211 | "output_type": "execute_result" 1212 | } 1213 | ], 1214 | "source": [ 1215 | "#To get a copy, need to be explicit\n", 1216 | "arr_copy = arr.copy()\n", 1217 | "\n", 1218 | "arr_copy" 1219 | ] 1220 | }, 1221 | { 1222 | "cell_type": "code", 1223 | "execution_count": 47, 1224 | "metadata": {}, 1225 | "outputs": [ 1226 | { 1227 | "data": { 1228 | "text/plain": [ 1229 | "array([[ 5, 10, 15],\n", 1230 | " [20, 25, 30],\n", 1231 | " [35, 40, 45]])" 1232 | ] 1233 | }, 1234 | "execution_count": 47, 1235 | "metadata": {}, 1236 | "output_type": "execute_result" 1237 | } 1238 | ], 1239 | "source": [ 1240 | "arr_2d = np.array(([5,10,15],[20,25,30],[35,40,45]))\n", 1241 | "\n", 1242 | "#Show\n", 1243 | "arr_2d" 1244 | ] 1245 | }, 1246 | { 1247 | "cell_type": "code", 1248 | "execution_count": 48, 1249 | "metadata": {}, 1250 | "outputs": [ 1251 | { 1252 | "data": { 1253 | "text/plain": [ 1254 | "array([20, 25, 30])" 1255 | ] 1256 | }, 1257 | "execution_count": 48, 1258 | "metadata": {}, 1259 | "output_type": "execute_result" 1260 | } 1261 | ], 1262 | "source": [ 1263 | "#Indexing row\n", 1264 | "arr_2d[1]" 1265 | ] 1266 | }, 1267 | { 1268 | "cell_type": "code", 1269 | "execution_count": 49, 1270 | "metadata": {}, 1271 | "outputs": [ 1272 | { 1273 | "data": { 1274 | "text/plain": [ 1275 | "20" 1276 | ] 1277 | }, 1278 | "execution_count": 49, 1279 | "metadata": {}, 1280 | "output_type": "execute_result" 1281 | } 1282 | ], 1283 | "source": [ 1284 | "# Format is arr_2d[row][col] or arr_2d[row,col]\n", 1285 | "\n", 1286 | "# Getting individual element value\n", 1287 | "arr_2d[1][0]" 1288 | ] 1289 | }, 1290 | { 1291 | "cell_type": "code", 1292 | "execution_count": 50, 1293 | "metadata": {}, 1294 | "outputs": [ 1295 | { 1296 | "data": { 1297 | "text/plain": [ 1298 | "20" 1299 | ] 1300 | }, 1301 | "execution_count": 50, 1302 | "metadata": {}, 1303 | "output_type": "execute_result" 1304 | } 1305 | ], 1306 | "source": [ 1307 | "# Getting individual element value\n", 1308 | "arr_2d[1,0]" 1309 | ] 1310 | }, 1311 | { 1312 | "cell_type": "code", 1313 | "execution_count": 51, 1314 | "metadata": {}, 1315 | "outputs": [ 1316 | { 1317 | "data": { 1318 | "text/plain": [ 1319 | "array([[10, 15],\n", 1320 | " [25, 30]])" 1321 | ] 1322 | }, 1323 | "execution_count": 51, 1324 | "metadata": {}, 1325 | "output_type": "execute_result" 1326 | } 1327 | ], 1328 | "source": [ 1329 | "# 2D array slicing\n", 1330 | "\n", 1331 | "#Shape (2,2) from top right corner\n", 1332 | "arr_2d[:2,1:]" 1333 | ] 1334 | }, 1335 | { 1336 | "cell_type": "code", 1337 | "execution_count": 52, 1338 | "metadata": {}, 1339 | "outputs": [ 1340 | { 1341 | "data": { 1342 | "text/plain": [ 1343 | "array([35, 40, 45])" 1344 | ] 1345 | }, 1346 | "execution_count": 52, 1347 | "metadata": {}, 1348 | "output_type": "execute_result" 1349 | } 1350 | ], 1351 | "source": [ 1352 | "#Shape bottom row\n", 1353 | "arr_2d[2]" 1354 | ] 1355 | }, 1356 | { 1357 | "cell_type": "code", 1358 | "execution_count": 53, 1359 | "metadata": {}, 1360 | "outputs": [ 1361 | { 1362 | "data": { 1363 | "text/plain": [ 1364 | "array([35, 40, 45])" 1365 | ] 1366 | }, 1367 | "execution_count": 53, 1368 | "metadata": {}, 1369 | "output_type": "execute_result" 1370 | } 1371 | ], 1372 | "source": [ 1373 | "#Shape bottom row\n", 1374 | "arr_2d[2,:]" 1375 | ] 1376 | }, 1377 | { 1378 | "cell_type": "code", 1379 | "execution_count": 54, 1380 | "metadata": { 1381 | "collapsed": true 1382 | }, 1383 | "outputs": [], 1384 | "source": [ 1385 | "#Set up matrix\n", 1386 | "arr2d = np.zeros((10,10))" 1387 | ] 1388 | }, 1389 | { 1390 | "cell_type": "code", 1391 | "execution_count": 55, 1392 | "metadata": { 1393 | "collapsed": true 1394 | }, 1395 | "outputs": [], 1396 | "source": [ 1397 | "#Length of array\n", 1398 | "arr_length = arr2d.shape[1]" 1399 | ] 1400 | }, 1401 | { 1402 | "cell_type": "code", 1403 | "execution_count": 56, 1404 | "metadata": {}, 1405 | "outputs": [ 1406 | { 1407 | "data": { 1408 | "text/plain": [ 1409 | "array([[ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", 1410 | " [ 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n", 1411 | " [ 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n", 1412 | " [ 3., 3., 3., 3., 3., 3., 3., 3., 3., 3.],\n", 1413 | " [ 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.],\n", 1414 | " [ 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.],\n", 1415 | " [ 6., 6., 6., 6., 6., 6., 6., 6., 6., 6.],\n", 1416 | " [ 7., 7., 7., 7., 7., 7., 7., 7., 7., 7.],\n", 1417 | " [ 8., 8., 8., 8., 8., 8., 8., 8., 8., 8.],\n", 1418 | " [ 9., 9., 9., 9., 9., 9., 9., 9., 9., 9.]])" 1419 | ] 1420 | }, 1421 | "execution_count": 56, 1422 | "metadata": {}, 1423 | "output_type": "execute_result" 1424 | } 1425 | ], 1426 | "source": [ 1427 | "#Set up array\n", 1428 | "\n", 1429 | "for i in range(arr_length):\n", 1430 | " arr2d[i] = i\n", 1431 | " \n", 1432 | "arr2d" 1433 | ] 1434 | }, 1435 | { 1436 | "cell_type": "code", 1437 | "execution_count": 57, 1438 | "metadata": {}, 1439 | "outputs": [ 1440 | { 1441 | "data": { 1442 | "text/plain": [ 1443 | "array([[ 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n", 1444 | " [ 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.],\n", 1445 | " [ 6., 6., 6., 6., 6., 6., 6., 6., 6., 6.],\n", 1446 | " [ 8., 8., 8., 8., 8., 8., 8., 8., 8., 8.]])" 1447 | ] 1448 | }, 1449 | "execution_count": 57, 1450 | "metadata": {}, 1451 | "output_type": "execute_result" 1452 | } 1453 | ], 1454 | "source": [ 1455 | "arr2d[[2,4,6,8]]" 1456 | ] 1457 | }, 1458 | { 1459 | "cell_type": "code", 1460 | "execution_count": 58, 1461 | "metadata": {}, 1462 | "outputs": [ 1463 | { 1464 | "data": { 1465 | "text/plain": [ 1466 | "array([[ 6., 6., 6., 6., 6., 6., 6., 6., 6., 6.],\n", 1467 | " [ 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.],\n", 1468 | " [ 2., 2., 2., 2., 2., 2., 2., 2., 2., 2.],\n", 1469 | " [ 7., 7., 7., 7., 7., 7., 7., 7., 7., 7.]])" 1470 | ] 1471 | }, 1472 | "execution_count": 58, 1473 | "metadata": {}, 1474 | "output_type": "execute_result" 1475 | } 1476 | ], 1477 | "source": [ 1478 | "#Allows in any order\n", 1479 | "arr2d[[6,4,2,7]]" 1480 | ] 1481 | }, 1482 | { 1483 | "cell_type": "code", 1484 | "execution_count": 59, 1485 | "metadata": {}, 1486 | "outputs": [ 1487 | { 1488 | "data": { 1489 | "text/plain": [ 1490 | "array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])" 1491 | ] 1492 | }, 1493 | "execution_count": 59, 1494 | "metadata": {}, 1495 | "output_type": "execute_result" 1496 | } 1497 | ], 1498 | "source": [ 1499 | "arr = np.arange(1,11)\n", 1500 | "arr" 1501 | ] 1502 | }, 1503 | { 1504 | "cell_type": "code", 1505 | "execution_count": 60, 1506 | "metadata": {}, 1507 | "outputs": [ 1508 | { 1509 | "data": { 1510 | "text/plain": [ 1511 | "array([False, False, False, False, True, True, True, True, True, True], dtype=bool)" 1512 | ] 1513 | }, 1514 | "execution_count": 60, 1515 | "metadata": {}, 1516 | "output_type": "execute_result" 1517 | } 1518 | ], 1519 | "source": [ 1520 | "arr > 4" 1521 | ] 1522 | }, 1523 | { 1524 | "cell_type": "code", 1525 | "execution_count": 61, 1526 | "metadata": { 1527 | "collapsed": true 1528 | }, 1529 | "outputs": [], 1530 | "source": [ 1531 | "bool_arr = arr>4" 1532 | ] 1533 | }, 1534 | { 1535 | "cell_type": "code", 1536 | "execution_count": 62, 1537 | "metadata": {}, 1538 | "outputs": [ 1539 | { 1540 | "data": { 1541 | "text/plain": [ 1542 | "array([False, False, False, False, True, True, True, True, True, True], dtype=bool)" 1543 | ] 1544 | }, 1545 | "execution_count": 62, 1546 | "metadata": {}, 1547 | "output_type": "execute_result" 1548 | } 1549 | ], 1550 | "source": [ 1551 | "bool_arr" 1552 | ] 1553 | }, 1554 | { 1555 | "cell_type": "code", 1556 | "execution_count": 63, 1557 | "metadata": {}, 1558 | "outputs": [ 1559 | { 1560 | "data": { 1561 | "text/plain": [ 1562 | "array([ 5, 6, 7, 8, 9, 10])" 1563 | ] 1564 | }, 1565 | "execution_count": 63, 1566 | "metadata": {}, 1567 | "output_type": "execute_result" 1568 | } 1569 | ], 1570 | "source": [ 1571 | "arr[bool_arr]" 1572 | ] 1573 | }, 1574 | { 1575 | "cell_type": "code", 1576 | "execution_count": 64, 1577 | "metadata": {}, 1578 | "outputs": [ 1579 | { 1580 | "data": { 1581 | "text/plain": [ 1582 | "array([ 3, 4, 5, 6, 7, 8, 9, 10])" 1583 | ] 1584 | }, 1585 | "execution_count": 64, 1586 | "metadata": {}, 1587 | "output_type": "execute_result" 1588 | } 1589 | ], 1590 | "source": [ 1591 | "arr[arr>2]" 1592 | ] 1593 | }, 1594 | { 1595 | "cell_type": "code", 1596 | "execution_count": 65, 1597 | "metadata": {}, 1598 | "outputs": [ 1599 | { 1600 | "data": { 1601 | "text/plain": [ 1602 | "array([ 3, 4, 5, 6, 7, 8, 9, 10])" 1603 | ] 1604 | }, 1605 | "execution_count": 65, 1606 | "metadata": {}, 1607 | "output_type": "execute_result" 1608 | } 1609 | ], 1610 | "source": [ 1611 | "x = 2\n", 1612 | "arr[arr>x]" 1613 | ] 1614 | }, 1615 | { 1616 | "cell_type": "code", 1617 | "execution_count": 66, 1618 | "metadata": { 1619 | "collapsed": true 1620 | }, 1621 | "outputs": [], 1622 | "source": [ 1623 | "arr = np.arange(0,10)" 1624 | ] 1625 | }, 1626 | { 1627 | "cell_type": "code", 1628 | "execution_count": 67, 1629 | "metadata": {}, 1630 | "outputs": [ 1631 | { 1632 | "data": { 1633 | "text/plain": [ 1634 | "array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])" 1635 | ] 1636 | }, 1637 | "execution_count": 67, 1638 | "metadata": {}, 1639 | "output_type": "execute_result" 1640 | } 1641 | ], 1642 | "source": [ 1643 | "arr + arr" 1644 | ] 1645 | }, 1646 | { 1647 | "cell_type": "code", 1648 | "execution_count": 68, 1649 | "metadata": {}, 1650 | "outputs": [ 1651 | { 1652 | "data": { 1653 | "text/plain": [ 1654 | "array([ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81])" 1655 | ] 1656 | }, 1657 | "execution_count": 68, 1658 | "metadata": {}, 1659 | "output_type": "execute_result" 1660 | } 1661 | ], 1662 | "source": [ 1663 | "arr * arr" 1664 | ] 1665 | }, 1666 | { 1667 | "cell_type": "code", 1668 | "execution_count": 69, 1669 | "metadata": {}, 1670 | "outputs": [ 1671 | { 1672 | "data": { 1673 | "text/plain": [ 1674 | "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])" 1675 | ] 1676 | }, 1677 | "execution_count": 69, 1678 | "metadata": {}, 1679 | "output_type": "execute_result" 1680 | } 1681 | ], 1682 | "source": [ 1683 | "arr - arr" 1684 | ] 1685 | }, 1686 | { 1687 | "cell_type": "code", 1688 | "execution_count": 70, 1689 | "metadata": {}, 1690 | "outputs": [ 1691 | { 1692 | "name": "stderr", 1693 | "output_type": "stream", 1694 | "text": [ 1695 | "/Applications/anaconda/lib/python3.6/site-packages/ipykernel_launcher.py:3: RuntimeWarning: invalid value encountered in true_divide\n", 1696 | " This is separate from the ipykernel package so we can avoid doing imports until\n" 1697 | ] 1698 | }, 1699 | { 1700 | "data": { 1701 | "text/plain": [ 1702 | "array([ nan, 1., 1., 1., 1., 1., 1., 1., 1., 1.])" 1703 | ] 1704 | }, 1705 | "execution_count": 70, 1706 | "metadata": {}, 1707 | "output_type": "execute_result" 1708 | } 1709 | ], 1710 | "source": [ 1711 | "# Warning on division by zero, but not an error!\n", 1712 | "# Just replaced with nan\n", 1713 | "arr/arr" 1714 | ] 1715 | }, 1716 | { 1717 | "cell_type": "code", 1718 | "execution_count": 71, 1719 | "metadata": {}, 1720 | "outputs": [ 1721 | { 1722 | "name": "stderr", 1723 | "output_type": "stream", 1724 | "text": [ 1725 | "/Applications/anaconda/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in true_divide\n", 1726 | " \n" 1727 | ] 1728 | }, 1729 | { 1730 | "data": { 1731 | "text/plain": [ 1732 | "array([ inf, 1. , 0.5 , 0.33333333, 0.25 ,\n", 1733 | " 0.2 , 0.16666667, 0.14285714, 0.125 , 0.11111111])" 1734 | ] 1735 | }, 1736 | "execution_count": 71, 1737 | "metadata": {}, 1738 | "output_type": "execute_result" 1739 | } 1740 | ], 1741 | "source": [ 1742 | "# Also warning, but not an error instead infinity\n", 1743 | "1/arr" 1744 | ] 1745 | }, 1746 | { 1747 | "cell_type": "code", 1748 | "execution_count": 72, 1749 | "metadata": {}, 1750 | "outputs": [ 1751 | { 1752 | "data": { 1753 | "text/plain": [ 1754 | "array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])" 1755 | ] 1756 | }, 1757 | "execution_count": 72, 1758 | "metadata": {}, 1759 | "output_type": "execute_result" 1760 | } 1761 | ], 1762 | "source": [ 1763 | "arr**3" 1764 | ] 1765 | }, 1766 | { 1767 | "cell_type": "code", 1768 | "execution_count": 73, 1769 | "metadata": {}, 1770 | "outputs": [ 1771 | { 1772 | "data": { 1773 | "text/plain": [ 1774 | "array([ 0. , 1. , 1.41421356, 1.73205081, 2. ,\n", 1775 | " 2.23606798, 2.44948974, 2.64575131, 2.82842712, 3. ])" 1776 | ] 1777 | }, 1778 | "execution_count": 73, 1779 | "metadata": {}, 1780 | "output_type": "execute_result" 1781 | } 1782 | ], 1783 | "source": [ 1784 | "#Taking Square Roots\n", 1785 | "np.sqrt(arr)" 1786 | ] 1787 | }, 1788 | { 1789 | "cell_type": "code", 1790 | "execution_count": 74, 1791 | "metadata": {}, 1792 | "outputs": [ 1793 | { 1794 | "data": { 1795 | "text/plain": [ 1796 | "array([ 1.00000000e+00, 2.71828183e+00, 7.38905610e+00,\n", 1797 | " 2.00855369e+01, 5.45981500e+01, 1.48413159e+02,\n", 1798 | " 4.03428793e+02, 1.09663316e+03, 2.98095799e+03,\n", 1799 | " 8.10308393e+03])" 1800 | ] 1801 | }, 1802 | "execution_count": 74, 1803 | "metadata": {}, 1804 | "output_type": "execute_result" 1805 | } 1806 | ], 1807 | "source": [ 1808 | "#Calcualting exponential (e^)\n", 1809 | "np.exp(arr)" 1810 | ] 1811 | }, 1812 | { 1813 | "cell_type": "code", 1814 | "execution_count": 75, 1815 | "metadata": {}, 1816 | "outputs": [ 1817 | { 1818 | "data": { 1819 | "text/plain": [ 1820 | "9" 1821 | ] 1822 | }, 1823 | "execution_count": 75, 1824 | "metadata": {}, 1825 | "output_type": "execute_result" 1826 | } 1827 | ], 1828 | "source": [ 1829 | "np.max(arr) #same as arr.max()" 1830 | ] 1831 | }, 1832 | { 1833 | "cell_type": "code", 1834 | "execution_count": 76, 1835 | "metadata": {}, 1836 | "outputs": [ 1837 | { 1838 | "data": { 1839 | "text/plain": [ 1840 | "array([ 0. , 0.84147098, 0.90929743, 0.14112001, -0.7568025 ,\n", 1841 | " -0.95892427, -0.2794155 , 0.6569866 , 0.98935825, 0.41211849])" 1842 | ] 1843 | }, 1844 | "execution_count": 76, 1845 | "metadata": {}, 1846 | "output_type": "execute_result" 1847 | } 1848 | ], 1849 | "source": [ 1850 | "np.sin(arr)" 1851 | ] 1852 | }, 1853 | { 1854 | "cell_type": "code", 1855 | "execution_count": 77, 1856 | "metadata": {}, 1857 | "outputs": [ 1858 | { 1859 | "name": "stderr", 1860 | "output_type": "stream", 1861 | "text": [ 1862 | "/Applications/anaconda/lib/python3.6/site-packages/ipykernel_launcher.py:1: RuntimeWarning: divide by zero encountered in log\n", 1863 | " \"\"\"Entry point for launching an IPython kernel.\n" 1864 | ] 1865 | }, 1866 | { 1867 | "data": { 1868 | "text/plain": [ 1869 | "array([ -inf, 0. , 0.69314718, 1.09861229, 1.38629436,\n", 1870 | " 1.60943791, 1.79175947, 1.94591015, 2.07944154, 2.19722458])" 1871 | ] 1872 | }, 1873 | "execution_count": 77, 1874 | "metadata": {}, 1875 | "output_type": "execute_result" 1876 | } 1877 | ], 1878 | "source": [ 1879 | "np.log(arr)" 1880 | ] 1881 | } 1882 | ], 1883 | "metadata": { 1884 | "kernelspec": { 1885 | "display_name": "Python 3", 1886 | "language": "python", 1887 | "name": "python3" 1888 | }, 1889 | "language_info": { 1890 | "codemirror_mode": { 1891 | "name": "ipython", 1892 | "version": 3 1893 | }, 1894 | "file_extension": ".py", 1895 | "mimetype": "text/x-python", 1896 | "name": "python", 1897 | "nbconvert_exporter": "python", 1898 | "pygments_lexer": "ipython3", 1899 | "version": "3.6.1" 1900 | } 1901 | }, 1902 | "nbformat": 4, 1903 | "nbformat_minor": 1 1904 | } 1905 | -------------------------------------------------------------------------------- /Python /Python.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Python Basics" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Printing " 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 2, 20 | "metadata": {}, 21 | "outputs": [ 22 | { 23 | "name": "stdout", 24 | "output_type": "stream", 25 | "text": [ 26 | "5\n", 27 | "Hello World\n" 28 | ] 29 | } 30 | ], 31 | "source": [ 32 | "a = 5\n", 33 | "print(a)\n", 34 | "print('Hello World')" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "Defining a function" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 4, 47 | "metadata": {}, 48 | "outputs": [ 49 | { 50 | "data": { 51 | "text/plain": [ 52 | "3" 53 | ] 54 | }, 55 | "execution_count": 4, 56 | "metadata": {}, 57 | "output_type": "execute_result" 58 | } 59 | ], 60 | "source": [ 61 | "def add_numbers(a, b):\n", 62 | " return a + b\n", 63 | "sum = add_numbers(1,2)\n", 64 | "sum" 65 | ] 66 | }, 67 | { 68 | "cell_type": "markdown", 69 | "metadata": {}, 70 | "source": [ 71 | "Conditions" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": 8, 77 | "metadata": {}, 78 | "outputs": [ 79 | { 80 | "data": { 81 | "text/plain": [ 82 | "(5, 7)" 83 | ] 84 | }, 85 | "execution_count": 8, 86 | "metadata": {}, 87 | "output_type": "execute_result" 88 | } 89 | ], 90 | "source": [ 91 | "x = 5\n", 92 | "y = 7\n", 93 | "if x > 5:\n", 94 | " x += 1\n", 95 | "\n", 96 | " y = 8\n", 97 | "x,y" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "Indentation, not braces" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "Dynamic references, strong types" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": 13, 117 | "metadata": {}, 118 | "outputs": [ 119 | { 120 | "name": "stdout", 121 | "output_type": "stream", 122 | "text": [ 123 | "a is , b is \n" 124 | ] 125 | }, 126 | { 127 | "data": { 128 | "text/plain": [ 129 | "2.25" 130 | ] 131 | }, 132 | "execution_count": 13, 133 | "metadata": {}, 134 | "output_type": "execute_result" 135 | } 136 | ], 137 | "source": [ 138 | "a = 4.5\n", 139 | "b = 2\n", 140 | "print('a is {0}, b is {1}'.format(type(a), type(b)))\n", 141 | "a / b" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "metadata": {}, 147 | "source": [ 148 | "Strings" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": 15, 154 | "metadata": {}, 155 | "outputs": [ 156 | { 157 | "data": { 158 | "text/plain": [ 159 | "'this is a longer string'" 160 | ] 161 | }, 162 | "execution_count": 15, 163 | "metadata": {}, 164 | "output_type": "execute_result" 165 | } 166 | ], 167 | "source": [ 168 | "a = 'this is a string'\n", 169 | "b = a.replace('string', 'longer string')\n", 170 | "b" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "Loops" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": 17, 183 | "metadata": {}, 184 | "outputs": [ 185 | { 186 | "name": "stdout", 187 | "output_type": "stream", 188 | "text": [ 189 | "(0, 0)\n", 190 | "(1, 0)\n", 191 | "(1, 1)\n", 192 | "(2, 0)\n", 193 | "(2, 1)\n", 194 | "(2, 2)\n", 195 | "(3, 0)\n", 196 | "(3, 1)\n", 197 | "(3, 2)\n", 198 | "(3, 3)\n" 199 | ] 200 | } 201 | ], 202 | "source": [ 203 | "for i in range(4):\n", 204 | " for j in range(4):\n", 205 | " if j > i:\n", 206 | " break\n", 207 | " print((i, j))" 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": {}, 213 | "source": [ 214 | "Tuple" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": 18, 220 | "metadata": {}, 221 | "outputs": [ 222 | { 223 | "data": { 224 | "text/plain": [ 225 | "(4, 5, 6)" 226 | ] 227 | }, 228 | "execution_count": 18, 229 | "metadata": {}, 230 | "output_type": "execute_result" 231 | } 232 | ], 233 | "source": [ 234 | "tup = 4, 5, 6\n", 235 | "tup" 236 | ] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "List" 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": 19, 248 | "metadata": {}, 249 | "outputs": [ 250 | { 251 | "data": { 252 | "text/plain": [ 253 | "['foo', 'peekaboo', 'baz']" 254 | ] 255 | }, 256 | "execution_count": 19, 257 | "metadata": {}, 258 | "output_type": "execute_result" 259 | } 260 | ], 261 | "source": [ 262 | "a_list = [2, 3, 7, None]\n", 263 | "tup = ('foo', 'bar', 'baz')\n", 264 | "b_list = list(tup)\n", 265 | "b_list\n", 266 | "b_list[1] = 'peekaboo'\n", 267 | "b_list" 268 | ] 269 | }, 270 | { 271 | "cell_type": "markdown", 272 | "metadata": {}, 273 | "source": [ 274 | "Slicing" 275 | ] 276 | }, 277 | { 278 | "cell_type": "code", 279 | "execution_count": 20, 280 | "metadata": {}, 281 | "outputs": [ 282 | { 283 | "data": { 284 | "text/plain": [ 285 | "[2, 3, 7, 5]" 286 | ] 287 | }, 288 | "execution_count": 20, 289 | "metadata": {}, 290 | "output_type": "execute_result" 291 | } 292 | ], 293 | "source": [ 294 | "seq = [7, 2, 3, 7, 5, 6, 0, 1]\n", 295 | "seq[1:5]" 296 | ] 297 | }, 298 | { 299 | "cell_type": "markdown", 300 | "metadata": {}, 301 | "source": [ 302 | "Dictionary" 303 | ] 304 | }, 305 | { 306 | "cell_type": "code", 307 | "execution_count": 21, 308 | "metadata": {}, 309 | "outputs": [ 310 | { 311 | "data": { 312 | "text/plain": [ 313 | "{'a': 'some value', 'b': [1, 2, 3, 4]}" 314 | ] 315 | }, 316 | "execution_count": 21, 317 | "metadata": {}, 318 | "output_type": "execute_result" 319 | } 320 | ], 321 | "source": [ 322 | "empty_dict = {}\n", 323 | "d1 = {'a' : 'some value', 'b' : [1, 2, 3, 4]}\n", 324 | "d1" 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": 22, 330 | "metadata": {}, 331 | "outputs": [ 332 | { 333 | "data": { 334 | "text/plain": [ 335 | "{'a': 'some value', 'b': [1, 2, 3, 4]}" 336 | ] 337 | }, 338 | "execution_count": 22, 339 | "metadata": {}, 340 | "output_type": "execute_result" 341 | } 342 | ], 343 | "source": [ 344 | "d1[5] = 'some value'\n", 345 | "d1\n", 346 | "d1['dummy'] = 'another value'\n", 347 | "d1\n", 348 | "del d1[5]\n", 349 | "d1\n", 350 | "ret = d1.pop('dummy')\n", 351 | "ret\n", 352 | "d1" 353 | ] 354 | }, 355 | { 356 | "cell_type": "code", 357 | "execution_count": 23, 358 | "metadata": {}, 359 | "outputs": [ 360 | { 361 | "data": { 362 | "text/plain": [ 363 | "{'a': 'some value', 'b': 'foo', 'c': 12}" 364 | ] 365 | }, 366 | "execution_count": 23, 367 | "metadata": {}, 368 | "output_type": "execute_result" 369 | } 370 | ], 371 | "source": [ 372 | "d1.update({'b' : 'foo', 'c' : 12})\n", 373 | "d1" 374 | ] 375 | }, 376 | { 377 | "cell_type": "markdown", 378 | "metadata": {}, 379 | "source": [ 380 | "set" 381 | ] 382 | }, 383 | { 384 | "cell_type": "code", 385 | "execution_count": 24, 386 | "metadata": {}, 387 | "outputs": [ 388 | { 389 | "data": { 390 | "text/plain": [ 391 | "{1, 2, 3}" 392 | ] 393 | }, 394 | "execution_count": 24, 395 | "metadata": {}, 396 | "output_type": "execute_result" 397 | } 398 | ], 399 | "source": [ 400 | "set([2, 2, 2, 1, 3, 3])\n", 401 | "{2, 2, 2, 1, 3, 3}" 402 | ] 403 | }, 404 | { 405 | "cell_type": "markdown", 406 | "metadata": {}, 407 | "source": [ 408 | "List, Set, and Dict Comprehensions" 409 | ] 410 | }, 411 | { 412 | "cell_type": "code", 413 | "execution_count": 25, 414 | "metadata": {}, 415 | "outputs": [ 416 | { 417 | "data": { 418 | "text/plain": [ 419 | "['BAT', 'CAR', 'DOVE', 'PYTHON']" 420 | ] 421 | }, 422 | "execution_count": 25, 423 | "metadata": {}, 424 | "output_type": "execute_result" 425 | } 426 | ], 427 | "source": [ 428 | "strings = ['a', 'as', 'bat', 'car', 'dove', 'python']\n", 429 | "[x.upper() for x in strings if len(x) > 2]" 430 | ] 431 | }, 432 | { 433 | "cell_type": "markdown", 434 | "metadata": {}, 435 | "source": [ 436 | "Nested list comprehensions" 437 | ] 438 | }, 439 | { 440 | "cell_type": "code", 441 | "execution_count": 26, 442 | "metadata": { 443 | "collapsed": true 444 | }, 445 | "outputs": [], 446 | "source": [ 447 | "all_data = [['John', 'Emily', 'Michael', 'Mary', 'Steven'],\n", 448 | " ['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar']]" 449 | ] 450 | } 451 | ], 452 | "metadata": { 453 | "kernelspec": { 454 | "display_name": "Python 3", 455 | "language": "python", 456 | "name": "python3" 457 | }, 458 | "language_info": { 459 | "codemirror_mode": { 460 | "name": "ipython", 461 | "version": 3 462 | }, 463 | "file_extension": ".py", 464 | "mimetype": "text/x-python", 465 | "name": "python", 466 | "nbconvert_exporter": "python", 467 | "pygments_lexer": "ipython3", 468 | "version": "3.6.1" 469 | } 470 | }, 471 | "nbformat": 4, 472 | "nbformat_minor": 2 473 | } 474 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ### DL Toolkit Repository 2 | 3 | Toolkit Tutorials for getting started with Deep Learning. 4 | 5 | You can find the accompanying blog posts at http://medium.com/init27-labs Please feel free to fork/use the code as you want. If you feel there is scope for improvement, reach out to us or issue a PR, we're grateful to all our contributors for their support. 6 | --------------------------------------------------------------------------------