notebooks/pytorch_cpp_colab_notebook.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VS2lCrJC55PX"
      },
      "source": [
        "\n",
        "![Pytorch Cpp](https://github.com/prabhuomkar/pytorch-cpp/raw/master/images/pytorch_cpp.png)\n",
        "\n",
        "* **This notebook is intended to be used on [Google Colab](https://colab.research.google.com) ONLY!** \n",
        "* It allows you\n",
        "to build and run the [pytorch-cpp](https://github.com/prabhuomkar/pytorch-cpp) tutorials on a hosted GPU equipped system for free."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2giT9_5csfEP"
      },
      "source": [
        "#Setup\n",
        "1. Switch to a GPU runtime: `Runtime -> Change runtime type -> Hardware accelerator: Select GPU`\n",
        "2. Run each of the following setup cells one after the other."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZTcewDy6cnxQ"
      },
      "source": [
        "##Magics and Imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "s7-GsT7v-TAh"
      },
      "outputs": [],
      "source": [
        "# For nicer looking images\n",
        "%matplotlib inline\n",
        "%config InlineBackend.figure_format = 'retina'\n",
        "\n",
        "# Python package imports to display images\n",
        "import matplotlib.pyplot as plt\n",
        "from PIL import Image\n",
        "from pathlib import Path\n",
        "from google.colab import widgets\n",
        "from google.colab import output\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "import os"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2ASwLgYo3AkT"
      },
      "outputs": [],
      "source": [
        "# Image plotting helper function\n",
        "def plot_images(file_paths, nrows, ncols, figsize_per_image):\n",
        "    fig, ax = plt.subplots(nrows, ncols, figsize=(figsize_per_image[0] * ncols, figsize_per_image[1] * nrows))\n",
        "\n",
        "    n_files = len(file_paths)\n",
        "\n",
        "    if nrows == 1 or ncols == 1:\n",
        "        for i, image_path in enumerate(file_paths):\n",
        "            ax[i].imshow(Image.open(image_path), aspect=\"equal\")\n",
        "            ax[i].axis(\"off\")\n",
        "            ax[i].set_title(image_path.name)\n",
        "    else:\n",
        "        for i in range(nrows):\n",
        "            for j in range(ncols):\n",
        "                ax[i,j].imshow(Image.open(file_paths[i * ncols + j]), aspect=\"equal\")\n",
        "                ax[i,j].axis(\"off\")\n",
        "                ax[i,j].set_title(file_paths[i * ncols + j].name)\n",
        "    fig.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "# Image captioning helper functions\n",
        "def create_output_datafram(output_path):\n",
        "    output_data = []\n",
        "    for f in output_path.iterdir():\n",
        "        img_name, num, word = f.name.rsplit('_', 2)\n",
        "        word = word.split('.')[0]\n",
        "        output_data.append({\"file\": f, \"image\": img_name, \"num\": int(num), \"word\": word})\n",
        "\n",
        "    df = pd.DataFrame(output_data)\n",
        "\n",
        "    return df.groupby(\"image\").apply(pd.DataFrame.sort_values, 'num')[[\"file\", \"word\"]].groupby(\"image\").agg(list)\n",
        "\n",
        "def create_tab(output_example):\n",
        "    print(f\"Image: {output_example.Index}\")\n",
        "\n",
        "    t = widgets.TabBar(output_example.word)\n",
        "\n",
        "    for i, image_file in enumerate(output_example.file):\n",
        "        with t.output_to(i, select=False):\n",
        "            _, ax = plt.subplots(figsize=(8, 8))\n",
        "            ax.imshow(Image.open(image_file), aspect=\"equal\")\n",
        "            ax.axis(\"off\")\n",
        "            plt.show()\n",
        "\n",
        "def plot_image_caption_output(output_path):\n",
        "    df = create_output_datafram(output_path)\n",
        "    for p, _ in zip(df.itertuples(), widgets.Grid(len(df), 1)):\n",
        "        create_tab(p)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cs1nFZkH59Nb"
      },
      "source": [
        "##Install more recent versions of dependencies and build tools\n",
        "(This takes several minutes)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yS5dYChCtqzP"
      },
      "outputs": [],
      "source": [
        "# Update CUDA \n",
        "!wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/cuda-ubuntu1804.pin\n",
        "!sudo mv cuda-ubuntu1804.pin /etc/apt/preferences.d/cuda-repository-pin-600\n",
        "!wget https://developer.download.nvidia.com/compute/cuda/11.6.0/local_installers/cuda-repo-ubuntu1804-11-6-local_11.6.0-510.39.01-1_amd64.deb\n",
        "!sudo dpkg -i 'cuda-repo-ubuntu1804-11-6-local_11.6.0-510.39.01-1_amd64.deb'\n",
        "!sudo apt-key add /var/cuda-repo-ubuntu1804-11-6-local/7fa2af80.pub\n",
        "!sudo apt-get update\n",
        "!sudo DEBIAN_FRONTEND=noninteractive apt-get -y install cuda-11-6\n",
        "!sudo cp /usr/include/x86_64-linux-gnu/cudnn*.h /usr/local/cuda-11.6/include\n",
        "!sudo cp /usr/lib/x86_64-linux-gnu/libcudnn* /usr/local/cuda-11.6/lib64\n",
        "!sudo chmod a+r /usr/local/cuda-11.6/include/cudnn*.h /usr/local/cuda-11.6/lib64/libcudnn*\n",
        "old_ld_library_path = %env LD_LIBRARY_PATH\n",
        "new_ld_library_path = \"/usr/local/cuda-11.6/lib64:\" + old_ld_library_path\n",
        "%env LD_LIBRARY_PATH={new_ld_library_path}\n",
        "%env CUDA_HOME=/usr/local/cuda-11.6\n",
        "\n",
        "# Update CMake\n",
        "!rm -rf deps\n",
        "!mkdir deps\n",
        "%cd /content/deps\n",
        "!wget --no-check-certificate https://www.cmake.org/files/v3.28/cmake-3.28.6-linux-x86_64.tar.gz\n",
        "!tar -xvf cmake-3.28.6-linux-x86_64.tar.gz > /dev/null\n",
        "%mv cmake-3.28.6-linux-x86_64 cmake-install\n",
        "old_path = %env PATH\n",
        "new_path = \"/content/deps/cmake-install:/content/deps/cmake-install/bin:\" + old_path\n",
        "%env PATH={new_path}\n",
        "%cd /content/\n",
        "!cmake --version\n",
        "\n",
        "# Update g++\n",
        "!sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y\n",
        "!sudo apt-get update\n",
        "!sudo apt-get install gcc-10 g++-10 -y\n",
        "!sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 60 --slave /usr/bin/g++ g++ /usr/bin/g++-10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZCawMy0erYiQ"
      },
      "source": [
        "##Installed Programs & GPU"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pMMGmOVmra8B"
      },
      "outputs": [],
      "source": [
        "%%bash\n",
        "# Preinstalled compiler versions\n",
        "g++ --version\n",
        "gcc --version\n",
        "# Check installed CMake version\n",
        "cmake --version\n",
        "echo \"\"\n",
        "# Preinstalled pytorch/torchvision versions\n",
        "pip show torch\n",
        "echo \"\"\n",
        "pip show torchvision\n",
        "echo \"\"\n",
        "# CUDA Information\n",
        "nvcc --version"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "saxZiiBKsjbj"
      },
      "source": [
        "##Clone Repo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pYr7GTcGsnvx"
      },
      "outputs": [],
      "source": [
        "!git clone https://github.com/prabhuomkar/pytorch-cpp.git\n",
        "%cd /content/pytorch-cpp\n",
        "%ls"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jso4xNoBtRsk"
      },
      "source": [
        "##Generate Build System"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rbeD5lKStWhS"
      },
      "outputs": [],
      "source": [
        "%cd /content/pytorch-cpp\n",
        "%rm -rf build\n",
        "!cmake -B build -D CUDA_V=11.8 -D CMAKE_BUILD_TYPE=Release"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YOqr6Z6Mt5y9"
      },
      "source": [
        "##Build Tutorials"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H-n_1d4Mt8MG"
      },
      "outputs": [],
      "source": [
        "%cd /content/pytorch-cpp\n",
        "!cmake --build build"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YRgm8b_yvZyQ"
      },
      "source": [
        "#Run Tutorials\n",
        "\n",
        "### 1. Basics\n",
        "* [PyTorch Basics](#scrollTo=OVBcBgknvm_W)\n",
        "* [Linear Regression](#scrollTo=eX6YN9DB04r2)\n",
        "* [Logistic Regression](#scrollTo=3rfrwqKU1VZm)\n",
        "* [Feedforward Neural Network](#scrollTo=ywmM2xkt1mi0)\n",
        "\n",
        "### 2. Intermediate\n",
        "* [Convolutional Neural Network](#scrollTo=Convolutional_Neural_Network)\n",
        "* [Deep Residual Network](#scrollTo=Kla2SaVv228f)\n",
        "* [Recurrent Neural Network](#scrollTo=aTrOcUke3Zxu)\n",
        "* [Bidirectional Recurrent Neural Network](#scrollTo=FVVx0XFY3yvU)\n",
        "* [Language Model (RNN-LM)](#scrollTo=gnvBsukO4H00)\n",
        "\n",
        "### 3. Advanced\n",
        "* [Generative Adversarial Networks](#scrollTo=ggBdsvyR8UMN)\n",
        "* [Variational Auto-Encoder](#scrollTo=CYzbCRPo_TJ7)\n",
        "* [Neural Style Transfer](#scrollTo=ix6R5AosZHTx)\n",
        "* [Image Captioning (CNN-RNN)](#scrollTo=aEBcqiKr-5Sb)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VbwYTgxWvfMD"
      },
      "source": [
        "##Basics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "U1S-Iruk0GAB"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/basics/ -1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OVBcBgknvm_W"
      },
      "source": [
        "### Pytorch-Basics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ev7P19zzzRfu"
      },
      "outputs": [],
      "source": [
        "# Create required torchscript module:\n",
        "%cd /content/pytorch-cpp/tutorials/basics/pytorch_basics/model/\n",
        "!python create_resnet18_scriptmodule.py"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Z2pMypzTywYj"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/basics/pytorch_basics/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "l4YOWqn2y_0G"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%cd /content/pytorch-cpp/build/tutorials/basics/pytorch_basics/\n",
        "!./pytorch-basics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eX6YN9DB04r2"
      },
      "source": [
        "###Linear Regression"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BPXFDYqO1DqW"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/basics/linear_regression/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6agvmvVh1J7f"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%cd /content/pytorch-cpp/build/tutorials/basics/linear_regression/\n",
        "!./linear-regression"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3rfrwqKU1VZm"
      },
      "source": [
        "###Logistic Regression"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mIBloL341Yis"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/basics/logistic_regression/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qkKPAWBk1d9V"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%cd /content/pytorch-cpp/build/tutorials/basics/logistic_regression/\n",
        "!./logistic-regression"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ywmM2xkt1mi0"
      },
      "source": [
        "###Feedforward Neural Network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jZsPU07C1p-K"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/basics/feedforward_neural_network/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DAgpSavJ1tjH"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%cd /content/pytorch-cpp/build/tutorials/basics/feedforward_neural_network/\n",
        "!./feedforward-neural-network"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XFVlcoQKvhX3"
      },
      "source": [
        "##Intermediate"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TVcLYosB16Xi"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/intermediate/ -1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "amr2BK2XpJ5j"
      },
      "source": [
        "###Convolutional Neural Network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-ERzOw4F2ap1"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/intermediate/convolutional_neural_network/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PygE27Dq2mUp"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%%time\n",
        "%cd /content/pytorch-cpp/build/tutorials/intermediate/convolutional_neural_network/\n",
        "!./convolutional-neural-network"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kla2SaVv228f"
      },
      "source": [
        "###Deep Residual Network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "grh7dIl-2y_5"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/intermediate/deep_residual_network/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t6sxgY3U28Fj"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%%time\n",
        "%cd /content/pytorch-cpp/build/tutorials/intermediate/deep_residual_network/\n",
        "!./deep-residual-network"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aTrOcUke3Zxu"
      },
      "source": [
        "###Recurrent Neural Network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m2C4zWx_3iyM"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/intermediate/recurrent_neural_network/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xqEYhxql3qKr"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%%time\n",
        "%cd /content/pytorch-cpp/build/tutorials/intermediate/recurrent_neural_network/\n",
        "!./recurrent-neural-network"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FVVx0XFY3yvU"
      },
      "source": [
        "###Bidirectional Recurrent Neural Network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XwKsI8Cc315L"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/intermediate/bidirectional_recurrent_neural_network/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GvZmNxTr34eM"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%%time\n",
        "%cd /content/pytorch-cpp/build/tutorials/intermediate/bidirectional_recurrent_neural_network/\n",
        "!./bidirectional-recurrent-neural-network"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gnvBsukO4H00"
      },
      "source": [
        "###Language Model\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mvKxwskb4K81"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/intermediate/language_model/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RcHpHp3-4OMw"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%%time\n",
        "%cd /content/pytorch-cpp/build/tutorials/intermediate/language_model/\n",
        "!./language-model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "u8sZ3Wk2720U"
      },
      "outputs": [],
      "source": [
        "# Results\n",
        "%cat /content/pytorch-cpp/build/tutorials/intermediate/language_model/output/sample.txt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hJS5K-6rvjkW"
      },
      "source": [
        "##Advanced"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xZKTaitM4e9L"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/advanced/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ggBdsvyR8UMN"
      },
      "source": [
        "###Generative Adversarial Network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t3ehQI_O8bEM"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/advanced/generative_adversarial_network/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xPKI6qSw8n2F"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%%time\n",
        "%cd /content/pytorch-cpp/build/tutorials/advanced/generative_adversarial_network/\n",
        "!./generative-adversarial-network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CQ7Dt6dr9Hug"
      },
      "outputs": [],
      "source": [
        "# Results\n",
        "%ls /content/pytorch-cpp/build/tutorials/advanced/generative_adversarial_network/output/ -1 -r --sort=time | head -10\n",
        "!echo \"...\"\n",
        "%ls /content/pytorch-cpp/build/tutorials/advanced/generative_adversarial_network/output/ -1 -r --sort=time | tail -10"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LDZDvBUALJtw"
      },
      "outputs": [],
      "source": [
        "# Show results:\n",
        "# Get paths of output files sorted by creation time:\n",
        "gan_output_file_paths = sorted(list(Path(\"/content/pytorch-cpp/build/tutorials/advanced/generative_adversarial_network/output\").iterdir()), key=os.path.getmtime)\n",
        "# Select some indices to show\n",
        "gan_display_indices = [0, 1, len(gan_output_file_paths) // 2, len(gan_output_file_paths) - 1]\n",
        "gan_file_paths = [gan_output_file_paths[i] for i in gan_display_indices]\n",
        "\n",
        "plot_images(gan_file_paths, nrows=1, ncols=len(gan_file_paths), figsize_per_image=(5, 5))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CYzbCRPo_TJ7"
      },
      "source": [
        "###Variational Autoencoder"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qP1x5N6PFLw5"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/advanced/variational_autoencoder/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Y2PHWLYVFXR5"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%%time\n",
        "%cd /content/pytorch-cpp/build/tutorials/advanced/variational_autoencoder/\n",
        "!./variational-autoencoder"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "szHaGKCfFsju"
      },
      "outputs": [],
      "source": [
        "# Results\n",
        "%ls /content/pytorch-cpp/build/tutorials/advanced/variational_autoencoder/output/ -1 -r --sort=time | head -10\n",
        "!echo \"...\"\n",
        "%ls /content/pytorch-cpp/build/tutorials/advanced/variational_autoencoder/output/ -1 -r --sort=time | tail -10"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "elkk38xaGJLU"
      },
      "outputs": [],
      "source": [
        "vae_output_file_paths = sorted(list(Path(\"./output\").iterdir()), key=os.path.getmtime)\n",
        "vae_display_indices = [1, 0, len(vae_output_file_paths) // 2, len(vae_output_file_paths) // 2 - 1, len(vae_output_file_paths) - 1, len(vae_output_file_paths) - 2]\n",
        "vae_file_paths = [vae_output_file_paths[i] for i in vae_display_indices]\n",
        "\n",
        "plot_images(vae_file_paths, nrows=len(vae_file_paths) // 2, ncols=2, figsize_per_image=(9, 5))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ix6R5AosZHTx"
      },
      "source": [
        "###Neural Style Transfer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IaEqJbsXZjBD"
      },
      "outputs": [],
      "source": [
        "# Create required torchscript module:\n",
        "%cd /content/pytorch-cpp/tutorials/advanced/neural_style_transfer/model/\n",
        "!python create_vgg19_layers_scriptmodule.py"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "x-oKRmdZZSbz"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/advanced/neural_style_transfer/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bPrnqcFvZXJU"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%%time\n",
        "%cd /content/pytorch-cpp/build/tutorials/advanced/neural_style_transfer/\n",
        "!./neural-style-transfer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Eo8v_9s9eUvR"
      },
      "outputs": [],
      "source": [
        "# Results\n",
        "%ls /content/pytorch-cpp/build/tutorials/advanced/neural_style_transfer/output/ -1 -r --sort=time"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7RW9fPEyfus8"
      },
      "outputs": [],
      "source": [
        "# Inputs\n",
        "%ls /content/pytorch-cpp/data/neural_style_transfer_images/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vSJXkbn2hcgK"
      },
      "outputs": [],
      "source": [
        "nst_input_file_paths = sorted(list(Path(\"/content/pytorch-cpp/data/neural_style_transfer_images\").iterdir()))\n",
        "\n",
        "plot_images(nst_input_file_paths, nrows=1, ncols=len(nst_input_file_paths), figsize_per_image=(8, 5))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Qhyn-FrkekZa"
      },
      "outputs": [],
      "source": [
        "nst_output_file_paths = sorted(list(Path(\"/content/pytorch-cpp/build/tutorials/advanced/neural_style_transfer/output\").iterdir()), key=os.path.getmtime)\n",
        "\n",
        "plot_images(nst_output_file_paths, nrows=len(nst_output_file_paths), ncols=1, figsize_per_image=(7, 5))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aEBcqiKr-5Sb"
      },
      "source": [
        "###Image Captioning"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "s-sgAqiJiGEC"
      },
      "outputs": [],
      "source": [
        "# Create required torchscript module:\n",
        "%cd /content/pytorch-cpp/tutorials/advanced/image_captioning/model/\n",
        "!python create_encoder_cnn_backbone_scriptmodule.py"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VltI7w1tAuJt"
      },
      "outputs": [],
      "source": [
        "%ls /content/pytorch-cpp/build/tutorials/advanced/image_captioning/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "95UQmwSSBA4X"
      },
      "outputs": [],
      "source": [
        "# Show command line arguments:\n",
        "%cd /content/pytorch-cpp/build/tutorials/advanced/image_captioning/\n",
        "!./image-captioning --help"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "APa5ygazA1aw"
      },
      "outputs": [],
      "source": [
        "# Run\n",
        "%%time\n",
        "%cd /content/pytorch-cpp/build/tutorials/advanced/image_captioning/\n",
        "!./image-captioning --batch_size=128 --num_epochs=4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Do8Q7qzxBINd"
      },
      "outputs": [],
      "source": [
        "# Results\n",
        "plot_image_caption_output(Path(\"/content/pytorch-cpp/build/tutorials/advanced/image_captioning/output\"))"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "private_outputs": true,
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}