chapter04_getting-started-with-neural-networks.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%aimport tensor_toolbox\n",
    "%autoreload 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "# Getting started with neural networks: Classification and regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "## Classifying movie reviews: A binary classification example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### The IMDB dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.1: Loading the IMDB dataset**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "from tensorflow.keras.datasets import imdb\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words=10000)\n",
    "# These are arrays of lists! Ugh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.2: Decoding reviews back to text**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"? big hair big boobs bad music and a giant safety pin these are the words to best describe this terrible movie i love cheesy horror movies and i've seen hundreds but this had got to be on of the worst ever made the plot is paper thin and ridiculous the acting is an abomination the script is completely laughable the best is the end showdown with the cop and how he worked out who the killer is it's just so damn terribly written the clothes are sickening and funny in equal ? the hair is big lots of boobs ? men wear those cut ? shirts that show off their ? sickening that men actually wore them and the music is just ? trash that plays over and over again in almost every scene there is trashy music boobs and ? taking away bodies and the gym still doesn't close for ? all joking aside this is a truly bad film whose only charm is to look back on the disaster that was the 80's and have a good old laugh at how bad everything was back then\""
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_index = imdb.get_word_index()\n",
    "def read_review (review, word_index):\n",
    "    reverse_word_index = dict(\n",
    "        [(value, key) for (key, value) in word_index.items()])\n",
    "    return \" \".join(\n",
    "        [reverse_word_index.get(i - 3, \"?\") for i in review])\n",
    "read_review(train_data[1], word_index) # Interesting review"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Preparing the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.3: Encoding the integer sequences via multi-hot encoding**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "# It's important to note that by doing this, the concept of order is lost. The list previously had added meaning by\n",
    "# containing the order of the words. The vectorized interpretation only contains the presence of the word.\n",
    "# Therefore, it is impossible to get the sentence again from the vectorized form!\n",
    "def vectorize_sequences(sequences, dimension=10000):\n",
    "    results = np.zeros((len(sequences), dimension))\n",
    "    for i, sequence in enumerate(sequences):\n",
    "        for j in sequence:\n",
    "            results[i, j] = 1. # Sparse representation of the data\n",
    "            # For each entry, we will obtain a 10000-dimensional vector with 1s and 0s\n",
    "    return results\n",
    "x_train = vectorize_sequences(train_data)\n",
    "x_test = vectorize_sequences(test_data)\n",
    "\n",
    "y_train = np.asarray(train_labels).astype(\"float32\")\n",
    "y_test = np.asarray(test_labels).astype(\"float32\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== x_train | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (25000, 10000) | nDims: 2 | dtype: float64\n",
      "x_train[0]: [0. 1. 1. 0. 1. 1. 1. 1. 1. 1. 0. 0. 1. 1. 1. 1. 1. 1. 1. 1.]\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== train_labels | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (25000,) | nDims: 1 | dtype: int64\n",
      "Content: [1 0 0 1 0 0 1 0 1 0 1 0 0 0 0 0 1 1 0 1]\n",
      "... (showing only the first 20 elements)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "tensor_toolbox.tensor_info(x_train, \"x_train\", image=False)\n",
    "tensor_toolbox.tensor_info(train_labels, \"train_labels\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Building your model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.4: Model definition**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "\n",
    "model = keras.Sequential([\n",
    "    layers.Dense(16, activation=\"relu\"),\n",
    "    layers.Dense(16, activation=\"relu\"),\n",
    "    layers.Dense(1, activation=\"sigmoid\")\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/alemalvarez/.pyenv/versions/3.11.5/lib/python3.11/site-packages/torch/nn/modules/lazy.py:181: UserWarning: Lazy modules are a new feature under heavy development so changes to the API or functionality can happen at any moment.\n",
      "  warnings.warn('Lazy modules are a new feature under heavy development '\n"
     ]
    }
   ],
   "source": [
    "# PyTorch:\n",
    "import torch\n",
    "class TorchModel (torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        # This layer is lazy, it will only be created when the model is\n",
    "        # first run. Kind of similar to how Keras works.\n",
    "        self.fc1 = torch.nn.LazyLinear(16)\n",
    "        self.fc2 = torch.nn.Linear(16, 16)\n",
    "        self.fc3 = torch.nn.Linear(16, 1)\n",
    "    def forward(self, x):\n",
    "        x = torch.relu(self.fc1(x))\n",
    "        x = torch.relu(self.fc2(x))\n",
    "        return self.fc3(x)\n",
    "\n",
    "torchmodel = TorchModel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.5: Compiling the model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "model.compile(optimizer=\"rmsprop\", # rmsprop is a good default optimizer\n",
    "              loss=\"binary_crossentropy\", # binary_crossentropy is a good default loss function for binary classification\n",
    "              metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.RMSprop(torchmodel.parameters())\n",
    "loss_fn = torch.nn.BCEWithLogitsLoss() # Binary Cross-Entropy Loss from raw logits. Better for numerical stability.\n",
    "# For computing the loss, we are in a conundrum:\n",
    "# It gets reduced to a scalar by computing the batch average.\n",
    "# However, to be able to compute the average epoch loss, we need to\n",
    "# accumulate the loss without averaging it.\n",
    "# There are two options: either we multiply it back by the batch size\n",
    "# before accumulating it and after updating the weights,\n",
    "# or we keep it from reducing using 'reduction=none'. Then, we would\n",
    "# have to manually divide it by the batch size while computing the\n",
    "# gradient! I prefer approach 1.\n",
    "\n",
    "def torchtrain (model, train_dataloader, optimizer, loss_fn):\n",
    "    model.train() # Set training mode for the model\n",
    "    # Initialize metrics\n",
    "    total_loss = 0.0\n",
    "    correct = 0\n",
    "    samples = 0\n",
    "\n",
    "    for X, y in train_dataloader: # Iterate over the batches\n",
    "        # Forward pass\n",
    "        y_hat = torch.flatten(model(X)) # I flatten it because the output has shape (batch_size, 1)\n",
    "        # You can also use unsqueeze to add a dimension to the targets.\n",
    "\n",
    "        loss = loss_fn(y_hat, y) # Calculate the loss\n",
    "\n",
    "        # Backprop\n",
    "        optimizer.zero_grad() # Zero the gradients\n",
    "        loss.backward() # Calculate the gradients\n",
    "        optimizer.step() # Update the weights\n",
    "\n",
    "        # Metrics\n",
    "        total_loss += loss.item()*len(X) # Loss value!\n",
    "        # The expression y_hat.round() == y returns a tensor with shape\n",
    "        # 512x1 with True/False values. sum() will sum the True values.\n",
    "        # item() will convert the tensor to a Python number.\n",
    "\n",
    "        # Keep in mind that, using BCEwithLogitsLoss, the output is not a probability!\n",
    "        # To be able to compute accuracy, we will need to run it through a sigmoid and then\n",
    "        # round it.\n",
    "        correct += ((torch.sigmoid(y_hat).round()) == y).sum().item()\n",
    "        samples += len(y) # Items in the batch\n",
    "\n",
    "    avg_loss = total_loss / len(train_dataloader.dataset)\n",
    "    return avg_loss, correct / samples # Accuracy and loss\n",
    "\n",
    "def torchtest (model, test_dataloader, loss_fn):\n",
    "    model.eval() # Set evaluation mode\n",
    "    # Initialize metrics\n",
    "    total_loss = 0.0\n",
    "    correct = 0\n",
    "    samples = 0\n",
    "\n",
    "    with torch.no_grad(): # Disable gradient calculation\n",
    "        for X, y in test_dataloader: # Iterate over the batches\n",
    "            y_hat = torch.flatten(model(X)) # Forward pass. Flatten to get shape (512)\n",
    "            loss = loss_fn(y_hat, y) # Calculate the loss\n",
    "            # Metrics\n",
    "            total_loss += loss.item()*len(X) # Loss value\n",
    "            correct += (torch.sigmoid(y_hat.round()) == y).sum().item() # Correct count (with sigmoid)\n",
    "            samples += len(y) # Items in the batch\n",
    "    avg_loss = total_loss / len(test_dataloader.dataset)\n",
    "    return avg_loss, correct / samples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Validating your approach"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.6: Setting aside a validation set**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "x_val = x_train[:10000]\n",
    "partial_x_train = x_train[10000:]\n",
    "y_val = y_train[:10000]\n",
    "partial_y_train = y_train[10000:]\n",
    "\n",
    "# Or, in scikit:\n",
    "from sklearn.model_selection import train_test_split\n",
    "x_train, x_val, y_train, y_val = train_test_split(x_train, y_train,\n",
    "                                                  test_size=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== train_dataloader | tensor_info ====================\n",
      "Type: <class 'torch.utils.data.dataloader.DataLoader'>\n",
      "Batch size: 512 | N batches: 30 \n",
      "-- First batch of features\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512, 10000]) | nDims: 2 | dtype: torch.float32\n",
      "features[0]: tensor([0., 1., 1., 0., 1., 1., 1., 1., 1., 1., 0., 1., 1., 1., 1., 0., 0., 0.,\n",
      "        1., 1.])\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "-- First batch of labels\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512]) | nDims: 1 | dtype: torch.float32\n",
      "Content: tensor([1., 0., 1., 0., 0., 0., 1., 1., 0., 0., 0., 0., 1., 1., 1., 0., 0., 1.,\n",
      "        1., 1.])\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "\n",
      "==================== val_dataloader | tensor_info ====================\n",
      "Type: <class 'torch.utils.data.dataloader.DataLoader'>\n",
      "Batch size: 512 | N batches: 20 \n",
      "-- First batch of features\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512, 10000]) | nDims: 2 | dtype: torch.float32\n",
      "features[0]: tensor([0., 1., 1., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 1., 1., 1.,\n",
      "        1., 1.])\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "-- First batch of labels\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512]) | nDims: 1 | dtype: torch.float32\n",
      "Content: tensor([0., 1., 0., 0., 1., 1., 0., 0., 1., 0., 0., 1., 0., 0., 1., 0., 1., 0.,\n",
      "        0., 0.])\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Let's build two PyTorch dataloaders to hold the data\n",
    "train_dataloader = tensor_toolbox.make_dataloader([x_train], [y_train], batch_size=512, shuffle=False)\n",
    "val_dataloader = tensor_toolbox.make_dataloader([x_val], [y_val], batch_size=512, shuffle=False)\n",
    "tensor_toolbox.tensor_info(train_dataloader, \"train_dataloader\", image=False)\n",
    "tensor_toolbox.tensor_info(val_dataloader, \"val_dataloader\", image=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Annex: Propagations in PyTorch, Binary Cross Entropy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== first_batch_input | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512, 10000]) | nDims: 2 | dtype: torch.float32\n",
      "first_batch_input[0]: tensor([0., 1., 1., 0., 1., 1., 1., 1., 1., 1., 0., 1., 1., 1., 1., 0., 0., 0.,\n",
      "        1., 1.])\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== first_batch_labels | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512]) | nDims: 1 | dtype: torch.float32\n",
      "Content: tensor([1., 0., 1., 0., 0., 0., 1., 1., 0., 0., 0., 0., 1., 1., 1., 0., 0., 1.,\n",
      "        1., 1.])\n",
      "... (showing only the first 20 elements)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# The moment has come to look into the shapes of the info flow in PyTorch. \n",
    "# Let's select a single sample, and propagate it through the model.\n",
    "first_batch = next(iter(train_dataloader))\n",
    "first_batch_input = first_batch[0]\n",
    "first_batch_labels = first_batch[1]\n",
    "tensor_toolbox.tensor_info(first_batch_input, \"first_batch_input\", image=False)\n",
    "tensor_toolbox.tensor_info(first_batch_labels, \"first_batch_labels\", image=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== first_batch_output | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512, 1]) | nDims: 2 | dtype: torch.float32\n",
      "Content: tensor([0.4942, 0.4971, 0.4973, 0.4998, 0.4956, 0.4976, 0.4961, 0.4960, 0.4954,\n",
      "        0.4968, 0.4982, 0.4940, 0.4968, 0.4972, 0.4949, 0.4955, 0.4949, 0.4944,\n",
      "        0.4951, 0.4941], grad_fn=<ViewBackward0>)\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== first_batch_label unsqueezed | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512, 1]) | nDims: 2 | dtype: torch.float32\n",
      "Content: tensor([1., 0., 1., 0., 0., 0., 1., 1., 0., 0., 0., 0., 1., 1., 1., 0., 0., 1.,\n",
      "        1., 1.])\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== first_batch_loss | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([]) | nDims: 0 | dtype: torch.float32\n",
      "Content: 0.692478597164154\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/alemalvarez/code-workspace/dl-with-python-pytorch/tensor_toolbox.py:89: UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the .grad field to be populated for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/build/aten/src/ATen/core/TensorBody.h:494.)\n",
      "  if(tensor.requires_grad and tensor.grad is not None):\n"
     ]
    }
   ],
   "source": [
    "# It's key to see that even though a batch consists of 512 samples, it is only\n",
    "# one tensor! This is because the model is designed to handle batches, and\n",
    "# the operations get vectorized. \n",
    "first_batch_output = torchmodel(first_batch_input)\n",
    "tensor_toolbox.tensor_info(first_batch_output, \"first_batch_output\", image=False)\n",
    "# The shapes are different! Y is 512 Sized and yhat is 512x1 sized. \n",
    "# Let's fix it.\n",
    "first_batch_labels_expanded = first_batch_labels.unsqueeze(1)\n",
    "tensor_toolbox.tensor_info(first_batch_labels_expanded, \"first_batch_label unsqueezed\", image=False)\n",
    "\n",
    "first_batch_loss = loss_fn(first_batch_output, first_batch_labels_expanded) # If reduction is 'mean'\n",
    "# (which is default), the loss is averaged over the batch. Therefore, the loss is a scalar tensor!\n",
    "\n",
    "tensor_toolbox.tensor_info(first_batch_loss, \"first_batch_loss\", image=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== first_batch_correct raw | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512, 1]) | nDims: 2 | dtype: torch.bool\n",
      "Content: tensor([False,  True, False,  True,  True,  True, False, False,  True,  True,\n",
      "         True,  True, False, False, False,  True,  True, False, False, False])\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== first_batch_correct | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([]) | nDims: 0 | dtype: torch.int64\n",
      "Content: 277\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Let's compute the number of correct labels for accuracy calculations:\n",
    "# In this case, as y is a 512x1 tensor, it is easier to sum the correct guesses by\n",
    "# comparing element-wise and adding the results.\n",
    "first_batch_correct = ((first_batch_output.round()) == first_batch_labels_expanded)\n",
    "tensor_toolbox.tensor_info(first_batch_correct, \"first_batch_correct raw\", image=False)\n",
    "first_batch_correct = first_batch_correct.sum()\n",
    "tensor_toolbox.tensor_info(first_batch_correct, \"first_batch_correct\", image=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.7: Training your model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "da37ed430ea443a48458f51c2c58dba8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0epoch [00:00, ?epoch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "363577351a144a09bdbbbf831c0f4b91",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0batch [00:00, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tqdm.keras import TqdmCallback\n",
    "from tensorflow.keras.callbacks import TensorBoard\n",
    "\n",
    "history = model.fit(partial_x_train,\n",
    "                    partial_y_train,\n",
    "                    epochs=20,\n",
    "                    batch_size=512,\n",
    "                    validation_data=(x_val, y_val),\n",
    "                    verbose=0,\n",
    "                    callbacks=[TqdmCallback(verbose=1), \n",
    "                               TensorBoard(log_dir=\"logs\")])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tensor_toolbox.draw_training_history(history=history)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "Train -- Accuracy: 0.7370666666666666 | Loss: 0.6112157995700837\n",
      "Validation -- Accuracy: 0.8711 | Loss: 0.3175922405719757\n",
      "Epoch 2/20\n",
      "Train -- Accuracy: 0.9016666666666666 | Loss: 0.24886251456737518\n",
      "Validation -- Accuracy: 0.8823 | Loss: 0.2861351694583893\n",
      "Epoch 3/20\n",
      "Train -- Accuracy: 0.9368666666666666 | Loss: 0.17713230335911115\n",
      "Validation -- Accuracy: 0.8806 | Loss: 0.29858031578063965\n",
      "Epoch 4/20\n",
      "Train -- Accuracy: 0.9638666666666666 | Loss: 0.10141454988519351\n",
      "Validation -- Accuracy: 0.8799 | Loss: 0.348565754365921\n",
      "Epoch 5/20\n",
      "Train -- Accuracy: 0.9764 | Loss: 0.07045509678423405\n",
      "Validation -- Accuracy: 0.8791 | Loss: 0.39972504620552063\n",
      "Epoch 6/20\n",
      "Train -- Accuracy: 0.9854 | Loss: 0.046886634885768094\n",
      "Validation -- Accuracy: 0.8738 | Loss: 0.4621594308853149\n",
      "Epoch 7/20\n",
      "Train -- Accuracy: 0.9656 | Loss: 0.1739605342487494\n",
      "Validation -- Accuracy: 0.8792 | Loss: 0.38217355394363406\n",
      "Epoch 8/20\n",
      "Train -- Accuracy: 0.9906 | Loss: 0.03506569293687741\n",
      "Validation -- Accuracy: 0.8769 | Loss: 0.4572056742191315\n",
      "Epoch 9/20\n",
      "Train -- Accuracy: 0.9938 | Loss: 0.021389941010872524\n",
      "Validation -- Accuracy: 0.8751 | Loss: 0.5291803965091705\n",
      "Epoch 10/20\n",
      "Train -- Accuracy: 0.9952 | Loss: 0.01368978699296713\n",
      "Validation -- Accuracy: 0.8748 | Loss: 0.6381984724521637\n",
      "Epoch 11/20\n",
      "Train -- Accuracy: 0.9958 | Loss: 0.009597467208902042\n",
      "Validation -- Accuracy: 0.8741 | Loss: 0.7307847456932068\n",
      "Epoch 12/20\n",
      "Train -- Accuracy: 0.996 | Loss: 0.007428438745687405\n",
      "Validation -- Accuracy: 0.8743 | Loss: 0.8033297063827515\n",
      "Epoch 13/20\n",
      "Train -- Accuracy: 0.9960666666666667 | Loss: 0.006148105746259292\n",
      "Validation -- Accuracy: 0.873 | Loss: 0.8387202603340149\n",
      "Epoch 14/20\n",
      "Train -- Accuracy: 0.9961333333333333 | Loss: 0.005319858650366465\n",
      "Validation -- Accuracy: 0.8729 | Loss: 0.9117776210784913\n",
      "Epoch 15/20\n",
      "Train -- Accuracy: 0.9980666666666667 | Loss: 0.004587269838899374\n",
      "Validation -- Accuracy: 0.871 | Loss: 0.9800881030082703\n",
      "Epoch 16/20\n",
      "Train -- Accuracy: 0.9988666666666667 | Loss: 0.004027209304769834\n",
      "Validation -- Accuracy: 0.8707 | Loss: 1.058175837993622\n",
      "Epoch 17/20\n",
      "Train -- Accuracy: 0.9988 | Loss: 0.0036757373301933207\n",
      "Validation -- Accuracy: 0.8706 | Loss: 1.1109545124053954\n",
      "Epoch 18/20\n",
      "Train -- Accuracy: 0.9988666666666667 | Loss: 0.0033864851510773102\n",
      "Validation -- Accuracy: 0.8704 | Loss: 1.1967171928405762\n",
      "Epoch 19/20\n",
      "Train -- Accuracy: 0.9989333333333333 | Loss: 0.0030857775337994097\n",
      "Validation -- Accuracy: 0.8693 | Loss: 1.3076483810424804\n",
      "Epoch 20/20\n",
      "Train -- Accuracy: 0.999 | Loss: 0.002870709237580498\n",
      "Validation -- Accuracy: 0.8703 | Loss: 1.3434219375610352\n"
     ]
    }
   ],
   "source": [
    "epochs = 20\n",
    "for epoch in range(1, epochs+1):\n",
    "    print(f\"Epoch {epoch}/{epochs}\")\n",
    "    loss, accu = torchtrain(torchmodel, train_dataloader, optimizer, loss_fn)\n",
    "    print(f\"Train -- Accuracy: {accu} | Loss: {loss}\")\n",
    "    loss, accu = torchtest(torchmodel, val_dataloader, loss_fn)\n",
    "    print(f\"Validation -- Accuracy: {accu} | Loss: {loss}\")\n",
    "\n",
    "#TODO: Find a way to print more interesting output that takes less space."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.8: Plotting the training and validation loss**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "history_dict = history.history\n",
    "loss_values = history_dict[\"loss\"]\n",
    "val_loss_values = history_dict[\"val_loss\"]\n",
    "epochs = range(1, len(loss_values) + 1)\n",
    "plt.plot(epochs, loss_values, \"bo\", label=\"Training loss\")\n",
    "plt.plot(epochs, val_loss_values, \"b\", label=\"Validation loss\")\n",
    "plt.title(\"Training and validation loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.9: Plotting the training and validation accuracy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.clf()\n",
    "acc = history_dict[\"accuracy\"]\n",
    "val_acc = history_dict[\"val_accuracy\"]\n",
    "plt.plot(epochs, acc, \"bo\", label=\"Training acc\")\n",
    "plt.plot(epochs, val_acc, \"b\", label=\"Validation acc\")\n",
    "plt.title(\"Training and validation accuracy\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.10: Retraining a model from scratch**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7ea370dc5d24455b95dc50d4ba7c686f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0epoch [00:00, ?epoch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "752c1f3016c1443981798a368f90b529",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0batch [00:00, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "782/782 [==============================] - 0s 541us/step - loss: 0.3186 - accuracy: 0.8744\n"
     ]
    }
   ],
   "source": [
    "model = keras.Sequential([\n",
    "    layers.Dense(16, activation=\"relu\"),\n",
    "    layers.Dense(16, activation=\"relu\"),\n",
    "    layers.Dense(1, activation=\"sigmoid\")\n",
    "])\n",
    "model.compile(optimizer=\"rmsprop\",\n",
    "              loss=\"binary_crossentropy\",\n",
    "              metrics=[\"accuracy\"])\n",
    "\n",
    "model.fit(np.concatenate((x_train, x_val)), np.concatenate((y_train, y_val)), epochs=4, batch_size=512,\n",
    "          callbacks=[TqdmCallback(verbose=1)], verbose=0)\n",
    "results = model.evaluate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/alemalvarez/.pyenv/versions/3.11.5/lib/python3.11/site-packages/torch/nn/modules/lazy.py:181: UserWarning: Lazy modules are a new feature under heavy development so changes to the API or functionality can happen at any moment.\n",
      "  warnings.warn('Lazy modules are a new feature under heavy development '\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "Train -- Accuracy: 0.5062 | Loss: 1.0495133726119996\n",
      "Epoch 2/2\n",
      "Train -- Accuracy: 0.5686 | Loss: 0.6886625045776367\n",
      "Test -- Accuracy: 0.7764 | Loss: 0.5789848280334473\n"
     ]
    }
   ],
   "source": [
    "# Let's create a new dataloader to iterate over the whole training data (training+val) and\n",
    "# another to iterate over the test data.\n",
    "train_dataloader = tensor_toolbox.make_dataloader([x_train, x_val], [y_train, y_val], batch_size=512, shuffle=False)\n",
    "test_dataloader = tensor_toolbox.make_dataloader([x_test], [y_test], batch_size=512, shuffle=False)\n",
    "# The torch model peaks in validation metrics at the second iteration! That's actually crazy.\n",
    "epochs = 2\n",
    "# Re-initialize the model, optimizer and loss object:\n",
    "torchmodel = TorchModel()\n",
    "optimizer = torch.optim.RMSprop(torchmodel.parameters())\n",
    "loss_fn = torch.nn.BCELoss() \n",
    "\n",
    "for epoch in range(1, epochs+1):\n",
    "    print(f\"Epoch {epoch}/{epochs}\")\n",
    "    loss, accu = torchtrain(torchmodel, train_dataloader, optimizer, loss_fn)\n",
    "    print(f\"Train -- Accuracy: {accu} | Loss: {loss}\")\n",
    "\n",
    "loss, accu = torchtest(torchmodel, test_dataloader, loss_fn)\n",
    "print(f\"Test -- Accuracy: {accu} | Loss: {loss}\") # Hell yeah! We happy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Using a trained model to generate predictions on new data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "782/782 [==============================] - 0s 437us/step\n",
      "==================== Keras predictions | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (25000, 1) | nDims: 2 | dtype: float32\n",
      "Content: [1.3077712e-01 9.9908990e-01 6.7013836e-01 6.2095636e-01 9.3199962e-01\n",
      " 6.2911880e-01 9.9857688e-01 2.9880223e-03 9.3209517e-01 9.6303332e-01\n",
      " 8.9919835e-01 3.7891800e-03 3.8891074e-05 1.1317553e-02 9.8426348e-01\n",
      " 2.7555038e-06 8.1941819e-01 6.3465476e-01 1.0759056e-03 2.9207967e-02]\n",
      "... (showing only the first 20 elements)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "tensor_toolbox.tensor_info(model.predict(x_test), \"Keras predictions\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "? this is jackie chan's best film and my personal favourite after the disappointing u s made 'the ? directed by james ? jackie took the concept and placed it slap bang into hong kong this is also probably ? most violent movie with the audience cringing at the bone breaking stunts br br the action is fast and furious jackie and his crew really did put max effort into the fight design bones were broken and blood ? in the process of making this film as you'll see in the credits br br the script is a simple cops and robbers affair nothing special after all it was written around the action i must say that the english version has some dodgy dubbing but it shouldn't put you off too much br br so get the ? round crack open the beers and enjoy by the way the film was ? ? ? by the stunt crew why i'll let you find out for yourself\n",
      "1/1 [==============================] - 0s 10ms/step\n",
      "Prediction: Positive | Confidence: [0.93385845]\n"
     ]
    }
   ],
   "source": [
    "index = 751\n",
    "print(read_review(train_data[index], word_index))\n",
    "x = vectorize_sequences([test_data[index]])\n",
    "yhat = model.predict(x)\n",
    "print(f\"Prediction: {'Positive'if yhat[0] > 0.5 else 'Negative'} | Confidence: {yhat[0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Further experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: I would love to streamline this kind of network development. It gets kind of crammed..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "model1 = keras.Sequential([\n",
    "    layers.Dense(16, activation=\"relu\"),\n",
    "    layers.Dense(16, activation=\"relu\"),\n",
    "    layers.Dense(1, activation=\"sigmoid\")\n",
    "], name=\"model1\")\n",
    "model1.compile(optimizer=\"rmsprop\",\n",
    "              loss=\"binary_crossentropy\",\n",
    "              metrics=[\"accuracy\"])\n",
    "\n",
    "model2 = keras.Sequential([\n",
    "    layers.Dense(32, activation=\"relu\"),\n",
    "    layers.Dense(1, activation=\"sigmoid\")\n",
    "], name=\"model2\")\n",
    "model2.compile(optimizer=\"rmsprop\",\n",
    "              loss=\"mse\",\n",
    "              metrics=[\"accuracy\"])\n",
    "\n",
    "model3 = keras.Sequential([\n",
    "    layers.Dense(16, activation=\"tanh\"),\n",
    "    layers.Dense(1, activation=\"sigmoid\")\n",
    "], name=\"model3\")\n",
    "model3.compile(optimizer=\"rmsprop\",\n",
    "              loss=\"mse\",\n",
    "              metrics=[\"accuracy\"])\n",
    "model4 = keras.Sequential([\n",
    "    layers.Dense(16, activation=\"relu\"),\n",
    "    layers.Dense(16, activation=\"relu\"),\n",
    "    layers.Dense(1, activation=\"sigmoid\")\n",
    "], name=\"model4\")\n",
    "model4.compile(optimizer=\"rmsprop\",\n",
    "              loss=\"mse\",\n",
    "              metrics=[\"accuracy\"])\n",
    "\n",
    "model5 = keras.Sequential([\n",
    "    layers.Dense(32, activation=\"tanh\"),\n",
    "    layers.Dense(1, activation=\"sigmoid\")\n",
    "], name=\"model5\")\n",
    "model5.compile(optimizer=\"rmsprop\",\n",
    "              loss=\"mse\",\n",
    "              metrics=[\"accuracy\"])\n",
    "\n",
    "model6 = keras.Sequential([\n",
    "    layers.Dense(16, activation=\"relu\"),\n",
    "    layers.Dense(16, activation=\"tanh\"),\n",
    "    layers.Dense(1, activation=\"sigmoid\")\n",
    "], name=\"model6\")\n",
    "model6.compile(optimizer=\"rmsprop\",\n",
    "              loss=\"binary_crossentropy\",\n",
    "              metrics=[\"accuracy\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function is kind of cool tho.\n",
    "#tensor_toolbox.keras_comparer([model1, model2, model3, model4, model5, model6], X_train=x_train, y_train=y_train, X_test=x_test, y_test=y_test, val_data=(x_val, y_val), epochs=10, batch_size=512)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Wrapping up"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "## Classifying newswires: A multiclass classification example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### The Reuters dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.11: Loading the Reuters dataset**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "from tensorflow.keras.datasets import reuters\n",
    "(train_data, train_labels), (test_data, test_labels) = reuters.load_data(\n",
    "    num_words=10000)\n",
    "# More list arrays. Ugh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.12: Decoding newswires back to text**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "? ? ? said as a result of its december acquisition of space co it expects earnings per share in 1987 of 1 15 to 1 30 dlrs per share up from 70 cts in 1986 the company said pretax net should rise to nine to 10 mln dlrs from six mln dlrs in 1986 and rental operation revenues to 19 to 22 mln dlrs from 12 5 mln dlrs it said cash flow per share this year should be 2 50 to three dlrs reuter 3\n"
     ]
    }
   ],
   "source": [
    "word_index = reuters.get_word_index()\n",
    "reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])\n",
    "decoded_newswire = \" \".join([reverse_word_index.get(i - 3, \"?\") for i in\n",
    "    train_data[0]])\n",
    "print(decoded_newswire)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== train_labels | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (8982,) | nDims: 1 | dtype: int64\n",
      "Content: [ 3  4  3  4  4  4  4  3  3 16  3  3  4  4 19  8 16  3  3 21]\n",
      "... (showing only the first 20 elements)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "tensor_toolbox.tensor_info(train_labels, \"train_labels\", image=False)\n",
    "# Each category corresponds to a newswire topic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Preparing the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.13: Encoding the input data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== x_train | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (8982, 10000) | nDims: 2 | dtype: float64\n",
      "x_train[0]: [0. 1. 1. 0. 1. 1. 1. 1. 1. 1. 1. 1. 1. 0. 0. 1. 1. 1. 0. 1.]\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== x_test | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (2246, 10000) | nDims: 2 | dtype: float64\n",
      "x_test[0]: [0. 1. 1. 0. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 0. 1. 1. 1. 0. 1.]\n",
      "... (showing only the first 20 elements)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_train = vectorize_sequences(train_data) # Same function as we used in the previous case\n",
    "x_test = vectorize_sequences(test_data)\n",
    "tensor_toolbox.tensor_info(x_train, \"x_train\", image=False)\n",
    "tensor_toolbox.tensor_info(x_test, \"x_test\", image=False)\n",
    "# As in the previous case, the concept of order is lost."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.14: Encoding the labels**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== y_train | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (8982, 46) | nDims: 2 | dtype: float64\n",
      "y_train[0]: [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      "... (showing only the first 20 elements)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def to_one_hot(labels, dimension=46): # 46 categories\n",
    "    results = np.zeros((len(labels), dimension))\n",
    "    for i, label in enumerate(labels):\n",
    "        results[i, label] = 1.\n",
    "    return results\n",
    "y_train = to_one_hot(train_labels)\n",
    "y_test = to_one_hot(test_labels)\n",
    "# Gets encoded into a 46-dimensional vector\n",
    "tensor_toolbox.tensor_info(y_train, \"y_train\", image=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== y_train | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (8982, 46) | nDims: 2 | dtype: float32\n",
      "y_train[0]: [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== y_test | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (2246, 46) | nDims: 2 | dtype: float32\n",
      "y_test[0]: [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      "... (showing only the first 20 elements)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.utils import to_categorical\n",
    "y_train = to_categorical(train_labels)\n",
    "y_test = to_categorical(test_labels)\n",
    "tensor_toolbox.tensor_info(y_train, \"y_train\", image=False)\n",
    "tensor_toolbox.tensor_info(y_test, \"y_test\", image=False)\n",
    "# Scikit-learn has a similar function called LabelEncoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Building your model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.15: Model definition**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_2\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense_21 (Dense)            (512, 64)                 640064    \n",
      "                                                                 \n",
      " dense_22 (Dense)            (512, 64)                 4160      \n",
      "                                                                 \n",
      " dense_23 (Dense)            (512, 46)                 2990      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 647214 (2.47 MB)\n",
      "Trainable params: 647214 (2.47 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = keras.Sequential([\n",
    "    layers.Dense(64, activation=\"relu\"),\n",
    "    layers.Dense(64, activation=\"relu\"),\n",
    "    layers.Dense(46, activation=\"softmax\")\n",
    "])\n",
    "model.build(input_shape=(512, 10000))\n",
    "model.summary() # That's some parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch import nn\n",
    "import torch.nn.functional as F # Contains the softmax function\n",
    "\n",
    "class TorchModel (nn.Module):\n",
    "    def __init__(self):\n",
    "        super(TorchModel, self).__init__()\n",
    "        # Using LazyLinears again. I could explicitly define the size.\n",
    "        self.fc1 = nn.LazyLinear(64)\n",
    "        self.fc2 = nn.Linear(64, 64)\n",
    "        self.fc3 = nn.Linear(64, 46)\n",
    "\n",
    "    def forward(self, X):\n",
    "        X = torch.relu(self.fc1(X))\n",
    "        X = torch.relu(self.fc2(X))\n",
    "        return self.fc3(X) # No activation function here!\n",
    "        # CrossEntropyLoss in PyTorch expects raw logits, not probabilities.\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "            Linear-1              [-1, 512, 64]         640,064\n",
      "            Linear-2              [-1, 512, 64]           4,160\n",
      "            Linear-3              [-1, 512, 46]           2,990\n",
      "================================================================\n",
      "Total params: 647,214\n",
      "Trainable params: 647,214\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 19.53\n",
      "Forward/backward pass size (MB): 0.68\n",
      "Params size (MB): 2.47\n",
      "Estimated Total Size (MB): 22.68\n",
      "----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "torchmodel = TorchModel()\n",
    "# This is pretty nice.\n",
    "from torchsummary import summary\n",
    "summary(torchmodel, input_size=(512, 10000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.16: Compiling the model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "model.compile(optimizer=\"rmsprop\",\n",
    "              loss=\"categorical_crossentropy\",\n",
    "              metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# RMSprop, as in Keras.\n",
    "# When you pass it model.parameters(), it gets the reference and knows\n",
    "# how to update them. It's very cool. I'm such a fan of PyTorch.\n",
    "\n",
    "optimizer = torch.optim.RMSprop(torchmodel.parameters())\n",
    "loss_fn = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "def torchtrain(train_dataloader, model, loss_fn, optimizer):\n",
    "    model.train() # We're training you!\n",
    "    total_loss = 0.0\n",
    "    correct = 0\n",
    "    samples = 0\n",
    "\n",
    "    for X, y in train_dataloader:\n",
    "        y_hat = model(X)\n",
    "        loss = loss_fn(y_hat, y)\n",
    "\n",
    "        # Backprop\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # Multiply by the batch size to get the total loss\n",
    "        total_loss += loss.item()*len(y)\n",
    "\n",
    "        predicted_labels = torch.argmax(y_hat, dim=1)\n",
    "        true_labels = torch.argmax(y, dim=1)\n",
    "        correct += (predicted_labels == true_labels).sum().item()\n",
    "        samples += len(y)\n",
    "\n",
    "    avg_loss = total_loss / len(train_dataloader.dataset)\n",
    "    return avg_loss, correct / samples\n",
    "\n",
    "def torchtest(test_dataloader, model, loss_fn):\n",
    "    model.eval()\n",
    "    total_loss = 0.0\n",
    "    correct = 0\n",
    "    samples = 0\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for X, y in test_dataloader:\n",
    "            y_hat = model(X)\n",
    "            loss = loss_fn(y_hat, y)\n",
    "\n",
    "            total_loss += loss.item()*len(y)\n",
    "\n",
    "            predicted_labels = torch.argmax(y_hat, dim=1)\n",
    "            true_labels = torch.argmax(y, dim=1)\n",
    "            correct += (predicted_labels == true_labels).sum().item()\n",
    "            samples += len(y)\n",
    "            \n",
    "    avg_loss = total_loss / len(test_dataloader.dataset)\n",
    "    return avg_loss, correct / samples\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Validating your approach"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.17: Setting aside a validation set**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "x_val = x_train[:1000]\n",
    "partial_x_train = x_train[1000:]\n",
    "y_val = y_train[:1000]\n",
    "partial_y_train = y_train[1000:]\n",
    "# With sklearn:\n",
    "partial_x_train, x_val, partial_y_train, y_val = train_test_split(x_train, y_train,\n",
    "                                                  test_size=1000)\n",
    "# I'm not a big fan of the names, but it's aight."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DataLoaders for torch:\n",
    "train_dataloader = tensor_toolbox.make_dataloader([partial_x_train], [partial_y_train], batch_size=512, shuffle=False)\n",
    "val_dataloader = tensor_toolbox.make_dataloader([x_val], [y_val], batch_size=512, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Annex: Propagations in PyTorch, Categorical Cross Entropy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== first_batch_input | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512, 10000]) | nDims: 2 | dtype: torch.float32\n",
      "first_batch_input[0]: tensor([0., 1., 1., 0., 1., 1., 1., 1., 1., 1., 1., 0., 1., 0., 0., 1., 1., 1.,\n",
      "        0., 1.])\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== first_batch_labels | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512, 46]) | nDims: 2 | dtype: torch.float32\n",
      "first_batch_labels[0]: tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.,\n",
      "        0., 0.])\n",
      "... (showing only the first 20 elements)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "first_batch = next(iter(train_dataloader))\n",
    "first_batch_input = first_batch[0]\n",
    "first_batch_labels = first_batch[1]\n",
    "tensor_toolbox.tensor_info(first_batch_input, \"first_batch_input\", image=False)\n",
    "tensor_toolbox.tensor_info(first_batch_labels, \"first_batch_labels\", image=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== first_batch_output | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512, 46]) | nDims: 2 | dtype: torch.float32\n",
      "first_batch_output[0]: tensor([-0.0330,  0.0141, -0.0363, -0.0935,  0.0777,  0.0345, -0.1060,  0.0954,\n",
      "         0.0395, -0.0352, -0.0505, -0.0564,  0.0986, -0.0312,  0.1129, -0.0201,\n",
      "        -0.0483, -0.0628, -0.0662, -0.0592], grad_fn=<SliceBackward0>)\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== first_batch_loss | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([]) | nDims: 0 | dtype: torch.float32\n",
      "Content: 3.8667898178100586\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/alemalvarez/code-workspace/dl-with-python-pytorch/tensor_toolbox.py:89: UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the .grad field to be populated for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/build/aten/src/ATen/core/TensorBody.h:494.)\n",
      "  if(tensor.requires_grad and tensor.grad is not None):\n"
     ]
    }
   ],
   "source": [
    "first_batch_output = torchmodel(first_batch_input)\n",
    "tensor_toolbox.tensor_info(first_batch_output, \"first_batch_output\", image=False)\n",
    "first_batch_loss = loss_fn(first_batch_output, first_batch_labels)\n",
    "# Average loss over the batch\n",
    "tensor_toolbox.tensor_info(first_batch_loss, \"first_batch_loss\", image=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== first_batch_predictions | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512]) | nDims: 1 | dtype: torch.int64\n",
      "Content: tensor([24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n",
      "        24, 24])\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== first_batch_true | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([512]) | nDims: 1 | dtype: torch.int64\n",
      "Content: tensor([11,  3,  9, 20, 30,  4,  3,  3,  6, 11,  3, 19,  4,  4,  0,  4, 16,  3,\n",
      "         3,  4])\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== first_batch_correct | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([]) | nDims: 0 | dtype: torch.int64\n",
      "Content: 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Let's compute the predictions to get the accuracy\n",
    "first_batch_predictions = torch.argmax(first_batch_output, dim=1)\n",
    "first_batch_true = torch.argmax(first_batch_labels, dim=1)\n",
    "tensor_toolbox.tensor_info(first_batch_predictions, \"first_batch_predictions\", image=False)\n",
    "tensor_toolbox.tensor_info(first_batch_true, \"first_batch_true\", image=False)\n",
    "first_batch_correct = (first_batch_predictions == first_batch_true).sum()\n",
    "tensor_toolbox.tensor_info(first_batch_correct, \"first_batch_correct\", image=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.18: Training the model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "48d7c98adb0646138f3ab4058627caab",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0epoch [00:00, ?epoch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0cc9550aed594ff39ca8a7423bc7fbfc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0batch [00:00, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tqdm.keras import TqdmCallback\n",
    "history = model.fit(partial_x_train,\n",
    "                    partial_y_train,\n",
    "                    epochs=20,\n",
    "                    batch_size=512,\n",
    "                    validation_data=(x_val, y_val),\n",
    "                    callbacks=[TqdmCallback(verbose=1)],\n",
    "                    verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/30\n",
      "Train -- Accuracy: 0.45088950137810074 | Loss: 3.2757529844409747\n",
      "Validation -- Accuracy: 0.616 | Loss: 1.5371240644454955\n",
      "Epoch 2/30\n",
      "Train -- Accuracy: 0.6738912553244801 | Loss: 1.3459112854178343\n",
      "Validation -- Accuracy: 0.718 | Loss: 1.159098328590393\n",
      "Epoch 3/30\n",
      "Train -- Accuracy: 0.7562014532698572 | Loss: 0.9194483238932065\n",
      "Validation -- Accuracy: 0.752 | Loss: 1.031409791469574\n",
      "Epoch 4/30\n",
      "Train -- Accuracy: 0.8074417439238286 | Loss: 0.6809300561352679\n",
      "Validation -- Accuracy: 0.761 | Loss: 0.9957971019744873\n",
      "Epoch 5/30\n",
      "Train -- Accuracy: 0.8480330744174392 | Loss: 0.5343751083098984\n",
      "Validation -- Accuracy: 0.775 | Loss: 1.0000587120056152\n",
      "Epoch 6/30\n",
      "Train -- Accuracy: 0.8833625657729892 | Loss: 0.4113566933553997\n",
      "Validation -- Accuracy: 0.773 | Loss: 1.0378781266212462\n",
      "Epoch 7/30\n",
      "Train -- Accuracy: 0.9041593585567527 | Loss: 0.33147905753149304\n",
      "Validation -- Accuracy: 0.784 | Loss: 1.0778305649757385\n",
      "Epoch 8/30\n",
      "Train -- Accuracy: 0.9183162114758205 | Loss: 0.28117660756951673\n",
      "Validation -- Accuracy: 0.777 | Loss: 1.1365433311462403\n",
      "Epoch 9/30\n",
      "Train -- Accuracy: 0.9259584064144325 | Loss: 0.2420561331438857\n",
      "Validation -- Accuracy: 0.778 | Loss: 1.1745179920196533\n",
      "Epoch 10/30\n",
      "Train -- Accuracy: 0.9348534201954397 | Loss: 0.2148882062609588\n",
      "Validation -- Accuracy: 0.772 | Loss: 1.2570673456192016\n",
      "Epoch 11/30\n",
      "Train -- Accuracy: 0.9386118767226259 | Loss: 0.18964001272584047\n",
      "Validation -- Accuracy: 0.773 | Loss: 1.2591029014587403\n",
      "Epoch 12/30\n",
      "Train -- Accuracy: 0.9416186419443748 | Loss: 0.17846623571802875\n",
      "Validation -- Accuracy: 0.766 | Loss: 1.3049712009429932\n",
      "Epoch 13/30\n",
      "Train -- Accuracy: 0.9424956151340517 | Loss: 0.17089994864240082\n",
      "Validation -- Accuracy: 0.764 | Loss: 1.3462838821411134\n",
      "Epoch 14/30\n",
      "Train -- Accuracy: 0.9432473064394888 | Loss: 0.16133201213199314\n",
      "Validation -- Accuracy: 0.762 | Loss: 1.3499713153839112\n",
      "Epoch 15/30\n",
      "Train -- Accuracy: 0.9457529441242797 | Loss: 0.14920375175798367\n",
      "Validation -- Accuracy: 0.767 | Loss: 1.4100292835235595\n",
      "Epoch 16/30\n",
      "Train -- Accuracy: 0.9466299173139564 | Loss: 0.1455953541598921\n",
      "Validation -- Accuracy: 0.762 | Loss: 1.4403559818267822\n",
      "Epoch 17/30\n",
      "Train -- Accuracy: 0.947005762966675 | Loss: 0.1398484362408321\n",
      "Validation -- Accuracy: 0.761 | Loss: 1.4474716863632202\n",
      "Epoch 18/30\n",
      "Train -- Accuracy: 0.9477574542721122 | Loss: 0.13269238547704118\n",
      "Validation -- Accuracy: 0.761 | Loss: 1.4996321382522584\n",
      "Epoch 19/30\n",
      "Train -- Accuracy: 0.9507642194938611 | Loss: 0.1315322524621295\n",
      "Validation -- Accuracy: 0.767 | Loss: 1.4743233423233033\n",
      "Epoch 20/30\n",
      "Train -- Accuracy: 0.9502630919569031 | Loss: 0.124235130428327\n",
      "Validation -- Accuracy: 0.753 | Loss: 1.5869171695709228\n",
      "Epoch 21/30\n",
      "Train -- Accuracy: 0.9501378100726635 | Loss: 0.12592791680613427\n",
      "Validation -- Accuracy: 0.765 | Loss: 1.527007019996643\n",
      "Epoch 22/30\n",
      "Train -- Accuracy: 0.9507642194938611 | Loss: 0.11779000159643312\n",
      "Validation -- Accuracy: 0.763 | Loss: 1.5676482915878296\n",
      "Epoch 23/30\n",
      "Train -- Accuracy: 0.951641192683538 | Loss: 0.11672341703166343\n",
      "Validation -- Accuracy: 0.755 | Loss: 1.6372773571014405\n",
      "Epoch 24/30\n",
      "Train -- Accuracy: 0.9505136557253822 | Loss: 0.12390478802329166\n",
      "Validation -- Accuracy: 0.755 | Loss: 1.6583565893173218\n",
      "Epoch 25/30\n",
      "Train -- Accuracy: 0.9506389376096217 | Loss: 0.119169109863346\n",
      "Validation -- Accuracy: 0.757 | Loss: 1.6326056747436524\n",
      "Epoch 26/30\n",
      "Train -- Accuracy: 0.950012528188424 | Loss: 0.11725323316642319\n",
      "Validation -- Accuracy: 0.762 | Loss: 1.6316089992523193\n",
      "Epoch 27/30\n",
      "Train -- Accuracy: 0.9493861187672262 | Loss: 0.11431924778659133\n",
      "Validation -- Accuracy: 0.758 | Loss: 1.6812825756072998\n",
      "Epoch 28/30\n",
      "Train -- Accuracy: 0.9505136557253822 | Loss: 0.11208645964894967\n",
      "Validation -- Accuracy: 0.758 | Loss: 1.6615186805725097\n",
      "Epoch 29/30\n",
      "Train -- Accuracy: 0.9506389376096217 | Loss: 0.11546635008140543\n",
      "Validation -- Accuracy: 0.756 | Loss: 1.6844655961990356\n",
      "Epoch 30/30\n",
      "Train -- Accuracy: 0.9507642194938611 | Loss: 0.11499383771174596\n",
      "Validation -- Accuracy: 0.759 | Loss: 1.8689655342102052\n"
     ]
    }
   ],
   "source": [
    "epochs = 30\n",
    "for epoch in range(1, epochs+1):\n",
    "    print(f\"Epoch {epoch}/{epochs}\")\n",
    "    loss, accu = torchtrain(train_dataloader, torchmodel, loss_fn, optimizer)\n",
    "    print(f\"Train -- Accuracy: {accu} | Loss: {loss}\")\n",
    "    loss, accu = torchtest(val_dataloader, torchmodel, loss_fn)\n",
    "    print(f\"Validation -- Accuracy: {accu} | Loss: {loss}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.19: Plotting the training and validation loss**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x500 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tensor_toolbox.draw_training_history(history=history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "loss = history.history[\"loss\"]\n",
    "val_loss = history.history[\"val_loss\"]\n",
    "epochs = range(1, len(loss) + 1)\n",
    "plt.plot(epochs, loss, \"bo\", label=\"Training loss\")\n",
    "plt.plot(epochs, val_loss, \"b\", label=\"Validation loss\")\n",
    "plt.title(\"Training and validation loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.20: Plotting the training and validation accuracy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.clf()\n",
    "acc = history.history[\"accuracy\"]\n",
    "val_acc = history.history[\"val_accuracy\"]\n",
    "plt.plot(epochs, acc, \"bo\", label=\"Training accuracy\")\n",
    "plt.plot(epochs, val_acc, \"b\", label=\"Validation accuracy\")\n",
    "plt.title(\"Training and validation accuracy\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.21: Retraining a model from scratch**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3425f3948141472c9fad63aaffbc9a76",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0epoch [00:00, ?epoch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3aab9f4cb4014ccd94f75bfc8d0997ae",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0batch [00:00, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "71/71 [==============================] - 0s 689us/step - loss: 0.9499 - accuracy: 0.7921\n"
     ]
    }
   ],
   "source": [
    "model = keras.Sequential([\n",
    "  layers.Dense(64, activation=\"relu\"),\n",
    "  layers.Dense(64, activation=\"relu\"),\n",
    "  layers.Dense(46, activation=\"softmax\")\n",
    "])\n",
    "model.compile(optimizer=\"rmsprop\",\n",
    "              loss=\"categorical_crossentropy\",\n",
    "              metrics=[\"accuracy\"])\n",
    "model.fit(x_train, # This x_train contains both the training and the validation sets. That's \n",
    "          # kind of annoying in my opinion.\n",
    "          y_train,\n",
    "          epochs=9,\n",
    "          batch_size=512,\n",
    "          callbacks=[TqdmCallback(verbose=1)],\n",
    "          verbose=0)\n",
    "results = model.evaluate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/29\n",
      "Train -- Accuracy: 0.4704965486528613 | Loss: 3.156462012354448\n",
      "Epoch 2/29\n",
      "Train -- Accuracy: 0.6490759296370519 | Loss: 1.4295636198882191\n",
      "Epoch 3/29\n",
      "Train -- Accuracy: 0.7302382542863505 | Loss: 1.0435373346329373\n",
      "Epoch 4/29\n",
      "Train -- Accuracy: 0.7822311289245157 | Loss: 0.788783430044488\n",
      "Epoch 5/29\n",
      "Train -- Accuracy: 0.8217546203518148 | Loss: 0.6262870995073588\n",
      "Epoch 6/29\n",
      "Train -- Accuracy: 0.8482520596749054 | Loss: 0.518345636179813\n",
      "Epoch 7/29\n",
      "Train -- Accuracy: 0.8712981518592741 | Loss: 0.43397038373403524\n",
      "Epoch 8/29\n",
      "Train -- Accuracy: 0.8950122467156535 | Loss: 0.36147702219384836\n",
      "Epoch 9/29\n",
      "Train -- Accuracy: 0.9092629703852149 | Loss: 0.3067728398378961\n",
      "Epoch 10/29\n",
      "Train -- Accuracy: 0.9209530171454019 | Loss: 0.2680167863918981\n",
      "Epoch 11/29\n",
      "Train -- Accuracy: 0.9269650411934981 | Loss: 0.23946823856594887\n",
      "Epoch 12/29\n",
      "Train -- Accuracy: 0.9295257181028724 | Loss: 0.22125512987965865\n",
      "Epoch 13/29\n",
      "Train -- Accuracy: 0.9343130705856156 | Loss: 0.2049239412882471\n",
      "Epoch 14/29\n",
      "Train -- Accuracy: 0.93687374749499 | Loss: 0.19412451504373623\n",
      "Epoch 15/29\n",
      "Train -- Accuracy: 0.9387664217323536 | Loss: 0.18668415044369874\n",
      "Epoch 16/29\n",
      "Train -- Accuracy: 0.9406590959697172 | Loss: 0.1728259964257751\n",
      "Epoch 17/29\n",
      "Train -- Accuracy: 0.9441104431084391 | Loss: 0.16398812522869072\n",
      "Epoch 18/29\n",
      "Train -- Accuracy: 0.9442217768871075 | Loss: 0.15231644494267832\n",
      "Epoch 19/29\n",
      "Train -- Accuracy: 0.9448897795591182 | Loss: 0.14636751738476664\n",
      "Epoch 20/29\n",
      "Train -- Accuracy: 0.9460031173458027 | Loss: 0.14181582677128107\n",
      "Epoch 21/29\n",
      "Train -- Accuracy: 0.94978846582053 | Loss: 0.1335599577272955\n",
      "Epoch 22/29\n",
      "Train -- Accuracy: 0.9472277889111557 | Loss: 0.1378383017633466\n",
      "Epoch 23/29\n",
      "Train -- Accuracy: 0.948563794255177 | Loss: 0.13617574766716242\n",
      "Epoch 24/29\n",
      "Train -- Accuracy: 0.9482297929191716 | Loss: 0.13240363534296895\n",
      "Epoch 25/29\n",
      "Train -- Accuracy: 0.9474504564684926 | Loss: 0.12773349653722926\n",
      "Epoch 26/29\n",
      "Train -- Accuracy: 0.8910042306835894 | Loss: 0.4479529707545534\n",
      "Epoch 27/29\n",
      "Train -- Accuracy: 0.9425517702070808 | Loss: 0.17717275868888105\n",
      "Epoch 28/29\n",
      "Train -- Accuracy: 0.9487864618125139 | Loss: 0.13176558256909116\n",
      "Epoch 29/29\n",
      "Train -- Accuracy: 0.9483411266978401 | Loss: 0.11753940489371247\n",
      "Test -- Accuracy: 0.7724844167408726 | Loss: 1.8727452016152766\n"
     ]
    }
   ],
   "source": [
    "test_dataloader = tensor_toolbox.make_dataloader([x_test], [y_test], batch_size=512, shuffle=False)\n",
    "train_dataloader = tensor_toolbox.make_dataloader([x_train], [y_train], batch_size=512, shuffle=False)\n",
    "\n",
    "epochs = 29\n",
    "\n",
    "torchmodel = TorchModel()\n",
    "optimizer = torch.optim.RMSprop(torchmodel.parameters())\n",
    "loss_fn = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "for epoch in range(1, epochs+1):\n",
    "    print(f\"Epoch {epoch}/{epochs}\")\n",
    "    loss, accu = torchtrain(train_dataloader, torchmodel, loss_fn, optimizer)\n",
    "    print(f\"Train -- Accuracy: {accu} | Loss: {loss}\")\n",
    "\n",
    "loss, accu = torchtest(test_dataloader, torchmodel, loss_fn)\n",
    "print(f\"Test -- Accuracy: {accu} | Loss: {loss}\")\n",
    "# This time is slightly worse than in Keras. That bugs me, to be honest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.20391807658058772"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Random classifier. What he doesn't take into account is that a dummy classifier would\n",
    "# pick the most common class!\n",
    "import copy\n",
    "test_labels_copy = copy.copy(test_labels)\n",
    "np.random.shuffle(test_labels_copy)\n",
    "hits_array = np.array(test_labels) == np.array(test_labels_copy)\n",
    "hits_array.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3619768477292965"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Count the appearances of each category in test_labels\n",
    "from collections import Counter\n",
    "counter = Counter(test_labels)\n",
    "# Get the most common category\n",
    "most_common = counter.most_common(1)[0][0]\n",
    "# Get the accuracy of the dummy classifier\n",
    "accuracy = counter[most_common] / len(test_labels)\n",
    "accuracy\n",
    "# Yea, that's the true baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Generating predictions on new data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "71/71 [==============================] - 0s 674us/step\n"
     ]
    }
   ],
   "source": [
    "keras_predictions = model.predict(x_test)\n",
    "# Outputs have to be manually softmaxed in PyTorch if we want probabilities!\n",
    "torch_predictions = F.softmax(torchmodel(torch.Tensor(x_test)), dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== Keras predictions | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (2246, 46) | nDims: 2 | dtype: float32\n",
      "Keras predictions[0]: [3.05482332e-04 8.83252709e-04 3.83642793e-04 5.06331503e-01\n",
      " 4.17933196e-01 1.64827972e-04 7.35281676e-04 5.84057489e-05\n",
      " 1.78112090e-02 7.95358937e-05 1.20434415e-04 2.63445615e-03\n",
      " 1.13746864e-04 4.77247231e-04 1.93948654e-04 6.60627629e-05\n",
      " 5.66274254e-03 7.06405437e-04 1.19955512e-03 1.48347870e-03]\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== Torch predictions | tensor_info ====================\n",
      "Type: <class 'torch.Tensor'>\n",
      "Shape: torch.Size([2246, 46]) | nDims: 2 | dtype: torch.float32\n",
      "Torch predictions[0]: tensor([1.6485e-08, 1.4096e-08, 5.1989e-23, 9.9924e-01, 1.5010e-04, 9.3706e-20,\n",
      "        4.4912e-07, 1.5329e-08, 2.0549e-04, 4.6941e-08, 8.0897e-09, 2.7036e-05,\n",
      "        5.5732e-06, 1.2307e-10, 4.9102e-18, 3.1651e-19, 1.1472e-07, 1.3769e-13,\n",
      "        3.1764e-09, 1.9321e-06], grad_fn=<SliceBackward0>)\n",
      "... (showing only the first 20 elements)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "tensor_toolbox.tensor_info(keras_predictions, \"Keras predictions\", image=False)\n",
    "tensor_toolbox.tensor_info(torch_predictions, \"Torch predictions\", image=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(keras_predictions[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0000001"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# As expected, the sum of the probabilities is 1.\n",
    "np.sum(torch_predictions[0].detach().numpy())   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "newswire_index = 789"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'? control data corp the computer concern is introducing its first department computer the ? 180 model 930 which will integrate a computer network starting with ? computers through its mainframe line to the supercomputer for control data it signals our intent to compete in our marketplace more completely than ever before said ? williams control ? vice president of computer systems one of six business units the large minneapolis based computer concern hit hard after two years of huge losses has said it anticipates a profitable year ahead but ? computer business has not been profitable since 1983 last year the company lost 264 5 mln dlrs including a fourth quarter restructuring charge of 139 9 mln dlrs and a one time loss of 69 mln dlrs we will use the 930 ? not only to ? and expand relationships with existing ? customers but also to create new sales opportunities for the corporation with businesses large and small said williams reuter 3'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label_names = keras.datasets.reuters.get_label_names()\n",
    "decoded_newswire = \" \".join([reverse_word_index.get(i - 3, \"?\") for i in\n",
    "    test_data[newswire_index]])\n",
    "decoded_newswire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keras prediction: earn\n",
      "Torch prediction: earn\n",
      "True label: earn\n"
     ]
    }
   ],
   "source": [
    "print(f\"Keras prediction: {label_names[np.argmax(keras_predictions[newswire_index])]}\")\n",
    "print(f\"Torch prediction: {label_names[torch.argmax(torch_predictions[newswire_index])]}\")\n",
    "print(f\"True label: {label_names[np.argmax(y_test[newswire_index])]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### A different way to handle the labels and the loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "model.compile(optimizer=\"rmsprop\",\n",
    "              loss=\"sparse_categorical_crossentropy\",\n",
    "              metrics=[\"accuracy\"])\n",
    "# PyTorch CrossEntropyLoss already acceps the labels as integers. \n",
    "# I could make a PyTorch model that accepts the one-hot encoded labels, but\n",
    "# I would have to redo the training function and I don't have time. Let's move forward."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== train labels | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (8982,) | nDims: 1 | dtype: int64\n",
      "Content: [ 3  4  3  4  4  4  4  3  3 16  3  3  4  4 19  8 16  3  3 21]\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== test labels | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (2246,) | nDims: 1 | dtype: int64\n",
      "Content: [ 3 10  1  4  4  3  3  3  3  3  5  4  1  3  1 11 23  3 19  3]\n",
      "... (showing only the first 20 elements)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "tensor_toolbox.tensor_info(train_labels, \"train labels\")\n",
    "tensor_toolbox.tensor_info(test_labels, \"test labels\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### The importance of having sufficiently large intermediate layers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**A model with an information bottleneck**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "63/63 [==============================] - 1s 6ms/step - loss: 3.4940 - accuracy: 0.3280 - val_loss: 3.0917 - val_accuracy: 0.2980\n",
      "Epoch 2/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 2.8205 - accuracy: 0.2985 - val_loss: 2.6995 - val_accuracy: 0.2910\n",
      "Epoch 3/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 2.4419 - accuracy: 0.3125 - val_loss: 2.3954 - val_accuracy: 0.3020\n",
      "Epoch 4/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 2.0553 - accuracy: 0.3369 - val_loss: 1.9594 - val_accuracy: 0.5110\n",
      "Epoch 5/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 1.5134 - accuracy: 0.6581 - val_loss: 1.4850 - val_accuracy: 0.6420\n",
      "Epoch 6/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 1.1994 - accuracy: 0.7020 - val_loss: 1.3604 - val_accuracy: 0.6800\n",
      "Epoch 7/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 1.0624 - accuracy: 0.7383 - val_loss: 1.2987 - val_accuracy: 0.6980\n",
      "Epoch 8/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.9569 - accuracy: 0.7577 - val_loss: 1.2676 - val_accuracy: 0.7070\n",
      "Epoch 9/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.8727 - accuracy: 0.7750 - val_loss: 1.2576 - val_accuracy: 0.7120\n",
      "Epoch 10/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.8047 - accuracy: 0.7914 - val_loss: 1.2987 - val_accuracy: 0.7070\n",
      "Epoch 11/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.7461 - accuracy: 0.8061 - val_loss: 1.2892 - val_accuracy: 0.7120\n",
      "Epoch 12/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.6976 - accuracy: 0.8175 - val_loss: 1.3081 - val_accuracy: 0.7010\n",
      "Epoch 13/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.6531 - accuracy: 0.8262 - val_loss: 1.3908 - val_accuracy: 0.7090\n",
      "Epoch 14/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.6143 - accuracy: 0.8373 - val_loss: 1.3607 - val_accuracy: 0.7100\n",
      "Epoch 15/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.5840 - accuracy: 0.8394 - val_loss: 1.4076 - val_accuracy: 0.7210\n",
      "Epoch 16/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.5533 - accuracy: 0.8478 - val_loss: 1.4607 - val_accuracy: 0.7130\n",
      "Epoch 17/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.5271 - accuracy: 0.8543 - val_loss: 1.4725 - val_accuracy: 0.7150\n",
      "Epoch 18/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.4998 - accuracy: 0.8576 - val_loss: 1.5295 - val_accuracy: 0.7120\n",
      "Epoch 19/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.4814 - accuracy: 0.8653 - val_loss: 1.5574 - val_accuracy: 0.7070\n",
      "Epoch 20/20\n",
      "63/63 [==============================] - 0s 4ms/step - loss: 0.4602 - accuracy: 0.8732 - val_loss: 1.5976 - val_accuracy: 0.7120\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.History at 0x3567bd9d0>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = keras.Sequential([\n",
    "    layers.Dense(64, activation=\"relu\"),\n",
    "    layers.Dense(4, activation=\"relu\"),\n",
    "    layers.Dense(46, activation=\"softmax\")\n",
    "])\n",
    "model.compile(optimizer=\"rmsprop\",\n",
    "              loss=\"categorical_crossentropy\",\n",
    "              metrics=[\"accuracy\"])\n",
    "model.fit(partial_x_train,\n",
    "          partial_y_train,\n",
    "          epochs=20,\n",
    "          batch_size=128,\n",
    "          validation_data=(x_val, y_val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Further experiments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Wrapping up"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "## Predicting house prices: A regression example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### The Boston Housing Price dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.23: Loading the Boston housing dataset**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "from tensorflow.keras.datasets import boston_housing\n",
    "(train_data, train_targets), (test_data, test_targets) = boston_housing.load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================== train_data | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (404, 13) | nDims: 2 | dtype: float64\n",
      "train_data[0]: [  1.23247   0.        8.14      0.        0.538     6.142    91.7\n",
      "   3.9769    4.      307.       21.      396.9      18.72   ]\n",
      "\n",
      "==================== train_targets | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (404,) | nDims: 1 | dtype: float64\n",
      "Content: [15.2 42.3 50.  21.1 17.7 18.5 11.3 15.6 15.6 14.4 12.1 17.9 23.1 19.9\n",
      " 15.7  8.8 50.  22.5 24.1 27.5]\n",
      "... (showing only the first 20 elements)\n",
      "\n",
      "==================== test_data | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (102, 13) | nDims: 2 | dtype: float64\n",
      "test_data[0]: [ 18.0846   0.      18.1      0.       0.679    6.434  100.       1.8347\n",
      "  24.     666.      20.2     27.25    29.05  ]\n",
      "\n",
      "==================== test_targets | tensor_info ====================\n",
      "Type: <class 'numpy.ndarray'>\n",
      "Shape: (102,) | nDims: 1 | dtype: float64\n",
      "Content: [ 7.2 18.8 19.  27.  22.2 24.5 31.2 22.9 20.5 23.2 18.6 14.5 17.8 50.\n",
      " 20.8 24.3 24.2 19.8 19.1 22.7]\n",
      "... (showing only the first 20 elements)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "tensor_toolbox.tensor_info(train_data, \"train_data\", image=False)\n",
    "tensor_toolbox.tensor_info(train_targets, \"train_targets\", image=False)\n",
    "tensor_toolbox.tensor_info(test_data, \"test_data\", image=False)\n",
    "tensor_toolbox.tensor_info(test_targets, \"test_targets\", image=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Preparing the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.24: Normalizing the data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "mean = train_data.mean(axis=0)\n",
    "train_data -= mean\n",
    "std = train_data.std(axis=0)\n",
    "train_data /= std\n",
    "test_data -= mean\n",
    "test_data /= std\n",
    "\n",
    "# Or, in scikit:\n",
    "# from sklearn.preprocessing import StandardScaler\n",
    "# scaler = StandardScaler()\n",
    "# train_data = scaler.fit_transform(train_data)\n",
    "# test_data = scaler.transform(test_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Building your model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.25: Model definition**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "def build_model():\n",
    "    model = keras.Sequential([\n",
    "        layers.Dense(64, activation=\"relu\"),\n",
    "        layers.Dense(64, activation=\"relu\"),\n",
    "        layers.Dense(1)\n",
    "    ])\n",
    "    model.compile(optimizer=\"rmsprop\", loss=\"mse\", metrics=[\"mae\"])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If you think about it, the class-oriented approach of PyTorch has already\n",
    "# the 'model builder' mechanic into it. That's good.\n",
    "class TorchModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(TorchModel, self).__init__()\n",
    "        self.fc1 = nn.LazyLinear(64)\n",
    "        self.fc2 = nn.Linear(64, 64)\n",
    "        self.fc3 = nn.Linear(64, 1)\n",
    "    def forward(self, X):\n",
    "        X = torch.relu(self.fc1(X))\n",
    "        X = torch.relu(self.fc2(X))\n",
    "        return self.fc3(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I'm getting tired of always typing the same thing. I understand why they made Keras.\n",
    "def torchtrain(train_dataloader, model, loss_fn, optimizer):\n",
    "    model.train()\n",
    "    total_loss = 0.0\n",
    "    total_mae = 0.0\n",
    "    samples = 0\n",
    "    for X, y in train_dataloader:\n",
    "        yhat = torch.flatten(model(X))\n",
    "        loss = loss_fn(yhat, y)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        total_loss += loss.item()*len(y)\n",
    "        total_mae += torch.abs(yhat - y).sum().item()\n",
    "        samples += len(y)\n",
    "    avg_loss = total_loss / len(train_dataloader.dataset)\n",
    "    avg_mae = total_mae / len(train_dataloader.dataset)\n",
    "    return avg_loss, avg_mae\n",
    "\n",
    "def torchtest(test_dataloader, model, loss_fn):\n",
    "    model.eval()\n",
    "    total_loss = 0.0\n",
    "    total_mae = 0.0\n",
    "    samples = 0\n",
    "    with torch.no_grad():\n",
    "        for X, y in test_dataloader:\n",
    "            yhat = torch.flatten(model(X))\n",
    "            loss = loss_fn(yhat, y)\n",
    "            total_loss += loss.item()*len(y)\n",
    "            total_mae += torch.abs(yhat - y).sum().item()\n",
    "            samples += len(y)\n",
    "    avg_loss = total_loss / len(test_dataloader.dataset)\n",
    "    avg_mae = total_mae / len(test_dataloader.dataset)\n",
    "    return avg_loss, avg_mae"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Validating your approach using K-fold validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.26: K-fold validation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing fold #0\n",
      "Processing fold #1\n",
      "Processing fold #2\n",
      "Processing fold #3\n"
     ]
    }
   ],
   "source": [
    "k = 4\n",
    "num_val_samples = len(train_data) // k\n",
    "num_epochs = 100\n",
    "all_scores = {\n",
    "    \"keras\": [],\n",
    "    \"torch\": []\n",
    "}\n",
    "\n",
    "for i in range(k):\n",
    "    print(f\"Processing fold #{i}\")\n",
    "    val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]\n",
    "    val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples]\n",
    "    partial_train_data = np.concatenate(\n",
    "        [train_data[:i * num_val_samples],\n",
    "         train_data[(i + 1) * num_val_samples:]],\n",
    "        axis=0)\n",
    "    partial_train_targets = np.concatenate(\n",
    "        [train_targets[:i * num_val_samples],\n",
    "         train_targets[(i + 1) * num_val_samples:]],\n",
    "        axis=0)\n",
    "    \n",
    "    train_dataloader = tensor_toolbox.make_dataloader([partial_train_data], [partial_train_targets], batch_size=16, shuffle=False)\n",
    "    val_dataloader = tensor_toolbox.make_dataloader([val_data], [val_targets], batch_size=16, shuffle=False)\n",
    "\n",
    "    model = build_model()\n",
    "    torchmodel = TorchModel()\n",
    "    optimizer = torch.optim.RMSprop(torchmodel.parameters())\n",
    "    loss_fn = torch.nn.MSELoss()\n",
    "\n",
    "    model.fit(partial_train_data, partial_train_targets,\n",
    "              epochs=num_epochs, batch_size=16, verbose=0)\n",
    "    \n",
    "    for epoch in range(1, num_epochs+1):\n",
    "        torchtrain(train_dataloader, torchmodel, loss_fn, optimizer)\n",
    "\n",
    "    val_mse, val_mae = model.evaluate(val_data, val_targets, verbose=0)\n",
    "    all_scores['keras'].append(val_mae)\n",
    "    val_mse, val_mae = torchtest(val_dataloader, torchmodel, loss_fn)\n",
    "    all_scores['torch'].append(val_mae)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'keras': [1.970288872718811,\n",
       "  2.541607618331909,\n",
       "  2.445826768875122,\n",
       "  2.3189613819122314],\n",
       " 'torch': [2.6588436542171063,\n",
       "  2.596504060348662,\n",
       "  2.6117576750198213,\n",
       "  2.520821996254496]}"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keras score: 2.3191711604595184 PyTorch score: 2.5969818464600216\n"
     ]
    }
   ],
   "source": [
    "print(f\"Keras score: {np.mean(all_scores['keras'])} PyTorch score: {np.mean(all_scores['torch'])}\")\n",
    "# I'm so mad that the scores in PyTorch are always slightly worse. What am I missing?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.27: Saving the validation logs at each fold**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing fold #0\n",
      "Processing fold #1\n",
      "Processing fold #2\n",
      "Processing fold #3\n"
     ]
    }
   ],
   "source": [
    "# This would be a pain in the ass to do in PyTorch, as it lacks the history object. I will eventually try to build\n",
    "# something similar, but my god I don't feel like it.\n",
    "num_epochs = 500\n",
    "all_mae_histories = []\n",
    "for i in range(k):\n",
    "    print(f\"Processing fold #{i}\")\n",
    "    val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]\n",
    "    val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples]\n",
    "    partial_train_data = np.concatenate(\n",
    "        [train_data[:i * num_val_samples],\n",
    "         train_data[(i + 1) * num_val_samples:]],\n",
    "        axis=0)\n",
    "    partial_train_targets = np.concatenate(\n",
    "        [train_targets[:i * num_val_samples],\n",
    "         train_targets[(i + 1) * num_val_samples:]],\n",
    "        axis=0)\n",
    "    model = build_model()\n",
    "    history = model.fit(partial_train_data, partial_train_targets,\n",
    "                        validation_data=(val_data, val_targets),\n",
    "                        epochs=num_epochs, batch_size=16, verbose=0)\n",
    "    mae_history = history.history[\"val_mae\"]\n",
    "    all_mae_histories.append(mae_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.28: Building the history of successive mean K-fold validation scores**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "average_mae_history = [\n",
    "    np.mean([x[i] for x in all_mae_histories]) for i in range(num_epochs)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.29: Plotting validation scores**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "plt.plot(range(1, len(average_mae_history) + 1), average_mae_history)\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Validation MAE\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.30: Plotting validation scores, excluding the first 10 data points**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "truncated_mae_history = average_mae_history[10:]\n",
    "plt.plot(range(1, len(truncated_mae_history) + 1), truncated_mae_history)\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Validation MAE\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "**Listing 4.31: Training the final model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "model = build_model()\n",
    "model.fit(train_data, train_targets,\n",
    "          epochs=130, batch_size=16, verbose=0)\n",
    "test_mse_score, test_mae_score = model.evaluate(test_data, test_targets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "test_mae_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Generating predictions on new data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "predictions = model.predict(test_data)\n",
    "predictions[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Wrapping up"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "## Summary"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "chapter04_getting-started-with-neural-networks.i",
   "private_outputs": false,
   "provenance": [],
   "toc_visible": true
  },
  "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}