tutorials/tutorial2_deep_learning_libraries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial Part 2: Deep Learning Libraries\n",
    "In this tutorial, you'll get familiar with the most popular deep learning libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keras\n",
    "https://keras.io/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Activation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the model\n",
    "model = Sequential()\n",
    "model.add(Dense(32, activation='relu', input_dim=100))\n",
    "model.add(Dense(1, activation='sigmoid'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compile accepts the optimizer and the loss function\n",
    "model.compile(\n",
    "    optimizer='adam',\n",
    "    loss='binary_crossentropy',\n",
    "    metrics=['accuracy']\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# training data\n",
    "data = np.random.random((1000, 100)).astype(np.float32)\n",
    "labels = np.random.randint(2, size=(1000, 1)).astype(np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1000, 100)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.46766102, 0.24123445, 0.08452388, 0.3666759 , 0.5820863 ,\n",
       "        0.02717233, 0.8092726 , 0.693232  , 0.30956918, 0.5262542 ,\n",
       "        0.40517676, 0.07081285, 0.7481114 , 0.30779898, 0.82729685,\n",
       "        0.23595078, 0.6501258 , 0.98552865, 0.52228624, 0.5963983 ,\n",
       "        0.424813  , 0.54538333, 0.74023277, 0.5186164 , 0.31013143,\n",
       "        0.67367864, 0.46165305, 0.6002972 , 0.78533745, 0.30551317,\n",
       "        0.9495062 , 0.54857415, 0.31167874, 0.6954676 , 0.34788182,\n",
       "        0.57518405, 0.10705369, 0.60875726, 0.04705686, 0.92498744,\n",
       "        0.63246715, 0.6264184 , 0.24140006, 0.47684294, 0.80372345,\n",
       "        0.34266523, 0.34900242, 0.6545629 , 0.01746015, 0.6232982 ,\n",
       "        0.32974026, 0.35938972, 0.01104516, 0.24891818, 0.6058826 ,\n",
       "        0.37562242, 0.75703883, 0.5283604 , 0.5472243 , 0.90663797,\n",
       "        0.02140716, 0.1939004 , 0.92440516, 0.85662585, 0.60428405,\n",
       "        0.81388116, 0.72490865, 0.39498776, 0.29004273, 0.40608948,\n",
       "        0.27011403, 0.47289285, 0.9261094 , 0.13947117, 0.3802231 ,\n",
       "        0.72347015, 0.11828757, 0.08514433, 0.02948085, 0.92708284,\n",
       "        0.2378419 , 0.51997536, 0.17946646, 0.0413988 , 0.6599027 ,\n",
       "        0.27496004, 0.7518379 , 0.11070529, 0.48221293, 0.40565664,\n",
       "        0.8389177 , 0.634621  , 0.8442555 , 0.65517527, 0.6887331 ,\n",
       "        0.29030895, 0.31070027, 0.6151739 , 0.69356745, 0.92888045]],\n",
       "      dtype=float32)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[:3 :10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1000, 1)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.],\n",
       "       [0.],\n",
       "       [1.],\n",
       "       [1.],\n",
       "       [1.],\n",
       "       [0.],\n",
       "       [1.],\n",
       "       [0.],\n",
       "       [0.],\n",
       "       [1.]], dtype=float32)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "1000/1000 [==============================] - 0s 175us/step - loss: 0.7167 - acc: 0.4690\n",
      "Epoch 2/10\n",
      "1000/1000 [==============================] - 0s 30us/step - loss: 0.7037 - acc: 0.5150\n",
      "Epoch 3/10\n",
      "1000/1000 [==============================] - 0s 30us/step - loss: 0.6977 - acc: 0.5090\n",
      "Epoch 4/10\n",
      "1000/1000 [==============================] - 0s 32us/step - loss: 0.6918 - acc: 0.5270\n",
      "Epoch 5/10\n",
      "1000/1000 [==============================] - 0s 32us/step - loss: 0.6897 - acc: 0.5450\n",
      "Epoch 6/10\n",
      "1000/1000 [==============================] - 0s 30us/step - loss: 0.6896 - acc: 0.5450\n",
      "Epoch 7/10\n",
      "1000/1000 [==============================] - 0s 34us/step - loss: 0.6847 - acc: 0.5460\n",
      "Epoch 8/10\n",
      "1000/1000 [==============================] - 0s 31us/step - loss: 0.6751 - acc: 0.5750\n",
      "Epoch 9/10\n",
      "1000/1000 [==============================] - 0s 32us/step - loss: 0.6728 - acc: 0.5890\n",
      "Epoch 10/10\n",
      "1000/1000 [==============================] - 0s 32us/step - loss: 0.6727 - acc: 0.5960\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x7fc7495bdc50>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(data, labels, epochs=10, batch_size=32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensorflow\n",
    "https://www.tensorflow.org/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = tf.constant(3.0, dtype=tf.float32)\n",
    "b = tf.constant(4.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Const:0' shape=() dtype=float32>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "sess = tf.Session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3.0, 4.0]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sess.run([a,b])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'add:0' shape=() dtype=float32>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sess.run(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = tf.placeholder(tf.float32)\n",
    "b = tf.placeholder(tf.float32)\n",
    "adder = a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sess.run(adder, {a: 3, b:4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sess.run(adder, {a: 10, b:20})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The same model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = tf.placeholder(tf.float32, shape=(None, 100))\n",
    "targets = tf.placeholder(tf.float32, shape=(None, 1))\n",
    "\n",
    "fc1 = tf.layers.dense(inputs, 32, activation=tf.nn.relu)\n",
    "outputs = tf.layers.dense(fc1, 1, activation=None)\n",
    "\n",
    "outputs_sigmoid = tf.nn.sigmoid(outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'Placeholder_2:0' shape=(?, 100) dtype=float32>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'dense/Relu:0' shape=(?, 32) dtype=float32>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fc1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'dense_3/BiasAdd:0' shape=(?, 1) dtype=float32>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = tf.losses.sigmoid_cross_entropy(targets, outputs)\n",
    "accuracy = tf.reduce_mean(tf.to_float(tf.equal(targets, tf.to_float(outputs_sigmoid > 0.5))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.train.AdamOptimizer(0.001)\n",
    "train = optimizer.minimize(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "init = tf.global_variables_initializer()\n",
    "sess.run(init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, loss: 0.650, accuracy: 0.675\n",
      "Epoch: 1, loss: 0.650, accuracy: 0.682\n",
      "Epoch: 2, loss: 0.646, accuracy: 0.685\n",
      "Epoch: 3, loss: 0.645, accuracy: 0.692\n",
      "Epoch: 4, loss: 0.642, accuracy: 0.693\n",
      "Epoch: 5, loss: 0.639, accuracy: 0.697\n",
      "Epoch: 6, loss: 0.637, accuracy: 0.704\n",
      "Epoch: 7, loss: 0.635, accuracy: 0.706\n",
      "Epoch: 8, loss: 0.633, accuracy: 0.714\n",
      "Epoch: 9, loss: 0.630, accuracy: 0.714\n",
      "Epoch: 10, loss: 0.627, accuracy: 0.718\n",
      "Epoch: 11, loss: 0.626, accuracy: 0.725\n",
      "Epoch: 12, loss: 0.622, accuracy: 0.724\n",
      "Epoch: 13, loss: 0.620, accuracy: 0.731\n",
      "Epoch: 14, loss: 0.619, accuracy: 0.734\n",
      "Epoch: 15, loss: 0.617, accuracy: 0.735\n",
      "Epoch: 16, loss: 0.615, accuracy: 0.742\n",
      "Epoch: 17, loss: 0.612, accuracy: 0.744\n",
      "Epoch: 18, loss: 0.609, accuracy: 0.750\n",
      "Epoch: 19, loss: 0.606, accuracy: 0.753\n"
     ]
    }
   ],
   "source": [
    "nb_epochs = 20\n",
    "batch_size = 64\n",
    "nb_batches = len(data) // batch_size\n",
    "for epoch in range(nb_epochs):\n",
    "    accuracies = []\n",
    "    losses = []\n",
    "    for batch_idx in range(nb_batches):\n",
    "        batch_start = batch_idx * batch_size\n",
    "        batch_end = batch_start + batch_size\n",
    "\n",
    "        batch_inputs = data[batch_start:batch_end]\n",
    "        batch_targets = labels[batch_start:batch_end]       \n",
    "      \n",
    "        _, loss_value, accuracy_value = sess.run(\n",
    "            [train, loss, accuracy], {inputs: batch_inputs, targets: batch_targets}\n",
    "        )\n",
    "        losses.append(loss_value)        \n",
    "        accuracies.append(accuracy_value)\n",
    "        \n",
    "    accuracy_value = np.mean(accuracies)\n",
    "    loss_value = np.mean(loss_value)    \n",
    "    print(f'Epoch: {epoch}, loss: {loss_value:.3f}, accuracy: {accuracy_value:.3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that there's also a `tf.estimator` API that makes the training a little bit simplier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyTorch\n",
    "https://pytorch.org/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import torch.utils.data\n",
    "\n",
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = torch.ones(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a + 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([11., 11., 11., 11., 11.])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The same model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(torch.nn.Module):\n",
    "    def __init__(self, input_size, hidden_size=32):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.fc1 = torch.nn.Linear(100, hidden_size)\n",
    "        self.fc2 = torch.nn.Linear(hidden_size, 1)\n",
    "        \n",
    "    def forward(self, inputs):\n",
    "        hidden = F.relu(self.fc1(inputs))\n",
    "        outputs = self.fc2(hidden)\n",
    "        \n",
    "        outputs = outputs\n",
    "        return outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Net(input_size=data.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Net(\n",
       "  (fc1): Linear(in_features=100, out_features=32, bias=True)\n",
       "  (fc2): Linear(in_features=32, out_features=1, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.1069],\n",
       "        [0.1112],\n",
       "        [0.0593],\n",
       "        [0.1342]], grad_fn=<AddmmBackward>)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(torch.rand(4, 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = torch.utils.data.TensorDataset(torch.from_numpy(data), torch.from_numpy(labels))\n",
    "data_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(dataset[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.4677, 0.2412, 0.0845, 0.3667, 0.5821, 0.0272, 0.8093, 0.6932, 0.3096,\n",
       "        0.5263])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[0][0][:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1.])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[0][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = torch.nn.BCEWithLogitsLoss().cuda()\n",
    "optimizer = torch.optim.Adam(model.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, loss: 0.695, accuracy: 0.485\n",
      "Epoch: 1, loss: 0.693, accuracy: 0.502\n",
      "Epoch: 2, loss: 0.691, accuracy: 0.521\n",
      "Epoch: 3, loss: 0.690, accuracy: 0.550\n",
      "Epoch: 4, loss: 0.688, accuracy: 0.548\n",
      "Epoch: 5, loss: 0.688, accuracy: 0.564\n",
      "Epoch: 6, loss: 0.686, accuracy: 0.553\n",
      "Epoch: 7, loss: 0.683, accuracy: 0.552\n",
      "Epoch: 8, loss: 0.681, accuracy: 0.611\n",
      "Epoch: 9, loss: 0.680, accuracy: 0.554\n",
      "Epoch: 10, loss: 0.680, accuracy: 0.587\n",
      "Epoch: 11, loss: 0.674, accuracy: 0.583\n",
      "Epoch: 12, loss: 0.670, accuracy: 0.653\n",
      "Epoch: 13, loss: 0.666, accuracy: 0.614\n",
      "Epoch: 14, loss: 0.665, accuracy: 0.631\n",
      "Epoch: 15, loss: 0.662, accuracy: 0.629\n",
      "Epoch: 16, loss: 0.659, accuracy: 0.651\n",
      "Epoch: 17, loss: 0.654, accuracy: 0.639\n",
      "Epoch: 18, loss: 0.656, accuracy: 0.596\n",
      "Epoch: 19, loss: 0.648, accuracy: 0.651\n"
     ]
    }
   ],
   "source": [
    "nb_epochs = 20\n",
    "batch_size = 64\n",
    "nb_batches = len(data) // batch_size\n",
    "for epoch in range(nb_epochs):\n",
    "    accuracies = []\n",
    "    losses = []\n",
    "    for i, (inputs, targets) in enumerate(data_loader):\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        inputs = inputs.cuda()\n",
    "        targets = targets.cuda()\n",
    "        \n",
    "        outputs = model(inputs)\n",
    "        \n",
    "        loss = criterion(outputs, targets)\n",
    "        loss.backward()\n",
    "        optimizer.step()        \n",
    "\n",
    "        y_pred = (torch.sigmoid(outputs) > 0.5).data.cpu().numpy()\n",
    "        y_true = targets.data.cpu().numpy()\n",
    "        accuracy = accuracy_score(y_true, y_pred)\n",
    "        \n",
    "        losses.append(float(loss))\n",
    "        accuracies.append(accuracy)\n",
    "        \n",
    "    accuracy = np.mean(accuracies)\n",
    "    loss = np.mean(losses)    \n",
    "    print(f'Epoch: {epoch}, loss: {loss:.3f}, accuracy: {accuracy:.3f}')        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}