Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,45 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Downloads/deformation_experiments(1).pptx filter=lfs diff=lfs merge=lfs -text
+Downloads/deformation_experiments(2).pptx filter=lfs diff=lfs merge=lfs -text
+Downloads/deformation_experiments(3).pptx filter=lfs diff=lfs merge=lfs -text
+Downloads/deformation_experiments.pptx filter=lfs diff=lfs merge=lfs -text
+P_1/band6/attempts/attempt_1/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6/attempts/attempt_2/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_144524/attempts/attempt_1/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_144524/attempts/attempt_2/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_144524/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_150549/attempts/attempt_1/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_150549/attempts/attempt_2/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_150549/attempts/attempt_3/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_150549/attempts/attempt_4/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_150549/attempts/attempt_5/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_150549/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_152911/attempts/attempt_1/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_152911/attempts/attempt_2/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_152911/attempts/attempt_3/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_152911/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_153547/attempts/attempt_1/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_153547/attempts/attempt_2/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_153547/attempts/attempt_3/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/band6__20260826_153547/band6.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5/attempts/attempt_1/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5/attempts/attempt_2/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5/attempts/attempt_3/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5__20260826_140014/attempts/attempt_1/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5__20260826_140014/attempts/attempt_2/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5__20260826_140014/attempts/attempt_3/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5__20260826_140014/attempts/attempt_4/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5__20260826_140014/attempts/attempt_5/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5__20260826_140014/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5__20260826_142702/attempts/attempt_1/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5__20260826_142702/attempts/attempt_2/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/basketball5__20260826_142702/basketball5.png filter=lfs diff=lfs merge=lfs -text
+P_1/cat1__20260826_163052/attempts/attempt_1/cat1.png filter=lfs diff=lfs merge=lfs -text
+P_1/cat1__20260826_163052/attempts/attempt_2/cat1.png filter=lfs diff=lfs merge=lfs -text
+P_1/cat1__20260826_163052/attempts/attempt_3/cat1.png filter=lfs diff=lfs merge=lfs -text
+P_1/cat1__20260826_163052/attempts/attempt_4/cat1.png filter=lfs diff=lfs merge=lfs -text
+P_1/cat1__20260826_163052/attempts/attempt_5/cat1.png filter=lfs diff=lfs merge=lfs -text

=0.46.1

@@ -0,0 +1,25 @@
+Requirement already satisfied: bitsandbytes in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (0.50.1)
+Requirement already satisfied: torch<3,>=2.4 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from bitsandbytes) (2.5.1+cu121)
+Requirement already satisfied: numpy>=1.17 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from bitsandbytes) (2.2.6)
+Requirement already satisfied: packaging>=20.9 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from bitsandbytes) (26.0)
+Requirement already satisfied: filelock in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (3.29.0)
+Requirement already satisfied: typing-extensions>=4.8.0 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (4.15.0)
+Requirement already satisfied: networkx in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (3.4.2)
+Requirement already satisfied: jinja2 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (3.1.6)
+Requirement already satisfied: fsspec in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (2026.4.0)
+Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (12.1.105)
+Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (12.1.105)
+Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (12.1.105)
+Requirement already satisfied: nvidia-cudnn-cu12==9.1.0.70 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (9.1.0.70)
+Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (12.1.3.1)
+Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (11.0.2.54)
+Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (10.3.2.106)
+Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (11.4.5.107)
+Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (12.1.0.106)
+Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (2.21.5)
+Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (12.1.105)
+Requirement already satisfied: triton==3.1.0 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (3.1.0)
+Requirement already satisfied: sympy==1.13.1 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from torch<3,>=2.4->bitsandbytes) (1.13.1)
+Requirement already satisfied: nvidia-nvjitlink-cu12 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from nvidia-cusolver-cu12==11.4.5.107->torch<3,>=2.4->bitsandbytes) (12.9.86)
+Requirement already satisfied: mpmath<1.4,>=1.1.0 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from sympy==1.13.1->torch<3,>=2.4->bitsandbytes) (1.3.0)
+Requirement already satisfied: MarkupSafe>=2.0 in /scratch/rk01499/anaconda3/envs/sketch/lib/python3.10/site-packages (from jinja2->torch<3,>=2.4->bitsandbytes) (3.0.3)

Downloads/.ipynb_checkpoints/Convolutional Neural Networks Transfer Learning-checkpoint.ipynb

@@ -0,0 +1,990 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "view-in-github"
+   },
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/AnjanDutta/EEEM068/blob/main/Notebooks/Convolutional_Neural_Networks_Transfer_Learning.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "D_5Tkl9SzhjN",
+    "pycharm": {}
+   },
+   "source": [
+    "<H1 style=\"text-align: center\">EEEM068 - Applied Machine Learning</H1>\n",
+    "<H1 style=\"text-align: center\">Workshop 04</H1>\n",
+    "<H1 style=\"text-align: center\">Convolutional Neural Networks and Transfer Learning Tutorial</H1>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "e8f95r3cyd1S",
+    "pycharm": {}
+   },
+   "source": [
+    "## Introduction\n",
+    "In this tutorial, we will implement a convolutional neural network (CNN) model for classifying natural images. Specifically, we will use the STL-10 dataset for training and testing our model. In this workshop, we will use [PyTorch](https://pytorch.org/) deep learning framework to complete our task."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "LT-4QzaoAxQX",
+    "pycharm": {}
+   },
+   "source": [
+    "## STL-10 Dataset\n",
+    "\n",
+    "The [STL-10 dataset](https://cs.stanford.edu/~acoates/stl10/) is an image recognition dataset for developing supervised and unsupervised deep learning algorithms. It contains 10 classes: airplane, bird, car, cat, deer, dog, horse, monkey, ship, truck, containing 500 training and 800 test images per class. Each image is of size $96 \\times 96$ pixels. More detials on the STL-10 dataset can be found in here: https://cs.stanford.edu/~acoates/stl10\n",
+    "\n",
+    "<img src=\"https://cs.stanford.edu/~acoates/stl10/images.png\"  width=\"400\" height=\"400\">\n",
+    "\n",
+    "Similar to MNIST, since this dataset is already implemented at the torchvision [dataset collections](https://pytorch.org/vision/stable/index.html), we don't have to implement the data generator for this dataset and will utilise the one available from torchvision. However, an example of custon data generator can be found within the transfer learning section of this tutorial."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "YDSiTaVKSXJW"
+   },
+   "source": [
+    "### Dataset and DataLoader"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7Bi1u6k5P9wB"
+   },
+   "source": [
+    "In the following cell, we will be defining datasets and data loaders necessary for our training. Details on datasets and dataloaders can be found in the [documentation](https://pytorch.org/vision/stable/datasets.html)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "C7KkXL5OA8WX",
+    "pycharm": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torchvision\n",
+    "\n",
+    "# Before defining datasets, lets define how images should be transformed. This is \n",
+    "# because the transformations should go with the definitions of datasets. In this\n",
+    "# tutorial we will using simple transformations, such as (1) image to tensor, (2)\n",
+    "# normalization.\n",
+    "image_transform = torchvision.transforms.Compose([\n",
+    "                               torchvision.transforms.ToTensor(),\n",
+    "                               torchvision.transforms.Normalize(\n",
+    "                                 (0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
+    "\n",
+    "# Once we have the transformations defined, lets define the train and test sets\n",
+    "train_dataset = torchvision.datasets.STL10('dataset/', \n",
+    "                                           split='train', \n",
+    "                                           download=True,\n",
+    "                                           transform=image_transform)\n",
+    "test_dataset = torchvision.datasets.STL10('dataset/', \n",
+    "                                          split='test', \n",
+    "                                          download=True,\n",
+    "                                          transform=image_transform)\n",
+    "\n",
+    "# Now, lets define batch size, batch size is how much data you feed for training\n",
+    "# in one iteration\n",
+    "batch_size_train = 256 # We use smaller batch size here for training\n",
+    "batch_size_test = 1024 # We use bigger batch size for testing\n",
+    "\n",
+    "# Once we have the datasets defined, lets define the data loaders as follows\n",
+    "train_loader = torch.utils.data.DataLoader(train_dataset,\n",
+    "                                           batch_size=batch_size_train, \n",
+    "                                           shuffle=True)\n",
+    "test_loader = torch.utils.data.DataLoader(test_dataset,\n",
+    "                                          batch_size=batch_size_test, \n",
+    "                                          shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "WdYlqJ7xDvJa",
+    "pycharm": {}
+   },
+   "source": [
+    "### Example Image\n",
+    "Lets have a look on how images from STL-10 dataset looks like. Since the images are already normalized, their resolutions might have slightly changed. To visualize the original images, we should have ideally apply a reverse transformation which is avoided to keep this tutorial simple and brief."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "U4FrTxdxDwnE",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# import plot library\n",
+    "import matplotlib.pyplot as plt\n",
+    "# iterate the dataloader\n",
+    "_, (example_datas, labels) = next(enumerate(train_loader))\n",
+    "# get the first data\n",
+    "sample = example_datas[0]\n",
+    "# show the data\n",
+    "plt.imshow(sample.permute(1, 2, 0))\n",
+    "print(\"Label: \" + str(labels[0]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MUWGhlsMCYZD",
+    "pycharm": {}
+   },
+   "source": [
+    "## Model\n",
+    "Now, we have to define trainable layers with parameters and put them inside a model. Have a look on the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Module.html#module) of `nn.Module` and read more about different layers and functionalities of PyTorch there. Here we are going to implement various versions of AlexNet model and use it for classification. In this model, we are going to use the following functions or modules:\n",
+    "\n",
+    "* `nn.Conv2d()`: It is a PyTorch module that applies a 2D convolution over an input signal composed of several input planes. More details are available on the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html).\n",
+    "\n",
+    "* `nn.MaxPool2d()`: It is also a module that applies a 2D max pooling over an input signal composed of several input planes. Please have a look on this [documentation](https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html) for more details.\n",
+    "\n",
+    "* `nn.AdaptiveAvgPool2d()`: It is a module that applies a 2D adaptive average pooling over an input signal composed of several input planes. Given an output size, this function automatically select the stride and kernel size to adapt the need of target size. More details on this can be found in the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.AdaptiveAvgPool2d.html).\n",
+    "\n",
+    "* `nn.Sequential()`: It is a sequential container. Modules will be added to it in the order they are passed in the constructor. Please check the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html#torch.nn.Sequential) for more details.\n",
+    "\n",
+    "* `nn.Linear()`: It is a module that applies a linear transformation to the incoming data. More details can be found in its [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html#linear).\n",
+    "\n",
+    "* `nn.ReLU()`: It is also a module that applies element-wise the rectified linear unit function. Its [documentation](https://pytorch.org/docs/stable/generated/torch.nn.ReLU.html#relu) can explain more.\n",
+    "\n",
+    "* `nn.Dropout()`: This module randomly zeroes some of the elements of the input tensor with probability `p`. Check the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Dropout.html#dropout) for more details."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "yjGEol-IX31p"
+   },
+   "source": [
+    "One can define a model in several ways. Below, we show some of them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "LMtPp5OeCakG",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "## We first import the pytorch nn module and optimizer\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import torch.optim as optim\n",
+    "## Below you can see one way of defining the model class, where each individual \n",
+    "## layer is defined as an instance variable.\n",
+    "class AlexNet1(nn.Module):\n",
+    "    def __init__(self, num_classes):\n",
+    "        super(AlexNet1, self).__init__()\n",
+    "        # input channel 3, output channel 64\n",
+    "        self.conv1 = nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2)\n",
+    "        # relu non-linearity\n",
+    "        self.relu1 = nn.ReLU()\n",
+    "        # max pooling\n",
+    "        self.max_pool2d1 = nn.MaxPool2d(kernel_size=3, stride=2)\n",
+    "        # input channel 64, output channel 192\n",
+    "        self.conv2 = nn.Conv2d(64, 192, kernel_size=5, stride=1, padding=2)\n",
+    "        self.relu2 = nn.ReLU()\n",
+    "        self.max_pool2d2 = nn.MaxPool2d(kernel_size=3, stride=2)\n",
+    "        # input channel 192, output channel 384\n",
+    "        self.conv3 = nn.Conv2d(192, 384, kernel_size=3, stride=1, padding=1)\n",
+    "        self.relu3 = nn.ReLU()\n",
+    "        # input channel 384, output channel 256\n",
+    "        self.conv4 = nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1)\n",
+    "        self.relu4 = nn.ReLU()\n",
+    "        # input channel 256, output channel 256\n",
+    "        self.conv5 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)\n",
+    "        self.relu5 = nn.ReLU()\n",
+    "        self.max_pool2d5 = nn.MaxPool2d(kernel_size=3, stride=2)\n",
+    "        # adaptive pooling\n",
+    "        self.adapt_pool = nn.AdaptiveAvgPool2d(output_size=(6, 6))\n",
+    "        #dropout layer\n",
+    "        self.dropout1 = nn.Dropout()\n",
+    "        # linear layer\n",
+    "        self.linear1 = nn.Linear(in_features=9216, out_features=4096, bias=True)\n",
+    "        self.relu6 = nn.ReLU()\n",
+    "        self.dropout2 = nn.Dropout()\n",
+    "        self.linear2 = nn.Linear(in_features=4096, out_features=4096, bias=True)\n",
+    "        self.relu7 = nn.ReLU()\n",
+    "        self.linear3 = nn.Linear(in_features=4096, out_features=num_classes, bias=True)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv1(x)\n",
+    "        x = self.relu1(x)\n",
+    "        x = self.max_pool2d1(x)\n",
+    "        x = self.conv2(x)\n",
+    "        x = self.relu2(x)\n",
+    "        x = self.max_pool2d2(x)\n",
+    "        x = self.conv3(x)\n",
+    "        x = self.relu3(x)\n",
+    "        x = self.conv4(x)\n",
+    "        x = self.relu4(x)\n",
+    "        x = self.conv5(x)\n",
+    "        x = self.relu5(x)\n",
+    "        x = self.max_pool2d5(x)\n",
+    "        x = self.adapt_pool(x)\n",
+    "        # Note how we are flattening the feature map, B x C x H x W -> B x C*H*W\n",
+    "        x = x.reshape(x.shape[0], -1)\n",
+    "        x = self.dropout1(x)\n",
+    "        x = self.linear1(x)\n",
+    "        x = self.relu6(x)\n",
+    "        x = self.dropout2(x)\n",
+    "        x = self.linear2(x)\n",
+    "        x = self.relu7(x)\n",
+    "        x = self.linear3(x)\n",
+    "        return x\n",
+    "\n",
+    "## Below you can see another way of defining the model class, where some layers  \n",
+    "## together are defined as an instance variable.\n",
+    "class AlexNet2(nn.Module):\n",
+    "    def __init__(self, num_classes):\n",
+    "        super(AlexNet2, self).__init__()\n",
+    "        self.features = nn.Sequential(\n",
+    "            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),\n",
+    "            nn.ReLU(),\n",
+    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
+    "            nn.Conv2d(64, 192, kernel_size=5, stride=1, padding=2),\n",
+    "            nn.ReLU(),\n",
+    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
+    "            nn.Conv2d(192, 384, kernel_size=3, stride=1, padding=1),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),\n",
+    "            nn.ReLU(),\n",
+    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
+    "            nn.AdaptiveAvgPool2d(output_size=(6, 6))\n",
+    "            )\n",
+    "        self.classifier = nn.Sequential(\n",
+    "            nn.Dropout(),\n",
+    "            nn.Linear(in_features=9216, out_features=4096, bias=True),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Dropout(),\n",
+    "            nn.Linear(in_features=4096, out_features=4096, bias=True),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(in_features=4096, out_features=num_classes, bias=True)\n",
+    "            )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.features(x)\n",
+    "        # Note how we are flattening the feature map, B x C x H x W -> B x C*H*W\n",
+    "        x = x.reshape(x.shape[0], -1)\n",
+    "        x = self.classifier(x)\n",
+    "        return x\n",
+    "\n",
+    "## Below we define the model as defined in the torchvision package and haven't \n",
+    "## initialised with pretrained weights (see pretrained=False flag)\n",
+    "class AlexNet3(nn.Module):\n",
+    "    def __init__(self, num_classes):\n",
+    "        super(AlexNet3, self).__init__()\n",
+    "        from torchvision import models\n",
+    "        alexnet = models.alexnet(weights=None)\n",
+    "        self.features = alexnet.features\n",
+    "        self.avgpool = alexnet.avgpool\n",
+    "        self.classifier = alexnet.classifier\n",
+    "        # Please note how to change the last layer of the classifier for a new dataset\n",
+    "        # ImageNet-1K has 1000 classes, but STL-10 has 10 classes\n",
+    "        self.classifier[6] = nn.Linear(in_features=4096, out_features=num_classes, bias=True)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.features(x)\n",
+    "        x = self.avgpool(x)\n",
+    "        # Note how we are flattening the feature map, B x C x H x W -> B x C*H*W\n",
+    "        x = x.reshape(x.shape[0], -1)\n",
+    "        x = self.classifier(x)\n",
+    "        return x\n",
+    "\n",
+    "## Below we define the model as defined in the torchvision package and initialised \n",
+    "## with pretrained weights (see pretrained=True flag)\n",
+    "class AlexNet4(nn.Module):\n",
+    "    def __init__(self, num_classes):\n",
+    "        super(AlexNet4, self).__init__()\n",
+    "        from torchvision import models\n",
+    "        alexnet = models.alexnet(weights='IMAGENET1K_V1')\n",
+    "        self.features = alexnet.features\n",
+    "        self.avgpool = alexnet.avgpool\n",
+    "        self.classifier = alexnet.classifier\n",
+    "        # Please note how to change the last layer of the classifier for a new dataset\n",
+    "        # ImageNet-1K has 1000 classes, but STL-10 has 10 classes\n",
+    "        self.classifier[6] = nn.Linear(in_features=4096, out_features=num_classes, bias=True)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.features(x)\n",
+    "        x = self.avgpool(x)\n",
+    "        # Note how we are flattening the feature map, B x C x H x W -> B x C*H*W\n",
+    "        x = x.reshape(x.shape[0], -1)\n",
+    "        x = self.classifier(x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "nayicPkJCkWy",
+    "pycharm": {}
+   },
+   "source": [
+    "## Initialization\n",
+    "Once we have the model defined, lets instantiate it and set other hyperparameters."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Y6YBtqhvZGwG"
+   },
+   "source": [
+    "#### Model\n",
+    "We will initialize the model, transfer to the desired device and set the parameters to receive gradients."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TjyEGZSdCk_i",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# define the model, we could use any of the models AlexNet1, AlexNet2, AlexNet3, AlexNet4 \n",
+    "model = AlexNet2(10) # since STL-10 dataset has 10 classes, we set num_classes = 10\n",
+    "# device: cuda (gpu) or cpu\n",
+    "device = \"cuda\"\n",
+    "# map to device\n",
+    "model = model.to(device) # `model.cuda()` will also do the same job\n",
+    "# make the parameters trainable\n",
+    "for param in model.parameters():\n",
+    "    param.requires_grad = True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CETvGvW8Y5-U"
+   },
+   "source": [
+    "#### Optimizer\n",
+    "For updating the parameters, PyTorch provides the package torch.optim that has most popular optimizers implemented. In this tutorial, we will be using the `torch.optim.Adam` optimizer.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "jEBBRoh-Y-bU"
+   },
+   "outputs": [],
+   "source": [
+    "import torch.optim as optim\n",
+    "## some hyperparameters related to optimizer\n",
+    "learning_rate = 0.0001\n",
+    "weight_decay = 0.0005\n",
+    "# define optimizer\n",
+    "optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-RkqO0VcZuRP",
+    "pycharm": {}
+   },
+   "source": [
+    "## Average Meter\n",
+    "It is a simple class for keeping training statistics, such as losses and accuracies etc. The `.val` field usually holds the statistics for the current batch, whereas the `.avg` field hold statistics for the current epoch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JeLH7fbOHDhH",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "class AverageMeter(object):\n",
+    "    \"\"\"Computes and stores the average and current value\"\"\"\n",
+    "    def __init__(self):\n",
+    "        self.reset()\n",
+    "\n",
+    "    def reset(self):\n",
+    "        self.val = 0\n",
+    "        self.avg = 0\n",
+    "        self.sum = 0\n",
+    "        self.count = 0\n",
+    "\n",
+    "    def update(self, val, n=1):\n",
+    "        self.val = val\n",
+    "        self.sum += val * n\n",
+    "        self.count += n\n",
+    "        self.avg = self.sum / self.count"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CSk4VfO_C4tL",
+    "pycharm": {}
+   },
+   "source": [
+    "## Train and Test Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "NJeHMF_BC7bg",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "from tqdm.notebook import tqdm\n",
+    "##define train function\n",
+    "def train(model, device, train_loader, optimizer):\n",
+    "    # meter\n",
+    "    loss = AverageMeter()\n",
+    "    # switch to train mode\n",
+    "    model.train()\n",
+    "    tk0 = tqdm(train_loader, total=int(len(train_loader)))\n",
+    "    for batch_idx, (data, target) in enumerate(tk0):\n",
+    "        # after fetching the data transfer the model to the \n",
+    "        # required device, in this example the device is gpu\n",
+    "        # transfer to gpu can also be done by \n",
+    "        # data, target = data.cuda(), target.cuda()\n",
+    "        data, target = data.to(device), target.to(device)  \n",
+    "        # compute the forward pass\n",
+    "        # it can also be achieved by model.forward(data)\n",
+    "        output = model(data) \n",
+    "        # compute the loss function\n",
+    "        loss_this = F.cross_entropy(output, target)\n",
+    "        # initialize the optimizer\n",
+    "        optimizer.zero_grad()\n",
+    "        # compute the backward pass\n",
+    "        loss_this.backward()\n",
+    "        # update the parameters\n",
+    "        optimizer.step()\n",
+    "        # update the loss meter \n",
+    "        loss.update(loss_this.item(), target.shape[0])\n",
+    "    print('Train: Average loss: {:.4f}\\n'.format(loss.avg))\n",
+    "    return loss.avg\n",
+    "        \n",
+    "##define test function\n",
+    "def test(model, device, test_loader):\n",
+    "    # meters\n",
+    "    loss = AverageMeter()\n",
+    "    acc = AverageMeter()\n",
+    "    correct = 0\n",
+    "    # switch to test mode\n",
+    "    model.eval()\n",
+    "    for data, target in test_loader:\n",
+    "        # after fetching the data transfer the model to the \n",
+    "        # required device, in this example the device is gpu\n",
+    "        # transfer to gpu can also be done by \n",
+    "        # data, target = data.cuda(), target.cuda()\n",
+    "        data, target = data.to(device), target.to(device)  # data, target = data.cuda(), target.cuda()\n",
+    "        # since we dont need to backpropagate loss in testing,\n",
+    "        # we dont keep the gradient\n",
+    "        with torch.no_grad():\n",
+    "            # compute the forward pass\n",
+    "            # it can also be achieved by model.forward(data)\n",
+    "            output = model(data)\n",
+    "        # compute the loss function just for checking\n",
+    "        loss_this = F.cross_entropy(output, target) # sum up batch loss\n",
+    "        # get the index of the max log-probability\n",
+    "        pred = output.argmax(dim=1, keepdim=True) \n",
+    "        # check which of the predictions are correct\n",
+    "        correct_this = pred.eq(target.view_as(pred)).sum().item()\n",
+    "        # accumulate the correct ones\n",
+    "        correct += correct_this\n",
+    "        # compute accuracy\n",
+    "        acc_this = correct_this/target.shape[0]*100.0\n",
+    "        # update the loss and accuracy meter \n",
+    "        acc.update(acc_this, target.shape[0])\n",
+    "        loss.update(loss_this.item(), target.shape[0])\n",
+    "    print('Test: Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\\n'.format(\n",
+    "        loss.avg, correct, len(test_loader.dataset), acc.avg))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vzxivyrXDB7a",
+    "pycharm": {}
+   },
+   "source": [
+    "## Training Loop\n",
+    "Training loop containing alternating train and test phase. Below we are iterating the loops 5 times, you can iterate more times."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "tna_R8TSDD4D",
+    "pycharm": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# import tensorboard logger from PyTorch\n",
+    "from torch.utils.tensorboard import SummaryWriter\n",
+    "# create TensorBoard logger\n",
+    "writer = SummaryWriter('runs/stl10_experiment_1')\n",
+    "# number of epochs we decide to train\n",
+    "num_epoch = 10\n",
+    "for epoch in range(1, num_epoch + 1):\n",
+    "    epoch_loss = train(model, device, train_loader, optimizer)\n",
+    "    writer.add_scalar('training_loss', epoch_loss, global_step = epoch)\n",
+    "test(model, device, test_loader)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "grSrfsp5BhTC"
+   },
+   "source": [
+    "### Training loss curve"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "5FhhYHF_BUBv"
+   },
+   "source": [
+    "The TensorBoard file in the folder runs/stl10_experiment_1 now contains a training loss curve over number of epochs. To start the TensorBoard visualizer, simply run the following statements."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "oR9tsiHJ6LlS"
+   },
+   "outputs": [],
+   "source": [
+    "# Load tensorboard extension for Jupyter Notebook, only need to start TB in the notebook\n",
+    "%reload_ext tensorboard\n",
+    "%tensorboard --logdir runs/stl10_experiment_1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1B19bDzBDIV4",
+    "pycharm": {}
+   },
+   "source": [
+    "### Summary\n",
+    "Show the summary of the model. It shows the number of parameters in layerwise as well as the total number of parameters. It also shows the memories required for training the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "9eztTJ4VDKCA",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "from torchsummary import summary\n",
+    "summary(model, (3, 96, 96))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Skq4kzyt7PpN",
+    "pycharm": {}
+   },
+   "source": [
+    "## Transfer Learning\n",
+    "Transfer learning is a machine learning paradigm where a model developed for a task is reused as the starting point for a model on a second task. In this workshop, you will learn how to classifiy sketches using pretrained model trained on [ImageNet-1K](http://image-net.org/). In this part of the workshop, we will use the pretrained weights of AlexNet (note the `pretrained=True` flag in `AlexNet4` model above) available from PyTorch to classify sketch images from the [TU-Berlin dataset](http://cybertron.cg.tu-berlin.de/eitz/projects/classifysketch/). This is a very good example where knowledge or weights learned from natural images could be used for solving a classification task on completely different domains, such as sketch."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "YxLFKtvlV9jN",
+    "pycharm": {}
+   },
+   "source": [
+    "## TU-Berlin Dataset\n",
+    "TU-Berlin dataset contains over 20,000 human drawn sketches evenly distributed over 250 object categories. Some of the sketches from the dataset can be seen below.\n",
+    "\n",
+    "![TU-Berlin](https://cybertron.cg.tu-berlin.de/eitz/projects/classifysketch/teaser_siggraph.jpg)\n",
+    "\n",
+    "More details on the dataset can be found here: http://cybertron.cg.tu-berlin.de/eitz/projects/classifysketch/. Lets download the dataset and prepare it for usage."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "bxXqCPXvVI9J",
+    "pycharm": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "if not os.path.exists('sketches_png.zip'):\n",
+    "    !wget http://cybertron.cg.tu-berlin.de/eitz/projects/classifysketch/sketches_png.zip\n",
+    "    !unzip -q sketches_png.zip\n",
+    "    !rm sketches_png.zip\n",
+    "    !mv png tu_berlin"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kopBHyQu5K8t",
+    "pycharm": {}
+   },
+   "source": [
+    "### Split into Train and Test Set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "bgkRoHjIub9M",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "with open('tu_berlin/filelist.txt', 'r') as fp:\n",
+    "    files = fp.read().splitlines()\n",
+    "classes_str = [file.split('/')[0] for file in files]\n",
+    "classes_str, classes = np.unique(classes_str, return_inverse=True)\n",
+    "train_files, test_files, train_classes, test_classes = train_test_split(files, classes, train_size=0.3, test_size=0.1, stratify=classes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6_zDUF0R4xgR",
+    "pycharm": {}
+   },
+   "source": [
+    "### Custom Dataset\n",
+    "Since TU-Berlin is not implemented as a data generator within the torchvision package, we have to implement a custom data generator for this. One need to inherit the [`data.Dataset` class](https://pytorch.org/docs/stable/data.html) of PyTorch for designing a data generator for a dataset. The custom class should override the following methods:\n",
+    "\n",
+    "* `__len__` so that `len(dataset)` returns the size of the dataset.\n",
+    "* `__getitem__` to support the indexing such that `dataset[i]` can be used to get *i*th sample.\n",
+    "\n",
+    "Now lets create a dataset class for our TU-Berlin dataset. We will set the location of the sketches inside the `__init__` function, but leave the loading image sketch images for the `__getitem__` function. This way is memory efficient because all the images are not stored in the memory at once but read as required."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "fCcARypv3hpL",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "from PIL import Image\n",
+    "import torch.utils.data as data\n",
+    "class TUBerlin(data.Dataset):\n",
+    "    def __init__(self, root, files, classes, transforms=None): \n",
+    "        # location of the dataset\n",
+    "        self.root = root\n",
+    "        # list of files\n",
+    "        self.files = files\n",
+    "        # list of classes\n",
+    "        self.classes = classes\n",
+    "        # transforms\n",
+    "        self.transforms = transforms\n",
+    "\n",
+    "    def __getitem__(self, item):\n",
+    "        # read the image\n",
+    "        image = Image.open(os.path.join(self.root, self.files[item])).convert(mode=\"RGB\")\n",
+    "        # class for that image\n",
+    "        class_ = self.classes[item]\n",
+    "        # apply transformation\n",
+    "        if self.transforms:\n",
+    "            image = self.transforms(image)\n",
+    "        # return the image and class\n",
+    "        return image, class_\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        # return the total number of images\n",
+    "        return len(self.files)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NEFyh0BDo-l4",
+    "pycharm": {}
+   },
+   "source": [
+    "### Dataset and DataLoader\n",
+    "In the following cell, we are defining the datasets and data loaders. The usage of different functions are alike to the example mentioned above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "OTP0pmYG5oM9",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torchvision\n",
+    "# Define batch size, batch size is how much data you feed for training in one iteration\n",
+    "batch_size_train = 256 # We use a small batch size here for training\n",
+    "batch_size_test = 1024 # We use bigger batch size for testing\n",
+    "\n",
+    "# define how image transformed\n",
+    "image_transform = torchvision.transforms.Compose([\n",
+    "                               torchvision.transforms.Resize((224, 224)),\n",
+    "                               torchvision.transforms.ToTensor(),\n",
+    "                               torchvision.transforms.Normalize(\n",
+    "                                 (0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
+    "# image datasets\n",
+    "train_dataset = TUBerlin('tu_berlin/', train_files, train_classes, \n",
+    "                         transforms=image_transform)\n",
+    "test_dataset = TUBerlin('tu_berlin/', test_files, test_classes, \n",
+    "                        transforms=image_transform)\n",
+    "# data loaders\n",
+    "train_loader = torch.utils.data.DataLoader(train_dataset,\n",
+    "                                           batch_size=batch_size_train, \n",
+    "                                           shuffle=True, num_workers=2)\n",
+    "test_loader = torch.utils.data.DataLoader(test_dataset,\n",
+    "                                          batch_size=batch_size_test, \n",
+    "                                          shuffle=True, num_workers=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "oFhh272O7jkj",
+    "pycharm": {}
+   },
+   "source": [
+    "### Example Image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "4BSAiPFv7jkj",
+    "pycharm": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# import library\n",
+    "import matplotlib.pyplot as plt\n",
+    "# We can check the dataloader\n",
+    "_, (example_datas, labels) = next(enumerate(train_loader))\n",
+    "sample = example_datas[0]\n",
+    "# show the data\n",
+    "plt.imshow(sample.permute(1, 2, 0));\n",
+    "print(\"Label: \" + str(classes_str[labels[0]]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "__Wx5zUY7L92",
+    "pycharm": {}
+   },
+   "source": [
+    "## Initialization\n",
+    "\n",
+    "Please read the comments and understand the purpose of different lines of code."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fRqz56BYjgoU"
+   },
+   "source": [
+    "### Model\n",
+    "\n",
+    "Please check below how to make some of the layers not trainable and other trainable."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "mEawkRwgjvDq"
+   },
+   "outputs": [],
+   "source": [
+    "# define the model which contains pretrained weights from ImageNet\n",
+    "model = AlexNet4(250) # note the pretrained=True flag in the AlexNet4 model\n",
+    "# device: cuda (gpu) or cpu\n",
+    "device = \"cuda\"\n",
+    "# map to device\n",
+    "model = model.to(device)\n",
+    "################################################################################\n",
+    "################################# IMPORTANT ####################################\n",
+    "################################################################################\n",
+    "# one can choose which parameters of the model to train or finetune\n",
+    "# Setting 1: make all the parameters of the model trainable\n",
+    "for param in model.parameters():\n",
+    "    param.requires_grad = True\n",
+    "\n",
+    "# Setting 2: make only the last layer of the classifier handle trainable\n",
+    "for param in model.parameters():\n",
+    "    param.requires_grad = False\n",
+    "for param in model.classifier[6].parameters():\n",
+    "    param.requires_grad = True\n",
+    "\n",
+    "# Setting 3: make all the parameters of the conv layer (features handle) \n",
+    "# not trainable and others (classifier handle) trainable\n",
+    "for param in model.features.parameters():\n",
+    "    param.requires_grad = False\n",
+    "for param in model.classifier.parameters():\n",
+    "    param.requires_grad = True\n",
+    "\n",
+    "parameters = filter(lambda p: p.requires_grad, model.parameters())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "DSg5gjryjkXV"
+   },
+   "source": [
+    "### Optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "RxItpRN-7L93",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "## create model and optimizer\n",
+    "learning_rate = 0.0001\n",
+    "weight_decay = 0.0005\n",
+    "# define optimizer\n",
+    "optimizer = optim.Adam(parameters, lr=learning_rate, weight_decay=weight_decay)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "f_ET0FAw7Va_",
+    "pycharm": {}
+   },
+   "source": [
+    "## Training Loop\n",
+    "Training loop for several epochs. Perform testing after training the model for some epochs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "4OyndchC7VbA",
+    "pycharm": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "num_epoch = 5\n",
+    "for epoch in range(1, num_epoch + 1):\n",
+    "    train(model, device, train_loader, optimizer)\n",
+    "test(model, device, test_loader)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_hQ1PoEEvSQF"
+   },
+   "source": [
+    "## Summary\n",
+    "Show the summary of the model. It shows the number of parameters in layerwise as well as the total number of parameters. It also shows the memories required for training the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "dxNHMSBPXNLp",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "from torchsummary import summary\n",
+    "summary(model, (3, 224, 224))"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "include_colab_link": true,
+   "name": "ECMM426/ECMM441 - Convolutional Neural Networks and Transfer Learning.ipynb",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

Downloads/.ipynb_checkpoints/EEEM071_CourseWork_ipynb-checkpoint.ipynb

@@ -0,0 +1,379 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9X3IbRehFNjA"
+   },
+   "source": [
+    "# Step 1: GPU Selection\n",
+    "1. Find \"Edit\" tab above, select \"Hardware accelerator\" and choose \"GPU\"\n",
+    "2. Run bellow command to check what GPU you got"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 120,
+     "status": "ok",
+     "timestamp": 1742400948017,
+     "user": {
+      "displayName": "Wenqing Wang",
+      "userId": "10666645302626123442"
+     },
+     "user_tz": 0
+    },
+    "id": "xHEpV2i0zQrW",
+    "outputId": "582b5d58-d87d-479e-f1ab-feed3516fe6c"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Wed Mar 19 16:15:47 2025       \n",
+      "+-----------------------------------------------------------------------------------------+\n",
+      "| NVIDIA-SMI 550.54.15              Driver Version: 550.54.15      CUDA Version: 12.4     |\n",
+      "|-----------------------------------------+------------------------+----------------------+\n",
+      "| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |\n",
+      "| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |\n",
+      "|                                         |                        |               MIG M. |\n",
+      "|=========================================+========================+======================|\n",
+      "|   0  Tesla T4                       Off |   00000000:00:04.0 Off |                    0 |\n",
+      "| N/A   36C    P8              9W /   70W |       0MiB /  15360MiB |      0%      Default |\n",
+      "|                                         |                        |                  N/A |\n",
+      "+-----------------------------------------+------------------------+----------------------+\n",
+      "                                                                                         \n",
+      "+-----------------------------------------------------------------------------------------+\n",
+      "| Processes:                                                                              |\n",
+      "|  GPU   GI   CI        PID   Type   Process name                              GPU Memory |\n",
+      "|        ID   ID                                                               Usage      |\n",
+      "|=========================================================================================|\n",
+      "|  No running processes found                                                             |\n",
+      "+-----------------------------------------------------------------------------------------+\n"
+     ]
+    }
+   ],
+   "source": [
+    "!nvidia-smi"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "oQzoka29GGzQ"
+   },
+   "source": [
+    "# Step 2: Code Preparation\n",
+    "\n",
+    "We need to maintain our codebase with git history, so a file system (Google Drive) is needed\n",
+    "1. Select the left file icon and mount your Google Drive\n",
+    "2. Move path to Google Drive\n",
+    "3. Git clone code base\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 516,
+     "status": "ok",
+     "timestamp": 1742400952955,
+     "user": {
+      "displayName": "Wenqing Wang",
+      "userId": "10666645302626123442"
+     },
+     "user_tz": 0
+    },
+    "id": "4H0KIZFSGC4Z",
+    "outputId": "918bc8c9-00d1-4677-a68c-38c5977c3581"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[Errno 2] No such file or directory: '/content/MyDrive/'\n",
+      "/content/EEEM071-Coursework-2025\n",
+      "Cloning into 'EEEM071-Coursework-2025'...\n",
+      "remote: Enumerating objects: 55, done.\u001b[K\n",
+      "remote: Counting objects: 100% (15/15), done.\u001b[K\n",
+      "remote: Compressing objects: 100% (13/13), done.\u001b[K\n",
+      "remote: Total 55 (delta 5), reused 1 (delta 1), pack-reused 40 (from 1)\u001b[K\n",
+      "Receiving objects: 100% (55/55), 33.64 KiB | 4.20 MiB/s, done.\n",
+      "Resolving deltas: 100% (7/7), done.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# %cd /content/drive/MyDrive/\n",
+    "%cd /content/MyDrive/\n",
+    "\n",
+    "!git clone https://github.com/Surrey-EEEM071-CVDL/EEEM071-Coursework-2025.git"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 1549,
+     "status": "ok",
+     "timestamp": 1742400957932,
+     "user": {
+      "displayName": "Wenqing Wang",
+      "userId": "10666645302626123442"
+     },
+     "user_tz": 0
+    },
+    "id": "-LJSH0dbIeW5",
+    "outputId": "3fb3b507-65a8-45af-d33c-6ac920c4cd6c"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
+     ]
+    }
+   ],
+   "source": [
+    "from google.colab import drive\n",
+    "drive.mount('/content/drive')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "SYUXrD24IV8x"
+   },
+   "source": [
+    "# Step 3: Data Preparation\n",
+    "\n",
+    "Because reading images from Google Drive is very slow, we download datasets to Colab temporary file\n",
+    "1. Install gdown\n",
+    "2. Download data\n",
+    "3. Unzip data with password"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 3320,
+     "status": "ok",
+     "timestamp": 1742400323557,
+     "user": {
+      "displayName": "Wenqing Wang",
+      "userId": "10666645302626123442"
+     },
+     "user_tz": 0
+    },
+    "id": "_X3Y8Adk1xjd",
+    "outputId": "6c01c8c0-874e-4a1e-ddfd-eb45fb6133d1"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/content\n",
+      "Requirement already satisfied: gdown in /usr/local/lib/python3.11/dist-packages (5.2.0)\n",
+      "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.11/dist-packages (from gdown) (4.13.3)\n",
+      "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from gdown) (3.17.0)\n",
+      "Requirement already satisfied: requests[socks] in /usr/local/lib/python3.11/dist-packages (from gdown) (2.32.3)\n",
+      "Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (from gdown) (4.67.1)\n",
+      "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.11/dist-packages (from beautifulsoup4->gdown) (2.6)\n",
+      "Requirement already satisfied: typing-extensions>=4.0.0 in /usr/local/lib/python3.11/dist-packages (from beautifulsoup4->gdown) (4.12.2)\n",
+      "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests[socks]->gdown) (3.4.1)\n",
+      "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests[socks]->gdown) (3.10)\n",
+      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests[socks]->gdown) (2.3.0)\n",
+      "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests[socks]->gdown) (2025.1.31)\n",
+      "Requirement already satisfied: PySocks!=1.5.7,>=1.5.6 in /usr/local/lib/python3.11/dist-packages (from requests[socks]->gdown) (1.7.1)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%cd /content\n",
+    "!pip install -U --no-cache-dir gdown --pre\n",
+    "\n",
+    "# please download datasets from assignment doc link and upload, then unzip it."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "u1z0Kb-LMfh-"
+   },
+   "source": [
+    "# Step 4: Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 111,
+     "status": "ok",
+     "timestamp": 1742401034406,
+     "user": {
+      "displayName": "Wenqing Wang",
+      "userId": "10666645302626123442"
+     },
+     "user_tz": 0
+    },
+    "id": "GDKjqjjsMcao",
+    "outputId": "ae0b64ff-0afc-4822-b7a3-953d2a936877"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/content/VeRi.zip: Zip archive data, at least v2.0 to extract, compression method=store\n"
+     ]
+    }
+   ],
+   "source": [
+    "!file /content/VeRi.zip"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 5,
+     "status": "ok",
+     "timestamp": 1742400487347,
+     "user": {
+      "displayName": "Wenqing Wang",
+      "userId": "10666645302626123442"
+     },
+     "user_tz": 0
+    },
+    "id": "xL87Cl0W6Wll",
+    "outputId": "7723f374-114e-42aa-c90a-6620e2e29517"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/content/EEEM071-Coursework-2025\n"
+     ]
+    }
+   ],
+   "source": [
+    "%cd /content/EEEM071-Coursework-2025/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 108
+    },
+    "executionInfo": {
+     "elapsed": 20,
+     "status": "error",
+     "timestamp": 1742403141571,
+     "user": {
+      "displayName": "Wenqing Wang",
+      "userId": "10666645302626123442"
+     },
+     "user_tz": 0
+    },
+    "id": "w2BqyZO3Mqjz",
+    "outputId": "ad17ae56-2501-467a-d9ae-e6bdd0fb0328"
+   },
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "invalid syntax (<ipython-input-20-64eca099a521>, line 1)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-20-64eca099a521>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    STUDENT_ID='@#123s£' STUDENT_NAME=\"Jane_/*%~#¬Doe\" python main.py \\\u001b[0m\n\u001b[0m                         ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
+     ]
+    }
+   ],
+   "source": [
+    "!STUDENT_ID='@#123s£' STUDENT_NAME=\"Jane_/*%~#¬Doe\" python main.py \\\n",
+    "-s veri \\\n",
+    "-t veri \\\n",
+    "-a mobilenet_v3_small \\\n",
+    "--root /content/drive/MyDrive/VeRi \\\n",
+    "--height 224 \\\n",
+    "--width 224 \\\n",
+    "--optim amsgrad \\\n",
+    "--lr 0.0003 \\\n",
+    "--max-epoch 10 \\\n",
+    "--stepsize 20 40 \\\n",
+    "--train-batch-size 64 \\\n",
+    "--test-batch-size 100 \\\n",
+    "--save-dir logs/mobilenet_v3_small-veri"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "jA43L0cTNpiJ"
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "provenance": []
+  },
+  "gpuClass": "standard",
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

Downloads/.ipynb_checkpoints/Human Action Recognition Tutorial-checkpoint.ipynb

@@ -0,0 +1,820 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "view-in-github"
+   },
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/AnjanDutta/EEEM068/blob/main/Notebooks/Human_Action_Recognition.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RakR_TVgNmE6"
+   },
+   "source": [
+    "<H1 style=\"text-align: center\">EEEM068 - Applied Machine Learning</H1>\n",
+    "<H1 style=\"text-align: center\">Workshop 05</H1>\n",
+    "<H1 style=\"text-align: center\">Human Action Recognition Tutorial</H1>\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vNvDHbU2zY1u"
+   },
+   "source": [
+    "##Introduction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1xVXuN1-zXI9"
+   },
+   "source": [
+    "In this tutorial, we will explore 2D and 3D convolutional neural network models in recognizing human actions occurring in the videos from the [KTH dataset](https://www.csc.kth.se/cvap/actions/)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RBqUFnmzx21o"
+   },
+   "source": [
+    "## KTH Dataset\n",
+    "The KTH dataset consists of videos of humans performing 6 types of action: *boxing*, *clapping*, *waving*, *jogging*, *running*, and *walking*. There are 25 subjects performing these actions in 4 scenarios: outdoor, outdoor with scale variation, outdoor with different clothes, and indoor. The total number of videos is therefore $25 \\times 4 \\times 6 = 600$. The videos' frame rate are 25fps and their resolution is $160 \\times 120$. More information about the dataset can be looked up at the website. More details on this dataset can be found at https://www.csc.kth.se/cvap/actions.\n",
+    "\n",
+    "We have preprocessed (i.e., extracted the frames and resized those frames etc) those videos and pickled them in the following link (https://empslocal.ex.ac.uk/people/staff/ad735/ECMM426/KTH_pickle.zip). In this experiment, we will be using the pickled version of the KTH dataset. However, the raw KTH videos can be found in this link (https://empslocal.ex.ac.uk/people/staff/ad735/ECMM426/KTH.zip).\n",
+    "\n",
+    "<img src=\"http://www.csc.kth.se/cvap/actions/actions.gif\" alt=\"action recognition\" width=\"500\"/>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "sVrBKULQUi5r"
+   },
+   "source": [
+    "Lets download the pickled dataset from the above link."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JC1zNcUjwDmQ"
+   },
+   "outputs": [],
+   "source": [
+    "# Download the dataset\n",
+    "import os\n",
+    "if not os.path.exists('KTH_pickle.zip'):\n",
+    "  !wget --no-check-certificate https://empslocal.ex.ac.uk/people/staff/ad735/ECMM426/KTH_pickle.zip\n",
+    "  !unzip -q KTH_pickle.zip\n",
+    "\n",
+    "# Dictionary of categories\n",
+    "CATEGORY_INDEX = {\n",
+    "    \"boxing\": 0,\n",
+    "    \"handclapping\": 1,\n",
+    "    \"handwaving\": 2,\n",
+    "    \"jogging\": 3,\n",
+    "    \"running\": 4,\n",
+    "    \"walking\": 5\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9_3bTBMf26bP"
+   },
+   "source": [
+    "### Example Video"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "8W-FdHna6gvQ"
+   },
+   "source": [
+    "Lets plot 20 equidistant frames of the very first video in the train split."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "irg1Pter2_33"
+   },
+   "outputs": [],
+   "source": [
+    "import pickle\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "videos = pickle.load(open('KTH_pickle/train.pickle', 'rb'))\n",
+    "# first video\n",
+    "video_0 = videos[0]['frames']\n",
+    "# number of frames\n",
+    "n = 20\n",
+    "# figure size\n",
+    "fig = plt.figure(figsize=(25, 25))\n",
+    "# index of equidistant frames\n",
+    "nth_frames = np.linspace(0, len(video_0) - 1, n).astype(int)\n",
+    "for i in range(n):\n",
+    "    frame = video_0[i]\n",
+    "    fig.add_subplot(1, n, i + 1)\n",
+    "    plt.imshow(frame, cmap='gray')\n",
+    "    plt.axis('off')\n",
+    "plt.show()\n",
+    "\n",
+    "print('Action class: ' + videos[0]['category'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_b_RgpUI-LEG"
+   },
+   "source": [
+    "Now lets plot 20 equidistant frames of the 91st video in the train split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "O22r78_C-Xpv"
+   },
+   "outputs": [],
+   "source": [
+    "# tenth video\n",
+    "video_90 = videos[90]['frames']\n",
+    "# number of frames\n",
+    "n = 20\n",
+    "# figure size\n",
+    "fig = plt.figure(figsize=(25, 25))\n",
+    "# index of equidistant frames\n",
+    "nth_frames = np.linspace(0, len(video_90) - 1, n).astype(int)\n",
+    "for i in range(n):\n",
+    "    frame = video_90[i]\n",
+    "    fig.add_subplot(1, n, i + 1)\n",
+    "    plt.imshow(frame, cmap='gray')\n",
+    "    plt.axis('off')\n",
+    "plt.show()\n",
+    "\n",
+    "print('Action class: ' + videos[90]['category'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "oOyC0Tolsu1r"
+   },
+   "source": [
+    "### Dataset and DataLoader\n",
+    "Since KTH dataset is not available within the torchvision's collection of datasets, we have to create our own dataset class to train an action recognition model. As discussed in the lecture, we will build two different models for that. The first one is based on 2D CNN, which will consider each frame as an image and will classify each frame into one of the action classes. Therefore, this model will work as an image classification model rather than a video classification model. For the second model, we will use 3D CNN which will consider a sequence or block of frames and intend to classify the entire sequence of frames into one of the action classes. In contrast with the first model, the second model will consider temporal information and will act as a true action recognition model.\n",
+    "\n",
+    "Therefore, in order to feed appropriate data, we will design two different types of dataset: (1) **SingleFrameDataset:** the first will return single frame which we will consider as an individual image, (2) **BlockFrameDataset:** block or sequence of frames where temporal information will be considered. Below, we have the two datasets for in PyTorch format."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_w7xu7m-D6lZ"
+   },
+   "source": [
+    "#### Single frame dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "p30M6x3LD3L0"
+   },
+   "source": [
+    "This dataset is used for training the single frame model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "kJCZkUw0sxKv"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import torch\n",
+    "import pickle\n",
+    "import numpy as np\n",
+    "from torch.utils.data import Dataset\n",
+    "\n",
+    "class SingleFrameDataset(Dataset):\n",
+    "    def __init__(self, directory, dataset=\"train\"):\n",
+    "        self.instances, self.labels = self.read_dataset(directory, dataset)\n",
+    "        # convert them into tensor\n",
+    "        self.instances = torch.from_numpy(self.instances)\n",
+    "        self.labels = torch.from_numpy(self.labels)\n",
+    "        # normalize\n",
+    "        self.zero_center()\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return self.instances.shape[0]\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        return self.instances[idx], self.labels[idx]\n",
+    "\n",
+    "    def zero_center(self):\n",
+    "        self.instances -= float(self.mean)\n",
+    "\n",
+    "    def read_dataset(self, directory, dataset=\"train\"):\n",
+    "        # set paths according to split\n",
+    "        if dataset == \"train\":\n",
+    "            filepath = os.path.join(directory, \"train.pickle\")\n",
+    "        elif dataset == \"val\":\n",
+    "            filepath = os.path.join(directory, \"val.pickle\")\n",
+    "        else:\n",
+    "            filepath = os.path.join(directory, \"test.pickle\")\n",
+    "        #read the pickle file\n",
+    "        videos = pickle.load(open(filepath, \"rb\"))\n",
+    "        # accumulate the instances and label\n",
+    "        instances = []\n",
+    "        labels = []\n",
+    "        for video in videos:\n",
+    "            for frame in video[\"frames\"]:\n",
+    "                instances.append(frame.reshape((1, 60, 80)))\n",
+    "                labels.append(CATEGORY_INDEX[video[\"category\"]])\n",
+    "        # numpy array\n",
+    "        instances = np.array(instances, dtype=np.float32)\n",
+    "        labels = np.array(labels, dtype=np.uint8)\n",
+    "        self.mean = np.mean(instances)\n",
+    "        return instances, labels"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "qKKppTFJEDMK"
+   },
+   "source": [
+    "#### Block Frame Dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "oWUpk0tytWjH"
+   },
+   "source": [
+    "This dataset is used for training the block frame model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "J0uYc1o_tcFm"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import torch\n",
+    "import pickle\n",
+    "import numpy as np\n",
+    "from torch.utils.data import Dataset\n",
+    "\n",
+    "class BlockFrameDataset(Dataset):\n",
+    "    def __init__(self, directory, dataset=\"train\"):\n",
+    "        self.instances, self.labels = self.read_dataset(directory, dataset)\n",
+    "        # convert them into tensor\n",
+    "        self.instances = torch.from_numpy(self.instances)\n",
+    "        self.labels = torch.from_numpy(self.labels)\n",
+    "        # normalize\n",
+    "        self.zero_center()\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return self.instances.shape[0]\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        return self.instances[idx], self.labels[idx]\n",
+    "\n",
+    "    def zero_center(self):\n",
+    "        self.instances -= float(self.mean)\n",
+    "\n",
+    "    def read_dataset(self, directory, dataset=\"train\", mean=None):\n",
+    "        # set paths according to split\n",
+    "        if dataset == \"train\":\n",
+    "            filepath = os.path.join(directory, \"train.pickle\")\n",
+    "        elif dataset == \"val\":\n",
+    "            filepath = os.path.join(directory, \"val.pickle\")\n",
+    "        else:\n",
+    "            filepath = os.path.join(directory, \"test.pickle\")\n",
+    "        # read the pickle file\n",
+    "        videos = pickle.load(open(filepath, \"rb\"))\n",
+    "        # accumulate the instances and label\n",
+    "        instances = []\n",
+    "        labels = []\n",
+    "        current_block = []\n",
+    "        for video in videos:\n",
+    "            for i, frame in enumerate(video[\"frames\"]):\n",
+    "                current_block.append(frame)\n",
+    "                # 15 consecutive frames\n",
+    "                if len(current_block) % 15 == 0:\n",
+    "                    current_block = np.array(current_block)\n",
+    "                    instances.append(current_block.reshape((1, 15, 60, 80)))\n",
+    "                    current_block = []\n",
+    "                    labels.append(CATEGORY_INDEX[video[\"category\"]])\n",
+    "        # numpy array\n",
+    "        instances = np.array(instances, dtype=np.float32)\n",
+    "        labels = np.array(labels, dtype=np.uint8)\n",
+    "        self.mean = np.mean(instances)\n",
+    "        return instances, labels"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "YE5seYpPxY_f"
+   },
+   "source": [
+    "## Models\n",
+    "\n",
+    "As mentioned above, we will create two different models. (1) **SingleFrameModel:** the first one is based on 2D CNN, which will consider each single frame as an image and will classify each frame into one of the action classes. In other words, this model will work as an image classification model rather than a video classification model, because it will not consider any temporal information. (2) **BlockFrameModel:** the second model we will use 3D CNN which will consider a sequence or block of frames and intend to classify the entire sequence of frames into one of the action classes. In contrast with the first model, the second model will consider temporal information and will act as a true action recognition model. Therefore, it is expected that the BlockFrameModel works better than the SingleFrameModel for the action classification task."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "eKlLD8NFFYoA"
+   },
+   "source": [
+    "### Single Frame Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "DtaTfXruFaZp"
+   },
+   "source": [
+    "Below we implement the single frame model. If this model is tested after training it for 20 epochs, the accuracy of this model on the test set should be around 55%. This accuracy could be increased if you train it longer. In this model, we are going to use the following functions or modules:\n",
+    "\n",
+    "* `nn.Sequential()`: It is a sequential container. Modules will be added to it in the order they are passed in the constructor. Please check the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html#torch.nn.Sequential) for more details.\n",
+    "\n",
+    "* `nn.Conv2d()`: It is a PyTorch module that applies a 2D convolution over an input signal composed of several input planes. More details are available on the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html).\n",
+    "\n",
+    "* `nn.BatchNorm2d()`: This module applies batch normalization over a 4D input as described in the [Batch Normalization paper](https://arxiv.org/abs/1502.03167). More details can be found in the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.BatchNorm2d.html).\n",
+    "\n",
+    "* `nn.MaxPool2d()`: It is also a module that applies a 2D max pooling over an input signal composed of several input planes. Please have a look on this [documentation](https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html) for more details.\n",
+    "\n",
+    "* `nn.Linear()`: It is a module that applies a linear transformation to the incoming data. More details can be found in its [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html#linear).\n",
+    "\n",
+    "* `nn.ReLU()`: It is also a module that applies element-wise the rectified linear unit function. Its [documentation](https://pytorch.org/docs/stable/generated/torch.nn.ReLU.html#relu) can explain more.\n",
+    "\n",
+    "* `nn.Dropout()`: This module randomly zeroes some of the elements of the input tensor with probability `p`. Check the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Dropout.html#dropout) for more details."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "w_mka7mhwppH"
+   },
+   "outputs": [],
+   "source": [
+    "import torch.nn as nn\n",
+    "\n",
+    "class SingleFrameModel(nn.Module):\n",
+    "    def __init__(self, n_classes):\n",
+    "        super(SingleFrameModel, self).__init__()\n",
+    "\n",
+    "        self.conv = nn.Sequential(\n",
+    "            nn.Conv2d(1, 16, kernel_size=5),\n",
+    "            nn.BatchNorm2d(16),\n",
+    "            nn.ReLU(),\n",
+    "            nn.MaxPool2d(kernel_size=2),\n",
+    "            nn.Dropout(0.5),\n",
+    "            nn.Conv2d(16, 32, kernel_size=3),\n",
+    "            nn.BatchNorm2d(32),\n",
+    "            nn.ReLU(),\n",
+    "            nn.MaxPool2d(kernel_size=2),\n",
+    "            nn.Dropout(0.5),\n",
+    "            nn.Conv2d(32, 64, kernel_size=3),\n",
+    "            nn.BatchNorm2d(64),\n",
+    "            nn.ReLU(),\n",
+    "            nn.MaxPool2d(kernel_size=2),\n",
+    "            nn.Dropout(0.5))\n",
+    "\n",
+    "        self.fc = nn.Sequential(\n",
+    "            nn.Linear(2560, 128),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Dropout(0.5),\n",
+    "            nn.Linear(128, n_classes))\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        out = self.conv(x)\n",
+    "        out = out.view(out.size(0), -1)\n",
+    "        out = self.fc(out)\n",
+    "\n",
+    "        return out"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "5MjQIJjuxglx"
+   },
+   "source": [
+    "### Block Frame Model\n",
+    "Below we implement the 2nd model that considers sequence of frames. For each video, we devide it into blocks of 15 contiguous frames. The model is then trained on these blocks instead of individual frame. In the convolutional layers, we use 3D convolutional filters (i.e. 3D CNN) to train the model to learn to detect temporal features.\n",
+    "\n",
+    "To classify a video, we also divide it into blocks of 15 contiguous frames. We then run the model on each block to get the block's vector of class probabilities. If this model is tested after training the model for 20 epochs the obtained accuracy on the test set should be around 67%. This means that the model is able to detect capture temporal information appeared in consecutive frames. However, this accuracy could be increased further by training it longer. In this model, we are going to use the following functions or modules:\n",
+    "\n",
+    "* `nn.Sequential()`: It is a sequential container. Modules will be added to it in the order they are passed in the constructor. Please check the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html#torch.nn.Sequential) for more details.\n",
+    "\n",
+    "* `nn.Conv3d()`: It is a PyTorch module that applies a 3D convolution over an input signal composed of several input planes. More details are available on the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Conv3d.html).\n",
+    "\n",
+    "* `nn.BatchNorm3d()`: This module applies batch normalization over a 5D input as described in the [Batch Normalization paper](https://arxiv.org/abs/1502.03167). More details can be found in the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.BatchNorm3d.html).\n",
+    "\n",
+    "* `nn.MaxPool3d()`: It is also a module that applies a 3D max pooling over an input signal composed of several input planes. Please have a look on this [documentation](https://pytorch.org/docs/stable/generated/torch.nn.MaxPool3d.html) for more details.\n",
+    "\n",
+    "* `nn.Linear()`: It is a module that applies a linear transformation to the incoming data. More details can be found in its [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html#linear).\n",
+    "\n",
+    "* `nn.ReLU()`: It is also a module that applies element-wise the rectified linear unit function. Its [documentation](https://pytorch.org/docs/stable/generated/torch.nn.ReLU.html#relu) can explain more.\n",
+    "\n",
+    "* `nn.Dropout()`: This module randomly zeroes some of the elements of the input tensor with probability `p`. Check the [documentation](https://pytorch.org/docs/stable/generated/torch.nn.Dropout.html#dropout) for more details."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "2_FP6ZyGwLwC"
+   },
+   "outputs": [],
+   "source": [
+    "import torch.nn as nn\n",
+    "\n",
+    "class BlockFrameModel(nn.Module):\n",
+    "    def __init__(self, n_classes):\n",
+    "        super(BlockFrameModel, self).__init__()\n",
+    "\n",
+    "        self.conv = nn.Sequential(\n",
+    "            nn.Conv3d(1, 16, kernel_size=(4, 5, 5)),\n",
+    "            nn.BatchNorm3d(16),\n",
+    "            nn.ReLU(),\n",
+    "            nn.MaxPool3d(kernel_size=(1, 2, 2)),\n",
+    "            nn.Dropout(0.5),\n",
+    "            nn.Conv3d(16, 32, kernel_size=(4, 3, 3)),\n",
+    "            nn.BatchNorm3d(32),\n",
+    "            nn.ReLU(),\n",
+    "            nn.MaxPool3d(kernel_size=(2, 2, 2)),\n",
+    "            nn.Dropout(0.5),\n",
+    "            nn.Conv3d(32, 64, kernel_size=(3, 3, 3)),\n",
+    "            nn.BatchNorm3d(64),\n",
+    "            nn.ReLU(),\n",
+    "            nn.MaxPool3d(kernel_size=(2, 2, 2)),\n",
+    "            nn.Dropout(0.5))\n",
+    "\n",
+    "        self.fc = nn.Sequential(\n",
+    "            nn.Linear(2560, 128),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Dropout(0.5),\n",
+    "            nn.Linear(128, n_classes))\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        out = self.conv(x)\n",
+    "        out = out.view(out.size(0), -1)\n",
+    "        out = self.fc(out)\n",
+    "        return out"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "oap6-7RKG0s7"
+   },
+   "source": [
+    "### Average Meter\n",
+    "It is a simple class for keeping training statistics, such as losses and accuracies etc. The `.val` field usually holds the statistics for the current batch, whereas the `.avg` field hold statistics for the current epoch."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JeLH7fbOHDhH"
+   },
+   "outputs": [],
+   "source": [
+    "class AverageMeter(object):\n",
+    "    \"\"\"Computes and stores the average and current value\"\"\"\n",
+    "    def __init__(self):\n",
+    "        self.reset()\n",
+    "\n",
+    "    def reset(self):\n",
+    "        self.val = 0\n",
+    "        self.avg = 0\n",
+    "        self.sum = 0\n",
+    "        self.count = 0\n",
+    "\n",
+    "    def update(self, val, n=1):\n",
+    "        self.val = val\n",
+    "        self.sum += val * n\n",
+    "        self.count += n\n",
+    "        self.avg = self.sum / self.count"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "F-zN4n7LJrAY"
+   },
+   "source": [
+    "### Train and Test Functions\n",
+    "Dataset/model independent train and test functions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "SrWHdjf3waDZ"
+   },
+   "outputs": [],
+   "source": [
+    "from tqdm.notebook import tqdm\n",
+    "import torch.nn.functional as F\n",
+    "##define train function\n",
+    "def train(model, data_loader, optimizer, device):\n",
+    "    # meter\n",
+    "    loss_meter = AverageMeter()\n",
+    "    # switch to train mode\n",
+    "    model.train()\n",
+    "    tk = tqdm(data_loader, total=int(len(data_loader)), desc='Training', unit='frames', leave=False)\n",
+    "    for batch_idx, data in enumerate(tk):\n",
+    "        # fetch the data\n",
+    "        frame, label = data[0], data[1]\n",
+    "        # after fetching the data, transfer the model to the\n",
+    "        # required device, in this example the device is gpu\n",
+    "        # transfer to gpu can also be done by\n",
+    "        frame, label = frame.to(device), label.to(device)\n",
+    "        # compute the forward pass\n",
+    "        output = model(frame)\n",
+    "        # compute the loss function\n",
+    "        loss_this = F.cross_entropy(output, label)\n",
+    "        # initialize the optimizer\n",
+    "        optimizer.zero_grad()\n",
+    "        # compute the backward pass\n",
+    "        loss_this.backward()\n",
+    "        # update the parameters\n",
+    "        optimizer.step()\n",
+    "        # update the loss meter\n",
+    "        loss_meter.update(loss_this.item(), label.shape[0])\n",
+    "        tk.set_postfix({\"loss\": loss_meter.avg})\n",
+    "    print('Train: Average loss: {:.4f}\\n'.format(loss_meter.avg))\n",
+    "\n",
+    "##define test function\n",
+    "def test(model, data_loader, device):\n",
+    "    # meters\n",
+    "    loss_meter = AverageMeter()\n",
+    "    acc_meter = AverageMeter()\n",
+    "    # switch to test mode\n",
+    "    correct = 0\n",
+    "    model.eval()\n",
+    "    tk = tqdm(data_loader, total=int(len(data_loader)), desc='Test', unit='frames', leave=False)\n",
+    "    for batch_idx, data in enumerate(tk):\n",
+    "        # fetch the data\n",
+    "        frame, label = data[0], data[1]\n",
+    "        # after fetching the data transfer the model to the\n",
+    "        # required device, in this example the device is gpu\n",
+    "        # transfer to gpu can also be done by\n",
+    "        frame, label = frame.to(device), label.to(device)\n",
+    "        # since we dont need to backpropagate loss in testing,\n",
+    "        # we dont keep the gradient\n",
+    "        with torch.no_grad():\n",
+    "            output = model(frame)\n",
+    "        # compute the loss function just for checking\n",
+    "        loss_this = F.cross_entropy(output, label)\n",
+    "        # get the index of the max log-probability\n",
+    "        pred = output.argmax(dim=1, keepdim=True)\n",
+    "        # check which of the predictions are correct\n",
+    "        correct_this = pred.eq(label.view_as(pred)).sum().item()\n",
+    "        # accumulate the correct ones\n",
+    "        correct += correct_this\n",
+    "        # compute accuracy\n",
+    "        acc_this = correct_this / label.shape[0] * 100.0\n",
+    "        # update the loss and accuracy meter\n",
+    "        acc_meter.update(acc_this, label.shape[0])\n",
+    "        loss_meter.update(loss_this.item(), label.shape[0])\n",
+    "    print('Test: Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\\n'.format(\n",
+    "        loss_meter.avg, correct, len(data_loader.dataset), acc_meter.avg))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6s8RdNhKSzK1"
+   },
+   "source": [
+    "## Train and Test"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mYQgGE9gS2PC"
+   },
+   "source": [
+    "### Single Frame Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "sMWS0PreVZWU"
+   },
+   "source": [
+    "#### Parameters and Model Instantiation\n",
+    "Select the correct dataset and model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "4mAUBPogU6aY"
+   },
+   "outputs": [],
+   "source": [
+    "# 1. Create Dataset\n",
+    "from pathlib import Path\n",
+    "dir_pickle = Path('KTH_pickle/')\n",
+    "\n",
+    "train_set = SingleFrameDataset(dir_pickle, \"train\")\n",
+    "test_set = SingleFrameDataset(dir_pickle, \"test\")\n",
+    "\n",
+    "# 2. Create Dataloader\n",
+    "from torch.utils.data import DataLoader\n",
+    "batch_size = 64\n",
+    "loader_args = dict(batch_size=batch_size, num_workers=1, pin_memory=True)\n",
+    "train_loader = DataLoader(train_set, shuffle=True, **loader_args)\n",
+    "test_loader = DataLoader(test_set, shuffle=False, drop_last=True, **loader_args)\n",
+    "\n",
+    "# 3. Create Model\n",
+    "device = \"cuda\"\n",
+    "model = SingleFrameModel(n_classes=6)\n",
+    "model = model.to(device)\n",
+    "\n",
+    "# 4. Set up the optimizer, the loss, the learning rate scheduler and the loss scaling for AMP\n",
+    "from torch import optim\n",
+    "learning_rate = 0.001\n",
+    "optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=1e-8)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-938nzOl1p4W"
+   },
+   "source": [
+    "#### Training Loop\n",
+    "Training loop containing 20 training epochs. Test accuracies should be around 55%."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ljL-MscZ1lou"
+   },
+   "outputs": [],
+   "source": [
+    "num_epoch = 20\n",
+    "for epoch in range(num_epoch):\n",
+    "    train(model, train_loader, optimizer, device)\n",
+    "test(model, test_loader, device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Ggun7cQCTAQ6"
+   },
+   "source": [
+    "### Block Frame Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XdS9XXjuTJuk"
+   },
+   "source": [
+    "#### Parameters and Model Instantiation\n",
+    "Select the correct dataset and model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "bdAgghnaM4-M"
+   },
+   "outputs": [],
+   "source": [
+    "# 1. Create Dataset\n",
+    "from pathlib import Path\n",
+    "dir_pickle = Path('KTH_pickle/')\n",
+    "\n",
+    "train_set = BlockFrameDataset(dir_pickle, \"train\")\n",
+    "test_set = BlockFrameDataset(dir_pickle, \"test\")\n",
+    "\n",
+    "# 2. Create Dataloader\n",
+    "from torch.utils.data import DataLoader\n",
+    "batch_size = 64\n",
+    "loader_args = dict(batch_size=batch_size, num_workers=1, pin_memory=True)\n",
+    "train_loader = DataLoader(train_set, shuffle=True, **loader_args)\n",
+    "test_loader = DataLoader(test_set, shuffle=False, drop_last=True, **loader_args)\n",
+    "\n",
+    "# 3. Create Model\n",
+    "device = \"cuda\"\n",
+    "model = BlockFrameModel(n_classes=6)\n",
+    "model = model.to(device)\n",
+    "\n",
+    "# 4. Set up the optimizer, the loss, the learning rate scheduler and the loss scaling for AMP\n",
+    "from torch import optim\n",
+    "learning_rate = 0.001\n",
+    "optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=1e-8)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "TsPrD3fzYhG5"
+   },
+   "source": [
+    "#### Training Loop\n",
+    "Training loop containing 20 training epochs. Test accuracies should be around 67%."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "qyf1Y_fZNDKi"
+   },
+   "outputs": [],
+   "source": [
+    "num_epoch = 20\n",
+    "for epoch in range(num_epoch):\n",
+    "    train(model, train_loader, optimizer, device)\n",
+    "test(model, test_loader, device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "tTuOF4Fh2vpb"
+   },
+   "source": [
+    "### Conclusion\n",
+    "If all goes well, the `BlockFrameModel()` should achieve superior performance than the `SingleFrameModel()` because the latter does not consider temporal information in a video which is crucial for video recognition."
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "include_colab_link": true,
+   "name": "ECMM426/ECMM441 - Human Action Recognition.ipynb",
+   "private_outputs": true,
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

Downloads/.ipynb_checkpoints/PyTorch Tutorial-checkpoint.ipynb

@@ -0,0 +1,2030 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "view-in-github"
+   },
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/AnjanDutta/EEEM068/blob/main/Notebooks/PyTorch_Tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hpDRECpayKDt"
+   },
+   "source": [
+    "<H1 style=\"text-align: center\">EEEM068 - Applied Machine Learning</H1>\n",
+    "<H1 style=\"text-align: center\">Workshop 02</H1>\n",
+    "<H1 style=\"text-align: center\">PyTorch Tutorial</H1>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3aZW7eWZWg_j"
+   },
+   "source": [
+    "## Introduction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CQ9aAM9AyKDx"
+   },
+   "source": [
+    "PyTorch is an open source machine/deep learning framework that allows you to write your own neural networks and optimize them efficiently. However, PyTorch is not the only framework of its kind. Alternatives to PyTorch include [TensorFlow](https://www.tensorflow.org/), [JAX](https://github.com/google/jax#quickstart-colab-in-the-cloud) and [Caffe](http://caffe.berkeleyvision.org/) etc. We choose PyTorch because it is well established, popular and has a huge developer community (supported by Meta/Facebook), is very flexible and especially used in research."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "WDqXKGwVw5VQ"
+   },
+   "source": [
+    "## PyTorch Versions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "YNagAs00YbRO"
+   },
+   "source": [
+    "As of February 2026, the current stable version of PyTorch on Colab is 2.9.0, eventually with some CUDA version (Cuda 12.8). The PyTorch version can be checked with the following line of code, which first import PyTorch and then print the `__version__` variable. Note that the package is called `torch`, based on its original framework [Torch](http://torch.ch/)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "zDcKMfz1ZeQB"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "print(\"Using torch\", torch.__version__)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "iFPzDt_2yKD1"
+   },
+   "source": [
+    "## Basics of PyTorch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hMyWsVfWyKD2"
+   },
+   "source": [
+    "As in every machine learning framework, PyTorch provides functions that are stochastic like generating random numbers. However, a very good practice is to setup your code to be reproducible with the exact same random numbers. This is why we set a seed below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "jXJtposLyKD2"
+   },
+   "outputs": [],
+   "source": [
+    "torch.manual_seed(42) # Setting the seed"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kUqFQ7q1bRao"
+   },
+   "source": [
+    "### Tensors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Me76FJ5cyKD2"
+   },
+   "source": [
+    "Tensors are the PyTorch equivalent to Numpy arrays, with the addition to also have support for GPU acceleration. The name \"tensor\" is a generalization of concepts you already know. For instance, a vector is a 1-D tensor, and a matrix a 2-D tensor. When working with neural networks, we will use tensors of various shapes and number of dimensions. Most common functions you know from Numpy can be used on tensors as well. Actually, since Numpy arrays are so similar to tensors, we can convert most tensors to Numpy arrays and back."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "STQ4KUSwbXRi"
+   },
+   "source": [
+    "#### Initialization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-ldy1KWFbaBi"
+   },
+   "source": [
+    "Let's first start by looking at different ways of creating a tensor. There are many possible options, the simplest one is to call `torch.Tensor` passing the desired shape as input argument:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Ws4H24EYyKD3"
+   },
+   "outputs": [],
+   "source": [
+    "x = torch.Tensor(2, 3, 4) # Creates a tensor of shape [2, 3, 4]\n",
+    "print(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uVpDx-T0yKD3"
+   },
+   "source": [
+    "The function `torch.Tensor` allocates memory for the desired tensor, but reuses any values that have already been in the memory. To directly assign values to the tensor during initialization, there are many alternatives including:\n",
+    "\n",
+    "* `torch.zeros`: Creates a tensor filled with zeros\n",
+    "* `torch.ones`: Creates a tensor filled with ones\n",
+    "* `torch.rand`: Creates a tensor with random values uniformly sampled between 0 and 1\n",
+    "* `torch.randn`: Creates a tensor with random values sampled from a normal distribution with mean 0 and variance 1\n",
+    "* `torch.arange`: Creates a tensor containing the values $N,N+1,N+2,...,M$\n",
+    "* `torch.Tensor` (input list): Creates a tensor from the list elements you provide"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "yQtpXfWeyKD4"
+   },
+   "outputs": [],
+   "source": [
+    "# Create a tensor from a (nested) list\n",
+    "x = torch.Tensor([[1, 2], [3, 4]])\n",
+    "print(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "8awQ54BPyKD4"
+   },
+   "outputs": [],
+   "source": [
+    "# Create a tensor with random values between 0 and 1 with the shape [2, 3, 4]\n",
+    "x = torch.rand(2, 3, 4)\n",
+    "print(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NJCmVHByyKD4"
+   },
+   "source": [
+    "You can obtain the shape of a tensor in the same way as in Numpy (`x.shape`), or using the `.size` method:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "kbshkJFlyKD5"
+   },
+   "outputs": [],
+   "source": [
+    "print(\"Shape:\", x.shape)\n",
+    "\n",
+    "print(\"Size:\", x.size())\n",
+    "\n",
+    "dim1, dim2, dim3 = x.size()\n",
+    "print(\"Size:\", dim1, dim2, dim3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "wqU-hvDMfzXE"
+   },
+   "source": [
+    "#### Tensor to Numpy, and Numpy to Tensor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mlgyRypPyKD5"
+   },
+   "source": [
+    "Tensors can be converted to Numpy arrays, and Numpy arrays back to tensors. To transform a Numpy array into a tensor, we can use the function `torch.from_numpy`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "5So3mR1fyKD5"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "np_arr = np.array([[1, 2], [3, 4]])\n",
+    "tensor = torch.from_numpy(np_arr)\n",
+    "\n",
+    "print(\"Numpy array:\", np_arr)\n",
+    "print(\"PyTorch tensor:\", tensor)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9ZhbSdmWyKD5"
+   },
+   "source": [
+    "To transform a PyTorch tensor back to a Numpy array, we can use the function `.numpy()` on tensors:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "lHpBvt7ryKD5"
+   },
+   "outputs": [],
+   "source": [
+    "tensor = torch.arange(4)\n",
+    "np_arr = tensor.numpy()\n",
+    "\n",
+    "print(\"PyTorch tensor:\", tensor)\n",
+    "print(\"Numpy array:\", np_arr)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6sj4hQR1yKD6"
+   },
+   "source": [
+    "The conversion of tensors to Numpy require the tensor to be on the CPU, and not the GPU (more on GPU support in a later section). In case you have a tensor on GPU, you need to call `.cpu()` on the tensor beforehand. Hence, you get a line like `np_arr = tensor.cpu().numpy()`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Q_Z4B31kfuwG"
+   },
+   "source": [
+    "#### Operations"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CyPh-BetyKD6"
+   },
+   "source": [
+    "Most operations that exist in Numpy, also exist in PyTorch. A full list of operations can be found in the [PyTorch documentation](https://pytorch.org/docs/stable/tensors.html#), but we will review the most important ones here.\n",
+    "\n",
+    "The simplest operation is to add two tensors:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ymI_kL7WyKD6"
+   },
+   "outputs": [],
+   "source": [
+    "x1 = torch.rand(2, 3)\n",
+    "x2 = torch.rand(2, 3)\n",
+    "y = x1 + x2\n",
+    "\n",
+    "print(\"X1\", x1)\n",
+    "print(\"X2\", x2)\n",
+    "print(\"Y\", y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FzxUmB52yKD6"
+   },
+   "source": [
+    "Calling `x1 + x2` creates a new tensor containing the sum of the two inputs. However, we can also use in-place operations that are applied directly on the memory of a tensor. We therefore change the values of `x2` without the chance to re-accessing the values of `x2` before the operation. An example is shown below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "lDVRRhYUyKD7"
+   },
+   "outputs": [],
+   "source": [
+    "x1 = torch.rand(2, 3)\n",
+    "x2 = torch.rand(2, 3)\n",
+    "print(\"X1 (before)\", x1)\n",
+    "print(\"X2 (before)\", x2)\n",
+    "\n",
+    "x2.add_(x1)\n",
+    "print(\"X1 (after)\", x1)\n",
+    "print(\"X2 (after)\", x2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7_zEJjhUyKD7"
+   },
+   "source": [
+    "In-place operations are usually marked with a underscore postfix (e.g. \"add_\" instead of \"add\")."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fkls4uTMjrlx"
+   },
+   "source": [
+    "#### `torch.arange()`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "pLbFkfC6hZNt"
+   },
+   "source": [
+    "`torch.arange()` returns a 1-D tensor of size $\\lceil{\\frac{\\text{end} - \\text{start}}{\\text{step}}}\\rceil$ with values from the interval `[start, end)` taken with common difference `step` beginning from `start`. It mostly works as the `range()` function in Numpy. For more details, please see the [documentation](https://pytorch.org/docs/stable/generated/torch.arange.html#torch-arange)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "semrM0JbyKD7"
+   },
+   "outputs": [],
+   "source": [
+    "x = torch.arange(6)\n",
+    "print(\"X\", x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "YszyduPpkUBZ"
+   },
+   "source": [
+    "#### `.view()`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "p5pKriuXg8VO"
+   },
+   "source": [
+    "A tensor of size (2, 3) can be re-organized to any other shape with the same number of elements (e.g. a tensor of size (6), or (3,2), ...). In PyTorch, this operation is called `view`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "K-4HwV-1yKD7"
+   },
+   "outputs": [],
+   "source": [
+    "x = x.view(2, 3)\n",
+    "print(\"X\", x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "DtPoljp1yKD7"
+   },
+   "outputs": [],
+   "source": [
+    "x = x.permute(1, 0) # Swapping dimension 0 and 1\n",
+    "print(\"X\", x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ALaEhyWdkDdJ"
+   },
+   "source": [
+    "#### Matrix multiplication"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "LNyWsbTzyKD7"
+   },
+   "source": [
+    "Other commonly used operations include matrix multiplications, which are essential for neural networks. Quite often, we have an input vector $\\mathbf{x}$, which is transformed using a learned weight matrix $\\mathbf{W}$. There are multiple ways and functions to perform matrix multiplication, some of which are listed below:\n",
+    "\n",
+    "* `torch.matmul`: Performs the matrix product over two tensors, where the specific behavior depends on the dimensions. If both inputs are matrices (2-dimensional tensors), it performs the standard matrix product. For higher dimensional inputs, the function supports broadcasting (for details see the [documentation](https://pytorch.org/docs/stable/generated/torch.matmul.html?highlight=matmul#torch.matmul)). Similar to Numpy, it can also be written as `a @ b`.\n",
+    "* `torch.mm`: Performs the matrix product over two matrices, but doesn't support broadcasting (see [documentation](https://pytorch.org/docs/stable/generated/torch.mm.html?highlight=torch%20mm#torch.mm)).\n",
+    "* `torch.bmm`: Performs the matrix product with a support batch dimension. If the first tensor $T$ is of shape ($b\\times n\\times m$), and the second tensor $R$ ($b\\times m\\times p$), the output $O$ is of shape ($b\\times n\\times p$), and has been calculated by performing $b$ matrix multiplications of the submatrices of $T$ and $R$: $O_i = T_i @ R_i$.\n",
+    "* `torch.einsum`: Performs matrix multiplications and more (i.e. sums of products) using the Einstein summation convention. Explanation of the Einstein sum can be found in assignment 1.\n",
+    "\n",
+    "Usually, we use `torch.matmul` or `torch.bmm`. We can try a matrix multiplication with `torch.matmul` below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "IPfjNkQ9yKD8"
+   },
+   "outputs": [],
+   "source": [
+    "x = torch.arange(6)\n",
+    "x = x.view(2, 3)\n",
+    "print(\"X\", x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "89BudWvryKD8"
+   },
+   "outputs": [],
+   "source": [
+    "W = torch.arange(9).view(3, 3) # We can also stack multiple operations in a single line\n",
+    "print(\"W\", W)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "VrwwqU5dyKD8"
+   },
+   "outputs": [],
+   "source": [
+    "h = torch.matmul(x, W) # Verify the result by calculating it by hand too!\n",
+    "print(\"h\", h)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NlL4qEXAkcVJ"
+   },
+   "source": [
+    "#### Indexing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uQ_URivAyKD8"
+   },
+   "source": [
+    "We often have the situation where we need to select a part of a tensor. Indexing in PyTorch works just like in Numpy, so let's try it:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "7SSPTOJ6yKD8"
+   },
+   "outputs": [],
+   "source": [
+    "x = torch.arange(12).view(3, 4)\n",
+    "print(\"X\", x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Ne9br4uSyKD8"
+   },
+   "outputs": [],
+   "source": [
+    "print(x[:, 1])   # Second column"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "snXYszDAyKD9"
+   },
+   "outputs": [],
+   "source": [
+    "print(x[0])      # First row"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "WmDokJuVyKD9"
+   },
+   "outputs": [],
+   "source": [
+    "print(x[:2, -1]) # First two rows, last column"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "bXIJhtnbyKD9"
+   },
+   "outputs": [],
+   "source": [
+    "print(x[1:3, :]) # Middle two rows"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XUpotMGSyKD9"
+   },
+   "source": [
+    "### Gradients, Computational graph and Backpropagation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "yYttGusdKXn6"
+   },
+   "source": [
+    "#### Gradients"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "bvCU_mMuKaoU"
+   },
+   "source": [
+    "We use a deep learning framework for implementing neural networks which are effectively a combination of several differentiable functions parameterized with weights that we aim to learn or adjust during the training procedure. While training, the gradients of those parameters or weights are computed to update them via the delta rule. One of the main reasons for using deep learning framework, such as PyTorch, TensorFlow is that we can automatically obatin the **derivatives** or **gradients** of those weights if we have a valid differentiable functions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "8EKJIwkfKef3"
+   },
+   "source": [
+    "#### Computational graph"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uo3quHoWKh3a"
+   },
+   "source": [
+    "We define our function by manipulating the input, usually by a series of matrix multiplications with weight matrices ($\\mathbf{W}$) and additions with bias vectors ($b$). As we manipulate our input, we are automatically creating a **computational graph** showing how to arrive at the output from the input. In PyTorch, we just define the manipulations and it keeps track of that graph by design.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "iEpXNRNqEeTC"
+   },
+   "source": [
+    "#### Backpropagation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "wwdEDnmnEg29"
+   },
+   "source": [
+    "Given an input $\\mathbf{x}$, we obtain the output $y$ by manipulating that input via series of matrix multiplications with weight matrices ($\\mathbf{W}$) and additions with bias vectors ($b$). As we manipulate our input, we automatically create a computational graph showing how to arrive at the output from the input. We then define an error measure or **loss function** that tells us how wrong our network is. In other words, how good or bad it is in predicting output $y$ from input $\\mathbf{x}$. Based on this error measure, we can use the gradients to update or **backpropagate** the weights $\\mathbf{W}$ that were responsible for the output, so that the next time we present input $\\mathbf{x}$ to our network, the output will be closer to what we want."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FLepWzW1L6tC"
+   },
+   "source": [
+    "#### `.requires_grad()`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "tk32gBuMEwTx"
+   },
+   "source": [
+    "In PyTorch, whether a particular tensor containing a set of parameters requires gradient or not is determined by the associated flag `requires_grad`. By default, when we create a tensor, it does not require gradients."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ejXjJ9ECyKD9"
+   },
+   "outputs": [],
+   "source": [
+    "x = torch.ones((3,))\n",
+    "print(x.requires_grad)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "bc3i5kVRyKD9"
+   },
+   "source": [
+    "We can change this for an existing tensor using the function `requires_grad_()` (underscore indicating that this is a in-place operation). Alternatively, when creating a tensor, you can pass the argument `requires_grad=True` to most initializers we have seen above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "7weDjnh5yKD9"
+   },
+   "outputs": [],
+   "source": [
+    "x.requires_grad_(True)\n",
+    "print(x.requires_grad)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RBQlwCyiDZ05"
+   },
+   "source": [
+    "#### Example"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "axzFVIkgyKD-"
+   },
+   "source": [
+    "In order to get familiar with the concept of a computation graph, we will create one for the following function:\n",
+    "\n",
+    "$$y = \\frac{1}{|x|}\\sum_i \\left[(x_i + 5)^3 + 7\\right]$$\n",
+    "\n",
+    "You could imagine that $x$ are our parameters, and we want to optimize (either maximize or minimize) the output $y$. For this, we want to obtain the gradients $\\partial y / \\partial \\mathbf{x}$. For our example, we'll use $\\mathbf{x}=[0,1,2,3,4]$ as our input."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "T7Ts_CHgyKD-"
+   },
+   "outputs": [],
+   "source": [
+    "x = torch.arange(5, dtype=torch.float32, requires_grad=True) # Only float tensors can have gradients\n",
+    "print(\"X\", x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "lOoDHPT-yKD-"
+   },
+   "source": [
+    "Now let's build the computation graph step by step. You can combine multiple operations in a single line, but we will separate them here to get a better understanding of how each operation is added to the computation graph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "85m78jwHyKD-"
+   },
+   "outputs": [],
+   "source": [
+    "a = x + 5\n",
+    "b = a ** 3\n",
+    "c = b + 7\n",
+    "y = c.mean()\n",
+    "print(\"Y\", y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "U9Xjh2ZoyKD-"
+   },
+   "source": [
+    "Using the statements above, we have created a computation graph that looks similar to the figure below:\n",
+    "\n",
+    "<center style=\"width: 100%\"><img src=\"https://github.com/AnjanDutta/SharedFigures/blob/main/comp_graph.png?raw=true\" width=\"500px\"></center>\n",
+    "\n",
+    "We calculate $a$ based on the inputs $x$ and the constant $5$, $b$ is $a$ cubed, and so on. The visualization is an abstraction of the dependencies between inputs and outputs of the operations we have applied.\n",
+    "Each node of the computation graph has automatically defined a function for calculating the gradients with respect to its inputs, `grad_fn`. You can see this when we printed the output tensor $y$. This is why the computation graph is usually visualized in the reverse direction (arrows point from the result to the inputs). We can perform backpropagation on the computation graph by calling the function `backward()` on the last output, which effectively calculates the gradients for each tensor that has the property `requires_grad=True`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "7_A1RRZUyKD-"
+   },
+   "outputs": [],
+   "source": [
+    "y.backward()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Lp9j77yKyKD_"
+   },
+   "source": [
+    "`x.grad` will now contain the gradient $\\partial y/ \\partial \\mathcal{x}$, and this gradient indicates how a change in $\\mathbf{x}$ will affect output $y$ given the current input $\\mathbf{x}=[0,1,2,3,4]$:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "jSnCN6REyKD_"
+   },
+   "outputs": [],
+   "source": [
+    "print(x.grad)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "j5XNxMfryKD_"
+   },
+   "source": [
+    "We can also verify these gradients by hand. We will calculate the gradients using the chain rule, in the same way as PyTorch did it:\n",
+    "\n",
+    "$$\\frac{\\partial y}{\\partial x_i} = \\frac{\\partial y}{\\partial c_i}\\frac{\\partial c_i}{\\partial b_i}\\frac{\\partial b_i}{\\partial a_i}\\frac{\\partial a_i}{\\partial x_i}$$\n",
+    "\n",
+    "Note that we have simplified this equation to index notation, and by using the fact that all operation besides the mean do not combine the elements in the tensor. The partial derivatives are:\n",
+    "\n",
+    "$$\n",
+    "\\frac{\\partial a_i}{\\partial x_i} = 1,\\hspace{1cm}\n",
+    "\\frac{\\partial b_i}{\\partial a_i} = 3\\cdot a_i^2\\hspace{1cm}\n",
+    "\\frac{\\partial c_i}{\\partial b_i} = 1\\hspace{1cm}\n",
+    "\\frac{\\partial y}{\\partial c_i} = \\frac{1}{5}\n",
+    "$$\n",
+    "\n",
+    "Hence, with the input being $\\mathbf{x}=[0,1,2,3,4]$, our gradients are $\\frac{\\partial y}{\\partial \\mathbf{x}}=[15, \\frac{108}{5}, \\frac{147}{5}, \\frac{192}{5},\\frac{243}{5}]$. The previous code cell should have printed the same result."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NbgfwdQlwudF"
+   },
+   "source": [
+    "### GPU support"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "LCd3NuIYyKD_"
+   },
+   "source": [
+    "A crucial feature of PyTorch is the support of Graphics Processing Unit (GPU). A GPU can perform many thousands of small operations in parallel, making it very well suitable for performing large matrix operations in neural networks. When comparing GPUs to CPUs, we can list the following main differences (credit: [Kevin Krewell, 2009](https://blogs.nvidia.com/blog/2009/12/16/whats-the-difference-between-a-cpu-and-a-gpu/))\n",
+    "\n",
+    "CPUs and GPUs have both different advantages and disadvantages, which is why many computers contain both components and use them for different tasks. In case you are not familiar with GPUs, you can read up more details in this [NVIDIA blog post](https://blogs.nvidia.com/blog/2009/12/16/whats-the-difference-between-a-cpu-and-a-gpu/) or [here](https://www.intel.com/content/www/us/en/products/docs/processors/what-is-a-gpu.html).\n",
+    "\n",
+    "GPUs can accelerate the training of your network up to a factor of $100$ which is essential for large neural networks. PyTorch implements a lot of functionality for supporting GPUs (mostly those of NVIDIA due to the libraries [CUDA](https://developer.nvidia.com/cuda-zone) and [cuDNN](https://developer.nvidia.com/cudnn)). First, let's check whether you have a GPU available:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "L7IUQhSZyKD_"
+   },
+   "outputs": [],
+   "source": [
+    "gpu_avail = torch.cuda.is_available()\n",
+    "print(f\"Is the GPU available? {gpu_avail}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "YT-miN_jyKD_"
+   },
+   "source": [
+    "If you have a GPU on your computer but the command above returns False, make sure you have the correct CUDA-version installed. On Colab, please change it if necessary (CUDA 12.4 is currently common on Colab). On Google Colab, make sure that you have selected a GPU in your runtime setup (in the menu, check under `Runtime -> Change runtime type`).\n",
+    "\n",
+    "By default, all tensors you create are stored on the CPU. We can push a tensor to the GPU by using the function `.to(...)`, or `.cuda()`. However, it is often a good practice to define a `device` object in your code which points to the GPU if you have one, and otherwise to the CPU. Then, you can write your code with respect to this device object, and it allows you to run the same code on both a CPU-only system, and one with a GPU. Let's try it below. We can specify the device as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "iYI9tssMyKD_"
+   },
+   "outputs": [],
+   "source": [
+    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
+    "print(\"Device\", device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "l7gtUjj3yKEA"
+   },
+   "source": [
+    "Now let's create a tensor and push it to the device:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "AEKx_99SyKEA"
+   },
+   "outputs": [],
+   "source": [
+    "x = torch.zeros(2, 3)\n",
+    "x = x.to(device)\n",
+    "print(\"X\", x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "8UrSdpFzyKEA"
+   },
+   "source": [
+    "In case you have a GPU, you should now see the attribute `device='cuda:0'` being printed next to your tensor. The zero next to cuda indicates that this is the zero-th GPU device on your computer. PyTorch also supports multi-GPU systems, but this you will only need once you have very big networks to train (if interested, see the [PyTorch documentation](https://pytorch.org/docs/stable/distributed.html#distributed-basics)). We can also compare the runtime of a large matrix multiplication on the CPU with a operation on the GPU:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "PMEsWrjMyKEA"
+   },
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "x = torch.randn(5000, 5000)\n",
+    "\n",
+    "## CPU version\n",
+    "start_time = time.time()\n",
+    "_ = torch.matmul(x, x)\n",
+    "end_time = time.time()\n",
+    "print(f\"CPU time: {(end_time - start_time):6.5f}s\")\n",
+    "\n",
+    "## GPU version\n",
+    "x = x.to(device)\n",
+    "_ = torch.matmul(x, x)  # First operation to 'burn in' GPU\n",
+    "# CUDA is asynchronous, so we need to use different timing functions\n",
+    "start = torch.cuda.Event(enable_timing=True)\n",
+    "end = torch.cuda.Event(enable_timing=True)\n",
+    "start.record()\n",
+    "_ = torch.matmul(x, x)\n",
+    "end.record()\n",
+    "torch.cuda.synchronize()  # Waits for everything to finish running on the GPU\n",
+    "print(f\"GPU time: {0.001 * start.elapsed_time(end):6.5f}s\")  # Milliseconds to seconds"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MFoSS6lCyKEA"
+   },
+   "source": [
+    "Depending on the size of the operation and the CPU/GPU in your system, the speedup of this operation can be >50x. As `matmul` operations are very common in neural networks, we can already see the great benefit of training a NN on a GPU. The time estimate can be relatively noisy here because we haven't run it for multiple times. Feel free to extend this, but it also takes longer to run.\n",
+    "\n",
+    "When generating random numbers, the seed between CPU and GPU is not synchronized. Hence, we need to set the seed on the GPU separately to ensure a reproducible code. Note that due to different GPU architectures, running the same code on different GPUs does not guarantee the same random numbers. Still, we don't want that our code gives us a different output every time we run it on the exact same hardware. Hence, we also set the seed on the GPU:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Rw89vknyyKEA"
+   },
+   "outputs": [],
+   "source": [
+    "# GPU operations have a separate seed we also want to set\n",
+    "if torch.cuda.is_available():\n",
+    "    torch.cuda.manual_seed(42)\n",
+    "    torch.cuda.manual_seed_all(42)\n",
+    "\n",
+    "# Additionally, some operations on a GPU are implemented stochastic for efficiency\n",
+    "# We want to ensure that all operations are deterministic on GPU (if used) for reproducibility\n",
+    "torch.backends.cudnn.deterministic = True\n",
+    "torch.backends.cudnn.benchmark = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HCjp1yYIyKEA"
+   },
+   "source": [
+    "## Example: Gaussian or continuous XNOR\n",
+    "\n",
+    "If we want to build a neural network in PyTorch, we could specify all our parameters (weight matrices, bias vectors) using `Tensors` (with `requires_grad=True`), ask PyTorch to calculate the gradients and then adjust the parameters. But things can quickly get cumbersome if we have a lot of parameters. In PyTorch, there is a package called `torch.nn` that makes building neural networks more convenient.\n",
+    "\n",
+    "We will introduce the libraries and all additional parts you might need to train a neural network in PyTorch, using a simple example classifier on a simple yet well known example: XNOR. Given two binary inputs $x_1$ and $x_2$, the label to predict is $1$ if $x_1$ equal to $x_2$ and $0$ if $x_1$ not equal to $x_2$. The example became famous by the fact that a single neuron, i.e. a linear classifier, cannot learn this simple function. Hence, we will learn how to build a small neural network that can learn this function. To make it a little bit more interesting, we move the XNOR into continuous space and introduce some Gaussian noise on the binary inputs. Our desired separation of an XNOR dataset could look as follows:\n",
+    "\n",
+    "<center style=\"width: 100%\"><img src=\"https://github.com/AnjanDutta/SharedFigures/blob/main/xnor_plot.png?raw=true\" width=\"500px\"></center>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "gXP2REOmwnQM"
+   },
+   "source": [
+    "### The model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "lvokYLAvyKEA"
+   },
+   "source": [
+    "The package `torch.nn` defines a series of useful classes like linear networks layers, activation functions, loss functions etc. A full list can be found [here](https://pytorch.org/docs/stable/nn.html). In case you need a certain network layer, check the documentation of the package first before writing the layer yourself as the package likely contains the code for it already. We import it below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "G7rc32GwyKEA"
+   },
+   "outputs": [],
+   "source": [
+    "import torch.nn as nn"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "eRv10SNSyKEB"
+   },
+   "source": [
+    "Additionally to `torch.nn`, there is also `torch.nn.functional`. It contains functions that are used in network layers. This is in contrast to `torch.nn` which defines them as `nn.Modules` (more on it below), and `torch.nn` actually uses a lot of functionalities from `torch.nn.functional`. Hence, the functional package is useful in many situations, and so we import it as well here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "BKV0ia61yKEB"
+   },
+   "outputs": [],
+   "source": [
+    "import torch.nn.functional as F"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "67AkppacyKEB"
+   },
+   "source": [
+    "#### nn.Module\n",
+    "\n",
+    "In PyTorch, a neural network is built up out of modules. Modules can contain other modules, and a neural network is considered to be a module itself as well. The basic template of a module is as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "IMKZ1UiIyKEB"
+   },
+   "outputs": [],
+   "source": [
+    "class MyModule(nn.Module):\n",
+    "\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "        # Some init for my module\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        # Function for performing the calculation of the module.\n",
+    "        pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "U_P3vY2dyKEB"
+   },
+   "source": [
+    "The `forward()` function is where the computation of the module is taken place, and is executed when you call the module (`nn = MyModule(); nn(x)`). In the `__init__()` function, we usually create the parameters of the module, using `nn.Parameter`, or defining other modules that are used in the forward function. The backward calculation is done automatically, but could be overwritten as well if wanted.\n",
+    "\n",
+    "#### Simple classifier\n",
+    "We can now make use of the pre-defined modules in the `torch.nn` package, and define our own small neural network. We will use a minimal network with a input layer, one hidden layer with tanh as activation function, and a output layer. In other words, our networks should look something like this:\n",
+    "\n",
+    "<center width=\"100%\"><img src=\"https://raw.githubusercontent.com/AnjanDutta/SharedFigures/5beba0ea58e54079bcff6663eb4d8e7a7969d142/small_neural_network.svg\" width=\"400px\"></center>\n",
+    "\n",
+    "The input neurons are shown in blue, which represent the coordinates $x_1$ and $x_2$ of a data point. The hidden neurons including a tanh activation are shown in white, and the output neuron in red.\n",
+    "In PyTorch, we can define this as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "UX_CcgvTyKEB"
+   },
+   "outputs": [],
+   "source": [
+    "class SimpleClassifier(nn.Module):\n",
+    "\n",
+    "    def __init__(self, num_inputs, num_hidden, num_outputs):\n",
+    "        super().__init__()\n",
+    "        # Initialize the modules we need to build the network\n",
+    "        self.linear1 = nn.Linear(num_inputs, num_hidden)\n",
+    "        self.act_fn = nn.Tanh()\n",
+    "        self.linear2 = nn.Linear(num_hidden, num_outputs)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        # Perform the calculation of the model to determine the prediction\n",
+    "        x = self.linear1(x)\n",
+    "        x = self.act_fn(x)\n",
+    "        x = self.linear2(x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2KXcb56byKEB"
+   },
+   "source": [
+    "For the examples in this notebook, we will use a tiny neural network with two input neurons and four hidden neurons. As we perform binary classification, we will use a single output neuron. Note that we do not apply a sigmoid on the output yet. This is because other functions, especially the loss, are more efficient and precise to calculate on the original outputs instead of the sigmoid output. We will discuss the detailed reason later."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "2nqMOh43yKEB"
+   },
+   "outputs": [],
+   "source": [
+    "model = SimpleClassifier(num_inputs=2, num_hidden=4, num_outputs=1)\n",
+    "# Printing a module shows all its submodules\n",
+    "print(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "AuzsBqEqyKEB"
+   },
+   "source": [
+    "Printing the model lists all submodules it contains. The parameters of a module can be obtained by using its `parameters()` functions, or `named_parameters()` to get a name to each parameter object. For our small neural network, we have the following parameters:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ZidXJhX4yKEC"
+   },
+   "outputs": [],
+   "source": [
+    "for name, param in model.named_parameters():\n",
+    "    print(f\"Parameter {name}, shape {param.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "W6LKZ0osyKEC"
+   },
+   "source": [
+    "Each linear layer has a weight matrix of the shape `[output, input]`, and a bias of the shape `[output]`. The tanh activation function does not have any parameters. Note that parameters are only registered for `nn.Module` objects that are direct object attributes, i.e. `self.a = ...`. If you define a list of modules, the parameters of those are not registered for the outer module and can cause some issues when you try to optimize your module. There are alternatives, like `nn.ModuleList`, `nn.ModuleDict` and `nn.Sequential`, that allow you to have different data structures of modules. We will use them in a few later tutorials and explain them there."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FUjzPv20yKEC"
+   },
+   "source": [
+    "### The data\n",
+    "\n",
+    "PyTorch also provides a few functionalities to load the training and test data efficiently, summarized in the package `torch.utils.data`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Z-csKPaGyKEC"
+   },
+   "outputs": [],
+   "source": [
+    "import torch.utils.data as data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9TR6t5aVyKEC"
+   },
+   "source": [
+    "The data package defines two classes which are the standard interface for handling data in PyTorch: `data.Dataset`, and `data.DataLoader`. The dataset class provides an uniform interface to access the training/test data, while the data loader makes sure to efficiently load and stack the data points from the dataset into batches during training."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "QGrZ9jr4wi5F"
+   },
+   "source": [
+    "#### The dataset class"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2yOzJkPuyKEC"
+   },
+   "source": [
+    "The dataset class summarizes the basic functionality of a dataset in a natural way. To define a dataset in PyTorch, we simply specify two functions: `__getitem__`, and `__len__`. The get-item function has to return the $i$-th data point in the dataset, while the len function returns the size of the dataset. For the XNOR dataset, we can define the dataset class as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "_VOhsu4EyKEC"
+   },
+   "outputs": [],
+   "source": [
+    "class XNORDataset(data.Dataset):\n",
+    "\n",
+    "    def __init__(self, size, std=0.1):\n",
+    "        \"\"\"\n",
+    "        Inputs:\n",
+    "            size - Number of data points we want to generate\n",
+    "            std - Standard deviation of the noise (see generate_continuous_xnor function)\n",
+    "        \"\"\"\n",
+    "        super().__init__()\n",
+    "        self.size = size\n",
+    "        self.std = std\n",
+    "        self.generate_continuous_xnor()\n",
+    "\n",
+    "    def generate_continuous_xnor(self):\n",
+    "        # Each data point in the XNOR dataset has two variables, x and y, that can be either 0 or 1.\n",
+    "        # The label is their XNOR combination, i.e. 1 if only x equal to y and 0 if x not equal to y.\n",
+    "        data = torch.randint(low=0, high=2, size=(self.size, 2), dtype=torch.float32)\n",
+    "        label = (data[:, 0] == data[:, 1]).to(torch.long)\n",
+    "        # To make it slightly more challenging, we add a bit of gaussian noise to the data points.\n",
+    "        data += self.std * torch.randn(data.shape)\n",
+    "\n",
+    "        self.data = data\n",
+    "        self.label = label\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        # Number of data point we have. Alternatively self.data.shape[0], or self.label.shape[0]\n",
+    "        return self.size\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        # Return the idx-th data point of the dataset\n",
+    "        # If we have multiple things to return (data point and label), we can return them as tuple\n",
+    "        data_point = self.data[idx]\n",
+    "        data_label = self.label[idx]\n",
+    "        return data_point, data_label"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "8vuUacxOyKEC"
+   },
+   "source": [
+    "Let's try to create such a dataset and inspect it:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "LyHNFoEvyKEC"
+   },
+   "outputs": [],
+   "source": [
+    "dataset = XNORDataset(size=200)\n",
+    "print(\"Size of dataset:\", len(dataset))\n",
+    "print(\"Data point 0:\", dataset[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2V6Cfz7AyKED"
+   },
+   "source": [
+    "To better relate to the dataset, we visualize the samples below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "0wZalS9dyKED"
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "%matplotlib inline\n",
+    "def visualize_samples(data, label):\n",
+    "    if isinstance(data, torch.Tensor):\n",
+    "        data = data.cpu().numpy()\n",
+    "    if isinstance(label, torch.Tensor):\n",
+    "        label = label.cpu().numpy()\n",
+    "    data_0 = data[label == 0]\n",
+    "    data_1 = data[label == 1]\n",
+    "\n",
+    "    plt.figure(figsize=(4,4))\n",
+    "    plt.scatter(data_0[:,0], data_0[:,1], edgecolor=\"#333\", label=\"Class 0\")\n",
+    "    plt.scatter(data_1[:,0], data_1[:,1], edgecolor=\"#333\", label=\"Class 1\")\n",
+    "    plt.title(\"Dataset samples\")\n",
+    "    plt.ylabel(r\"$x_2$\")\n",
+    "    plt.xlabel(r\"$x_1$\")\n",
+    "    plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "BwIPc7RPyKED"
+   },
+   "outputs": [],
+   "source": [
+    "visualize_samples(dataset.data, dataset.label)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vXxG7wkVyKED"
+   },
+   "source": [
+    "#### The data loader class\n",
+    "\n",
+    "The class `torch.utils.data.DataLoader` represents a Python iterable over a dataset with support for automatic batching, multi-process data loading and many more features. The data loader communicates with the dataset using the function `__getitem__()`, and stacks its outputs as tensors over the first dimension to form a batch.\n",
+    "In contrast to the dataset class, we usually don't have to define our own data loader class, but can just create an object of it with the dataset as input. Additionally, we can configure our data loader with the following input arguments (only a selection, see full list [here](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader)):\n",
+    "\n",
+    "* `batch_size`: Number of samples to stack per batch\n",
+    "* `shuffle`: If True, the data is returned in a random order. This is important during training for introducing stochasticity.\n",
+    "* `num_workers`: Number of subprocesses to use for data loading. The default, 0, means that the data will be loaded in the main process which can slow down training for datasets where loading a data point takes a considerable amount of time (e.g. large images). More workers are recommended for those, but can cause issues on Windows computers. For tiny datasets as ours, 0 workers are usually faster.\n",
+    "* `pin_memory`: If True, the data loader will copy Tensors into CUDA pinned memory before returning them. This can save some time for large data points on GPUs. Usually a good practice to use for a training set, but not necessarily for validation and test to save memory on the GPU.\n",
+    "* `drop_last`: If True, the last batch is dropped in case it is smaller than the specified batch size. This occurs when the dataset size is not a multiple of the batch size. Only potentially helpful during training to keep a consistent batch size.\n",
+    "\n",
+    "Let's create a simple data loader below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Zu_v2xxByKED"
+   },
+   "outputs": [],
+   "source": [
+    "data_loader = data.DataLoader(dataset, batch_size=8, shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "mJoQcFgmyKED"
+   },
+   "outputs": [],
+   "source": [
+    "# next(iter(...)) catches the first batch of the data loader\n",
+    "# If shuffle is True, this will return a different batch every time we run this cell\n",
+    "# For iterating over the whole dataset, we can simple use \"for batch in data_loader: ...\"\n",
+    "data_inputs, data_labels = next(iter(data_loader))\n",
+    "\n",
+    "# The shape of the outputs are [batch_size, d_1,...,d_N] where d_1,...,d_N are the\n",
+    "# dimensions of the data point returned from the dataset class\n",
+    "print(\"Data inputs\", data_inputs.shape, \"\\n\", data_inputs)\n",
+    "print(\"Data labels\", data_labels.shape, \"\\n\", data_labels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1zcfNLYtv4ic"
+   },
+   "source": [
+    "### Optimization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2ShudEaKyKED"
+   },
+   "source": [
+    "After defining the model and the dataset, it is time to prepare the optimization of the model. During training, we will perform the following steps:\n",
+    "\n",
+    "1. Get a batch from the data loader\n",
+    "2. Obtain the predictions from the model for the batch\n",
+    "3. Calculate the loss based on the difference between predictions and labels\n",
+    "4. Backpropagation: calculate the gradients for every parameter with respect to the loss\n",
+    "5. Update the parameters of the model in the direction of the gradients\n",
+    "\n",
+    "We have seen how we can do step 1, 2 and 4 in PyTorch. Now, we will look at step 3 and 5."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mMcn4KdEv1JN"
+   },
+   "source": [
+    "#### Loss modules"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "aR-L_Wa7yKEE"
+   },
+   "source": [
+    "We can calculate the loss for a batch by simply performing a few tensor operations as those are automatically added to the computation graph. For instance, for binary classification, we can use Binary Cross Entropy (BCE) which is defined as follows:\n",
+    "\n",
+    "$$\\mathcal{L}_{BCE} = -\\sum_i \\left[ y_i \\log x_i + (1 - y_i) \\log (1 - x_i) \\right]$$\n",
+    "\n",
+    "where $y$ are our labels, and $x$ our predictions, both in the range of $[0,1]$. However, PyTorch already provides a list of predefined loss functions which we can use (see [here](https://pytorch.org/docs/stable/nn.html#loss-functions) for a full list). For instance, for BCE, PyTorch has two modules: `nn.BCELoss()`, `nn.BCEWithLogitsLoss()`. While `nn.BCELoss` expects the inputs $x$ to be in the range $[0,1]$, i.e. the output of a sigmoid, `nn.BCEWithLogitsLoss` combines a sigmoid layer and the BCE loss in a single class. This version is numerically more stable than using a plain Sigmoid followed by a BCE loss because of the logarithms applied in the loss function. Hence, it is adviced to use loss functions applied on \"logits\" where possible (remember to not apply a sigmoid on the output of the model in this case!). For our model defined above, we therefore use the module `nn.BCEWithLogitsLoss`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "fw4yFEH6yKEE"
+   },
+   "outputs": [],
+   "source": [
+    "loss_module = nn.BCEWithLogitsLoss()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6GlWgf_5vyFo"
+   },
+   "source": [
+    "#### Stochastic Gradient Descent"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Kc7inCxbyKEE"
+   },
+   "source": [
+    "For updating the parameters, PyTorch provides the package `torch.optim` that has most popular optimizers implemented. We will discuss the specific optimizers and their differences later in the course, but will for now use the simplest of them: `torch.optim.SGD`. Stochastic Gradient Descent updates parameters by multiplying the gradients with a small constant, called learning rate, and subtracting those from the parameters (hence minimizing the loss). Therefore, we slowly move towards the direction of minimizing the loss. A good default value of the learning rate for a small network as ours is 0.1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "538d8YaIyKEE"
+   },
+   "outputs": [],
+   "source": [
+    "# Input to the optimizer are the parameters of the model: model.parameters()\n",
+    "optimizer = torch.optim.SGD(model.parameters(), lr=0.1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "A3OqLcuAyKEE"
+   },
+   "source": [
+    "The optimizer provides two useful functions: `optimizer.step()`, and `optimizer.zero_grad()`. The step function updates the parameters based on the gradients as explained above. The function `optimizer.zero_grad()` sets the gradients of all parameters to zero. While this function seems less relevant at first, it is a crucial pre-step before performing backpropagation. If we call the `backward` function on the loss while the parameter gradients are non-zero from the previous batch, the new gradients would actually be added to the previous ones instead of overwriting them. This is done because a parameter might occur multiple times in a computation graph, and we need to sum the gradients in this case instead of replacing them. Hence, remember to call `optimizer.zero_grad()` before calculating the gradients of a batch."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FpAceRBPyKEE"
+   },
+   "source": [
+    "### Training\n",
+    "\n",
+    "Finally, we are ready to train our model. As a first step, we create a slightly larger dataset and specify a data loader with a larger batch size."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "fZvApVhdyKEE"
+   },
+   "outputs": [],
+   "source": [
+    "train_dataset = XNORDataset(size=2500)\n",
+    "train_data_loader = data.DataLoader(train_dataset, batch_size=128, shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-wgVr8C5yKEE"
+   },
+   "source": [
+    "Now, we can write a small training function. Remember our five steps: load a batch, obtain the predictions, calculate the loss, backpropagate, and update. Additionally, we have to push all data and model parameters to the device of our choice (GPU if available). For the tiny neural network we have, communicating the data to the GPU actually takes much more time than we could save from running the operation on GPU. For large networks, the communication time is significantly smaller than the actual runtime making a GPU crucial in these cases. Still, to practice, we will push the data to GPU here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "xQ_By4XfyKEE"
+   },
+   "outputs": [],
+   "source": [
+    "# Push model to device. Has to be only done once\n",
+    "model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EuusR5sTyKEE"
+   },
+   "source": [
+    "In addition, we set our model to training mode. This is done by calling `model.train()`. There exist certain modules that need to perform a different forward step during training than during testing (e.g. BatchNorm and Dropout), and we can switch between them using `model.train()` and `model.eval()`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "4u3-tu1fyKEE"
+   },
+   "outputs": [],
+   "source": [
+    "from tqdm.notebook import tqdm\n",
+    "def train_model(model, optimizer, data_loader, loss_module, num_epochs=100):\n",
+    "    # Set model to train mode\n",
+    "    model.train()\n",
+    "\n",
+    "    # Training loop\n",
+    "    for epoch in tqdm(range(num_epochs)):\n",
+    "        for data_inputs, data_labels in data_loader:\n",
+    "\n",
+    "            ## Step 1: Move input data to device (only strictly necessary if we use GPU)\n",
+    "            data_inputs = data_inputs.to(device)\n",
+    "            data_labels = data_labels.to(device)\n",
+    "\n",
+    "            ## Step 2: Run the model on the input data\n",
+    "            preds = model(data_inputs)\n",
+    "            preds = preds.squeeze(dim=1) # Output is [Batch size, 1], but we want [Batch size]\n",
+    "\n",
+    "            ## Step 3: Calculate the loss\n",
+    "            loss = loss_module(preds, data_labels.float())\n",
+    "\n",
+    "            ## Step 4: Perform backpropagation\n",
+    "            # Before calculating the gradients, we need to ensure that they are all zero.\n",
+    "            # The gradients would not be overwritten, but actually added to the existing ones.\n",
+    "            optimizer.zero_grad()\n",
+    "            # Perform backpropagation\n",
+    "            loss.backward()\n",
+    "\n",
+    "            ## Step 5: Update the parameters\n",
+    "            optimizer.step()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "miyLOI08yKEF"
+   },
+   "outputs": [],
+   "source": [
+    "train_model(model, optimizer, train_data_loader, loss_module)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "eJdcLsO3wEG6"
+   },
+   "source": [
+    "#### Saving a model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Hq__j4kOyKEF"
+   },
+   "source": [
+    "After finish training a model, we save the model to disk so that we can load the same weights at a later time. For this, we extract the so-called `state_dict` from the model which contains all learnable parameters. For our simple model, the state dict contains the following entries:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Me3HsoD-yKEF"
+   },
+   "outputs": [],
+   "source": [
+    "state_dict = model.state_dict()\n",
+    "print(state_dict)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0SqbNIWKyKEF"
+   },
+   "source": [
+    "To save the state dictionary, we can use `torch.save`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "fooo7SBzyKEF"
+   },
+   "outputs": [],
+   "source": [
+    "# torch.save(object, filename). For the filename, any extension can be used\n",
+    "torch.save(state_dict, \"our_model.tar\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "TJe90OhZWIK-"
+   },
+   "source": [
+    "#### Loading a model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "QGuwzmRPyKEF"
+   },
+   "source": [
+    "To load a model from a state dict, we use the function `torch.load` to load the state dict from the disk, and the module function `load_state_dict` to overwrite our parameters with the new values:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "dGwKGN9_yKEF"
+   },
+   "outputs": [],
+   "source": [
+    "# Load state dict from the disk (make sure it is the same name as above)\n",
+    "state_dict = torch.load(\"our_model.tar\")\n",
+    "\n",
+    "# Create a new model and load the state\n",
+    "new_model = SimpleClassifier(num_inputs=2, num_hidden=4, num_outputs=1)\n",
+    "new_model.load_state_dict(state_dict)\n",
+    "\n",
+    "# Verify that the parameters are the same\n",
+    "print(\"Original model\\n\", model.state_dict())\n",
+    "print(\"\\nLoaded model\\n\", new_model.state_dict())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "nGgtDnIiyKEG"
+   },
+   "source": [
+    "A detailed tutorial on saving and loading models in PyTorch can be found [here](https://pytorch.org/tutorials/beginner/saving_loading_models.html)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ssTU_brHwIIW"
+   },
+   "source": [
+    "### Evaluation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hoUN-UEqyKEG"
+   },
+   "source": [
+    "Once we have trained a model, it is time to evaluate it on a held-out test set. As our dataset consist of randomly generated data points, we need to first create a test set with a corresponding data loader."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "SPrpqQx2yKEG"
+   },
+   "outputs": [],
+   "source": [
+    "test_dataset = XNORDataset(size=500)\n",
+    "# drop_last -> Don't drop the last batch although it is smaller than 128\n",
+    "test_data_loader = data.DataLoader(test_dataset, batch_size=128, shuffle=False, drop_last=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "q2kpq9yKyKEG"
+   },
+   "source": [
+    "As metric, we will use accuracy which is calculated as follows:\n",
+    "\n",
+    "$$acc = \\frac{\\#\\text{correct predictions}}{\\#\\text{all predictions}} = \\frac{TP+TN}{TP+TN+FP+FN}$$\n",
+    "\n",
+    "where TP are the true positives, TN true negatives, FP false positives, and FN the fale negatives.\n",
+    "\n",
+    "When evaluating the model, we don't need to keep track of the computation graph as we don't intend to calculate the gradients. This reduces the required memory and speed up the model. In PyTorch, we can deactivate the computation graph using `with torch.no_grad(): ...`. Remember to additionally set the model to eval mode."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "4tK9mh5NyKEG"
+   },
+   "outputs": [],
+   "source": [
+    "def eval_model(model, data_loader):\n",
+    "    model.eval() # Set model to eval mode\n",
+    "    true_preds, num_preds = 0., 0.\n",
+    "\n",
+    "    with torch.no_grad(): # Deactivate gradients for the following code\n",
+    "        for data_inputs, data_labels in data_loader:\n",
+    "\n",
+    "            # Determine prediction of model on dev set\n",
+    "            data_inputs, data_labels = data_inputs.to(device), data_labels.to(device)\n",
+    "            preds = model(data_inputs)\n",
+    "            preds = preds.squeeze(dim=1)\n",
+    "            preds = torch.sigmoid(preds) # Sigmoid to map predictions between 0 and 1\n",
+    "            pred_labels = (preds >= 0.5).long() # Binarize predictions to 0 and 1\n",
+    "\n",
+    "            # Keep records of predictions for the accuracy metric (true_preds=TP+TN, num_preds=TP+TN+FP+FN)\n",
+    "            true_preds += (pred_labels == data_labels).sum()\n",
+    "            num_preds += data_labels.shape[0]\n",
+    "\n",
+    "    acc = true_preds / num_preds\n",
+    "    print(f\"Accuracy of the model: {100.0*acc:4.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ZB_AtTqQyKEG"
+   },
+   "outputs": [],
+   "source": [
+    "eval_model(model, test_data_loader)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XBy98EtxyKEG"
+   },
+   "source": [
+    "If we trained our model correctly, we should see a score close to 100% accuracy. However, this is only possible because of our simple task, and unfortunately, we usually don't get such high scores on test sets of more complex tasks."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Z34M30BSwL44"
+   },
+   "source": [
+    "#### Classification boundaries"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CMLkSndpyKEH"
+   },
+   "source": [
+    "To visualize what our model has learned, we can perform a prediction for every data point in a range of $[-0.5, 1.5]$, and visualize the predicted class as in the sample figure at the beginning of this section. This shows where the model has created decision boundaries, and which points would be classified as $0$, and which as $1$. We therefore get a background image out of blue (class 0) and orange (class 1). The spots where the model is uncertain we will see a blurry overlap. The specific code is less relevant compared to the output figure which should hopefully show us a clear separation of classes:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "_T5bkqYnyKEH"
+   },
+   "outputs": [],
+   "source": [
+    "from matplotlib.colors import to_rgba\n",
+    "@torch.no_grad() # Decorator, same effect as \"with torch.no_grad(): ...\" over the whole function.\n",
+    "def visualize_classification(model, data, label):\n",
+    "    if isinstance(data, torch.Tensor):\n",
+    "        data = data.cpu().numpy()\n",
+    "    if isinstance(label, torch.Tensor):\n",
+    "        label = label.cpu().numpy()\n",
+    "    data_0 = data[label == 0]\n",
+    "    data_1 = data[label == 1]\n",
+    "\n",
+    "    fig = plt.figure(figsize=(4,4), dpi=500)\n",
+    "    plt.scatter(data_0[:,0], data_0[:,1], edgecolor=\"#333\", label=\"Class 0\")\n",
+    "    plt.scatter(data_1[:,0], data_1[:,1], edgecolor=\"#333\", label=\"Class 1\")\n",
+    "    plt.title(\"Dataset samples\")\n",
+    "    plt.ylabel(r\"$x_2$\")\n",
+    "    plt.xlabel(r\"$x_1$\")\n",
+    "    plt.legend()\n",
+    "\n",
+    "    # Let's make use of a lot of operations we have learned above\n",
+    "    model.to(device)\n",
+    "    c0 = torch.Tensor(to_rgba(\"C0\")).to(device)\n",
+    "    c1 = torch.Tensor(to_rgba(\"C1\")).to(device)\n",
+    "    x1 = torch.arange(-0.5, 1.5, step=0.01, device=device)\n",
+    "    x2 = torch.arange(-0.5, 1.5, step=0.01, device=device)\n",
+    "    xx1, xx2 = torch.meshgrid(x1, x2, indexing='ij')  # Meshgrid function as in Numpy\n",
+    "    model_inputs = torch.stack([xx1, xx2], dim=-1)\n",
+    "    preds = model(model_inputs)\n",
+    "    preds = torch.sigmoid(preds)\n",
+    "    output_image = (1 - preds) * c0[None,None] + preds * c1[None,None]  # Specifying \"None\" in a dimension creates a new one\n",
+    "    output_image = output_image.cpu().numpy()  # Convert to Numpy array. This only works for tensors on CPU, hence first push to CPU\n",
+    "    plt.imshow(output_image, origin='lower', extent=(-0.5, 1.5, -0.5, 1.5))\n",
+    "    plt.grid(False)\n",
+    "    return fig\n",
+    "\n",
+    "_ = visualize_classification(model, dataset.data, dataset.label)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Xd0V5xURyKEH"
+   },
+   "source": [
+    "The decision boundaries might not look exactly as in the figure in the preamble of this section which can be caused by running it on CPU or a different GPU architecture. Nevertheless, the result on the accuracy metric should be the approximately the same."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fD0bZOtWwO3N"
+   },
+   "source": [
+    "## Additional features"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "SWS3SbxEyKEH"
+   },
+   "source": [
+    "Finally, you are all set to start with your own PyTorch project! In summary, we have looked at how we can build neural networks in PyTorch, and train and test them on data. However, there is still much more to PyTorch we haven't discussed yet. In the coming series of Jupyter notebooks, we will discover more and more functionalities of PyTorch, so that you also get familiar to PyTorch concepts beyond the basics. If you are already interested in learning more of PyTorch, we recommend the official [tutorial website](https://pytorch.org/tutorials/) that contains many tutorials on various topics. Especially logging with Tensorboard ([official tutorial here](https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html)) is a very good practice. Nonetheless, let's check it shortly out how we could use TensorBoard in our small example."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "LJDPWpDCwW_b"
+   },
+   "source": [
+    "### TensorBoard logging"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "T62gqr2ByKEH"
+   },
+   "source": [
+    "TensorBoard is a logging and visualization tool that is a popular choice for training deep learning models. Although initially published for TensorFlow, TensorBoard is also integrated in PyTorch allowing us to easily use it. First, let's import it below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "0gh6VV8dyKEH"
+   },
+   "outputs": [],
+   "source": [
+    "# Import tensorboard logger from PyTorch\n",
+    "from torch.utils.tensorboard import SummaryWriter\n",
+    "\n",
+    "# Load tensorboard extension for Jupyter Notebook, only need to start TB in the notebook\n",
+    "%load_ext tensorboard"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Ilra_iscyKEH"
+   },
+   "source": [
+    "The last line is required if you want to run TensorBoard directly in the Jupyter Notebook. Otherwise, you can start TensorBoard from the terminal.\n",
+    "\n",
+    "PyTorch's TensorBoard API is simple to use. We start the logging process by creating a new object, `writer = SummaryWriter(...)`, where we specify the directory in which the logging file should be saved. With this object, we can log different aspects of our model by calling functions of the style `writer.add_...`. For example, we can visualize the computation graph with the function `writer.add_graph`, or add a scalar value like the loss with `writer.add_scalar`. Let's adapt our initial training function with adding a TensorBoard logger below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "BpiwqUmxyKEH"
+   },
+   "outputs": [],
+   "source": [
+    "def train_model_with_logger(model, optimizer, data_loader, loss_module, val_dataset, num_epochs=100, logging_dir='runs/our_experiment'):\n",
+    "    # Create TensorBoard logger\n",
+    "    writer = SummaryWriter(logging_dir)\n",
+    "    model_plotted = False\n",
+    "\n",
+    "    # Set model to train mode\n",
+    "    model.train()\n",
+    "\n",
+    "    # Training loop\n",
+    "    for epoch in tqdm(range(num_epochs)):\n",
+    "        epoch_loss = 0.0\n",
+    "        for data_inputs, data_labels in data_loader:\n",
+    "\n",
+    "            ## Step 1: Move input data to device (only strictly necessary if we use GPU)\n",
+    "            data_inputs = data_inputs.to(device)\n",
+    "            data_labels = data_labels.to(device)\n",
+    "\n",
+    "            # For the very first batch, we visualize the computation graph in TensorBoard\n",
+    "            if not model_plotted:\n",
+    "                writer.add_graph(model, data_inputs)\n",
+    "                model_plotted = True\n",
+    "\n",
+    "            ## Step 2: Run the model on the input data\n",
+    "            preds = model(data_inputs)\n",
+    "            preds = preds.squeeze(dim=1) # Output is [Batch size, 1], but we want [Batch size]\n",
+    "\n",
+    "            ## Step 3: Calculate the loss\n",
+    "            loss = loss_module(preds, data_labels.float())\n",
+    "\n",
+    "            ## Step 4: Perform backpropagation\n",
+    "            # Before calculating the gradients, we need to ensure that they are all zero.\n",
+    "            # The gradients would not be overwritten, but actually added to the existing ones.\n",
+    "            optimizer.zero_grad()\n",
+    "            # Perform backpropagation\n",
+    "            loss.backward()\n",
+    "\n",
+    "            ## Step 5: Update the parameters\n",
+    "            optimizer.step()\n",
+    "\n",
+    "            ## Step 6: Take the running average of the loss\n",
+    "            epoch_loss += loss.item()\n",
+    "\n",
+    "        # Add average loss to TensorBoard\n",
+    "        epoch_loss /= len(data_loader)\n",
+    "        writer.add_scalar('training_loss',\n",
+    "                          epoch_loss,\n",
+    "                          global_step = epoch + 1)\n",
+    "\n",
+    "        # Visualize prediction and add figure to TensorBoard\n",
+    "        # Since matplotlib figures can be slow in rendering, we only do it every 10th epoch\n",
+    "        if (epoch + 1) % 10 == 0:\n",
+    "            fig = visualize_classification(model, val_dataset.data, val_dataset.label)\n",
+    "            writer.add_figure('predictions',\n",
+    "                              fig,\n",
+    "                              global_step = epoch + 1)\n",
+    "\n",
+    "    writer.close()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2ionZe79yKEI"
+   },
+   "source": [
+    "Let's use this method to train a model as before, with a new model and optimizer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "w2qOWXWFyKEI"
+   },
+   "outputs": [],
+   "source": [
+    "model = SimpleClassifier(num_inputs=2, num_hidden=4, num_outputs=1).to(device)\n",
+    "optimizer = torch.optim.SGD(model.parameters(), lr=0.1)\n",
+    "train_model_with_logger(model, optimizer, train_data_loader, loss_module, val_dataset=dataset)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Nntp29iSyKEI"
+   },
+   "source": [
+    "The TensorBoard file in the folder `runs/our_experiment` now contains a loss curve, the computation graph of our network, and a visualization of the learned predictions over number of epochs. To start the TensorBoard visualizer, simply run the following statement:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "VTmYZzCCyKEI"
+   },
+   "outputs": [],
+   "source": [
+    "%tensorboard --logdir runs/our_experiment"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "QOlapcqzyKEI"
+   },
+   "source": [
+    "<center><img src=\"https://github.com/AnjanDutta/SharedFigures/blob/main/tensorboard_screenshot.png?raw=true\" width=\"600px\"></center>\n",
+    "\n",
+    "TensorBoard visualizations can help to identify possible issues with your model, and identify situations such as overfitting. You can also track the training progress while a model is training, since the logger automatically writes everything added to it to the logging file. Feel free to explore the TensorBoard functionalities."
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "include_colab_link": true,
+   "provenance": []
+  },
+  "gpuClass": "standard",
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

Downloads/.ipynb_checkpoints/Python Tutorial(1)-checkpoint.ipynb

@@ -0,0 +1,3313 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "view-in-github"
+   },
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/AnjanDutta/EEEM068/blob/main/Notebooks/Python_Tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dzNng6vCL9eP"
+   },
+   "source": [
+    "<H1 style=\"text-align: center\">EEEM068 - Applied Machine Learning</H1>\n",
+    "<H1 style=\"text-align: center\">Workshop 01</H1>\n",
+    "<H1 style=\"text-align: center\">Python Tutorial</H1>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "qVrTo-LhL9eS"
+   },
+   "source": [
+    "##Introduction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9t1gKp9PL9eV"
+   },
+   "source": [
+    "Python is a great general purpose programming language on its own, but with the help of a few popular libraries, such as numpy, scipy, matplotlib it becomes a powerful environment for scientific computing.\n",
+    "\n",
+    "We expect that many of you to have some experience with Python and numpy. Nevertheless, for the rest of you, this tutorial will serve as a quick crash course both on the Python programming language and on the use of Python for scientific computing.\n",
+    "\n",
+    "Some of you may have previous knowledge in Matlab, in which case we also recommend the [NumPy for Matlab users](https://numpy.org/doc/stable/user/numpy-for-matlab-users.html) page."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "U1PvreR9L9eW"
+   },
+   "source": [
+    "In this tutorial, we will cover:\n",
+    "\n",
+    "* Basic Python: Basic data types (Containers, Lists, Dictionaries, Sets, Tuples), Functions, Classes\n",
+    "* Numpy: Arrays, Array indexing, Datatypes, Array math, Broadcasting\n",
+    "* Matplotlib: Plotting, Subplots, Images\n",
+    "* Scikit-learn: Toy dataset, Classifier, Confusion matrix, Regressor\n",
+    "* OpenCV: Image, Image representation, Colour and datatype conversion, Image processing\n",
+    "* SciPy: I/O of MATLAB files, Distance functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-O99OrwPtGii"
+   },
+   "source": [
+    "## Python Versions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "nxvEkGXPM3Xh"
+   },
+   "source": [
+    "Please note that as of February 2026, Colab is using Python 3.12.12. Therefore, we will be using Python 3.12 for this iteration of the course. More details on Python 3.12 can be found in the [documentation](https://docs.python.org/3.12/tutorial/index.html). You can check your Python version at the command line by running `python --version`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "1L4Am0QATgOc"
+   },
+   "outputs": [],
+   "source": [
+    "!python --version"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "JAFKYgrpL9eY"
+   },
+   "source": [
+    "##Basics of Python"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RbFS6tdgL9ea"
+   },
+   "source": [
+    "Python is an easy to learn, high-level, dynamically typed multiparadigm programming language. Python code is often said to be almost like pseudocode, since it allows you to express very powerful ideas in very few lines of code while being very readable. As an example, here is an implementation of the classic quicksort algorithm in Python:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "cYb0pjh1L9eb"
+   },
+   "outputs": [],
+   "source": [
+    "def quicksort(arr):\n",
+    "    if len(arr) <= 1:\n",
+    "        return arr\n",
+    "    pivot = arr[len(arr) // 2]\n",
+    "    left = [x for x in arr if x < pivot]\n",
+    "    middle = [x for x in arr if x == pivot]\n",
+    "    right = [x for x in arr if x > pivot]\n",
+    "    return quicksort(left) + middle + quicksort(right)\n",
+    "\n",
+    "print(quicksort([3,6,8,10,1,2,1]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NwS_hu4xL9eo"
+   },
+   "source": [
+    "###Basic data types"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "DL5sMSZ9L9eq"
+   },
+   "source": [
+    "####Numbers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MGS0XEWoL9er"
+   },
+   "source": [
+    "Integers and floats work as you would expect from other languages:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "KheDr_zDL9es"
+   },
+   "outputs": [],
+   "source": [
+    "x = 3\n",
+    "print(x, type(x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "sk_8DFcuL9ey"
+   },
+   "outputs": [],
+   "source": [
+    "print(x + 1)   # Addition\n",
+    "print(x - 1)   # Subtraction\n",
+    "print(x * 2)   # Multiplication\n",
+    "print(x ** 2)  # Exponentiation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "U4Jl8K0tL9e4"
+   },
+   "outputs": [],
+   "source": [
+    "x += 1\n",
+    "print(x)\n",
+    "x *= 2\n",
+    "print(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "w-nZ0Sg_L9e9"
+   },
+   "outputs": [],
+   "source": [
+    "y = 2.5\n",
+    "print(type(y))\n",
+    "print(y, y + 1, y * 2, y ** 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "r2A9ApyaL9fB"
+   },
+   "source": [
+    "Note that unlike many languages (such as C and C++) Python does not have unary increment (x++) or decrement (x--) operators.\n",
+    "\n",
+    "Python also has built-in types for long integers and complex numbers; you can find all of the details in the [documentation](https://docs.python.org/3.8/library/stdtypes.html#numeric-types-int-float-long-complex)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EqRS7qhBL9fC"
+   },
+   "source": [
+    "####Booleans"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Nv_LIVOJL9fD"
+   },
+   "source": [
+    "Python implements all of the usual operators for Boolean logic, but uses English words rather than symbols (`&&`, `||`, etc.):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "RvoImwgGL9fE"
+   },
+   "outputs": [],
+   "source": [
+    "t, f = True, False\n",
+    "print(type(t))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "YQgmQfOgL9fI"
+   },
+   "source": [
+    "Now we let's look at the operations:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6zYm7WzCL9fK"
+   },
+   "outputs": [],
+   "source": [
+    "print(t and f) # Logical AND;\n",
+    "print(t or f)  # Logical OR;\n",
+    "print(not t)   # Logical NOT;\n",
+    "print(t != f)  # Logical XOR;"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "UQnQWFEyL9fP"
+   },
+   "source": [
+    "####Strings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "AijEDtPFL9fP"
+   },
+   "outputs": [],
+   "source": [
+    "hello = 'hello'   # String literals can use single quotes\n",
+    "world = \"world\"   # or double quotes; it does not matter\n",
+    "print(hello, len(hello))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "saDeaA7hL9fT"
+   },
+   "outputs": [],
+   "source": [
+    "hw = hello + ' ' + world  # String concatenation\n",
+    "print(hw)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Nji1_UjYL9fY"
+   },
+   "outputs": [],
+   "source": [
+    "hw12 = '{} {} {}'.format(hello, world, 12)  # string formatting\n",
+    "print(hw12)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "bUpl35bIL9fc"
+   },
+   "source": [
+    "String objects have a bunch of useful methods; for example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "VOxGatlsL9fd"
+   },
+   "outputs": [],
+   "source": [
+    "s = \"hello\"\n",
+    "print(s.capitalize())  # Capitalize a string\n",
+    "print(s.upper())       # Convert a string to uppercase; prints \"HELLO\"\n",
+    "print(s.rjust(7))      # Right-justify a string, padding with spaces\n",
+    "print(s.center(7))     # Center a string, padding with spaces\n",
+    "print(s.replace('l', '(ell)'))  # Replace all instances of one substring with another\n",
+    "print('  world '.strip())  # Strip leading and trailing whitespace"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "06cayXLtL9fi"
+   },
+   "source": [
+    "You can find a list of all string methods in the [documentation](https://docs.python.org/3.7/library/stdtypes.html#string-methods)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "p-6hClFjL9fk"
+   },
+   "source": [
+    "###Containers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FD9H18eQL9fk"
+   },
+   "source": [
+    "Python includes several built-in container types: lists, dictionaries, sets, and tuples."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "UsIWOe0LL9fn"
+   },
+   "source": [
+    "####Lists"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "wzxX7rgWL9fn"
+   },
+   "source": [
+    "A list is the Python equivalent of an array, but is resizeable and can contain elements of different types:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "hk3A8pPcL9fp"
+   },
+   "outputs": [],
+   "source": [
+    "xs = [3, 1, 2]   # Create a list\n",
+    "print(xs, xs[2])\n",
+    "print(xs[-1])    # Negative indices count from the end of the list; prints \"2\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "YCjCy_0_L9ft"
+   },
+   "outputs": [],
+   "source": [
+    "xs[2] = 'foo'    # Lists can be heterogeneous, i.e. it can contain elements of different types\n",
+    "print(xs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "vJ0x5cF-L9fx"
+   },
+   "outputs": [],
+   "source": [
+    "xs.append('bar') # Add a new element to the end of the list\n",
+    "print(xs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "cxVCNRTNL9f1"
+   },
+   "outputs": [],
+   "source": [
+    "x = xs.pop()     # Remove and return the last element of the list\n",
+    "print(x, xs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ilyoyO34L9f4"
+   },
+   "source": [
+    "As usual, you can find all the gory details about lists in the [documentation](https://docs.python.org/3.7/tutorial/datastructures.html#more-on-lists)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ovahhxd_L9f5"
+   },
+   "source": [
+    "####Slicing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "YeSYKhv9L9f6"
+   },
+   "source": [
+    "In addition to accessing list elements one at a time, Python provides concise syntax to access sublists; this is known as slicing:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ninq666bL9f6"
+   },
+   "outputs": [],
+   "source": [
+    "nums = list(range(5))   # range is a built-in function that creates a list of integers\n",
+    "print(nums)             # Prints \"[0, 1, 2, 3, 4]\"\n",
+    "print(nums[2:4])        # Get a slice from index 2 to 4 (exclusive); prints \"[2, 3]\"\n",
+    "print(nums[2:])         # Get a slice from index 2 to the end; prints \"[2, 3, 4]\"\n",
+    "print(nums[:2])         # Get a slice from the start to index 2 (exclusive); prints \"[0, 1]\"\n",
+    "print(nums[:])          # Get a slice of the whole list; prints [\"0, 1, 2, 3, 4]\"\n",
+    "print(nums[:-1])        # Slice indices can be negative; prints [\"0, 1, 2, 3]\"\n",
+    "nums[2:4] = [8, 9]      # Assign a new sublist to a slice\n",
+    "print(nums)             # Prints \"[0, 1, 8, 9, 4]\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "arrLCcMyL9gK"
+   },
+   "source": [
+    "####List comprehensions:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "5Qn2jU_pL9gL"
+   },
+   "source": [
+    "When programming, frequently we want to transform one type of data into another. As a simple example, consider the following code that computes square numbers:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "IVNEwoMXL9gL"
+   },
+   "outputs": [],
+   "source": [
+    "nums = [0, 1, 2, 3, 4]\n",
+    "squares = []\n",
+    "for x in nums:\n",
+    "    squares.append(x ** 2)\n",
+    "print(squares)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7DmKVUFaL9gQ"
+   },
+   "source": [
+    "You can make this code simpler using a list comprehension:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "kZxsUfV6L9gR"
+   },
+   "outputs": [],
+   "source": [
+    "nums = [0, 1, 2, 3, 4]\n",
+    "squares = [x ** 2 for x in nums]\n",
+    "print(squares)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-D8ARK7tL9gV"
+   },
+   "source": [
+    "List comprehensions can also contain conditions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "yUtgOyyYL9gV"
+   },
+   "outputs": [],
+   "source": [
+    "nums = [0, 1, 2, 3, 4]\n",
+    "even_squares = [x ** 2 for x in nums if x % 2 == 0]\n",
+    "print(even_squares)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "H8xsUEFpL9gZ"
+   },
+   "source": [
+    "####Dictionaries"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kkjAGMAJL9ga"
+   },
+   "source": [
+    "A dictionary stores (key, value) pairs, similar to a `Map` in Java or an object in Javascript. You can use it like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "XBYI1MrYL9gb"
+   },
+   "outputs": [],
+   "source": [
+    "d = {'cat': 'cute', 'dog': 'furry'}     # Create a new dictionary with some data\n",
+    "print(d['cat'])                         # Get an entry from a dictionary; prints \"cute\"\n",
+    "print('cat' in d)                       # Check if a dictionary has a given key; prints \"True\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pS7e-G-HL9gf"
+   },
+   "outputs": [],
+   "source": [
+    "d['fish'] = 'wet'   # Set an entry in a dictionary\n",
+    "print(d['fish'])    # Prints \"wet\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "tFY065ItL9gi"
+   },
+   "outputs": [],
+   "source": [
+    "print(d['monkey'])  # KeyError: 'monkey' not a key of d"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "8TjbEWqML9gl"
+   },
+   "outputs": [],
+   "source": [
+    "print(d.get('monkey', 'N/A'))  # Get an element with a default; prints \"N/A\"\n",
+    "print(d.get('fish', 'N/A'))    # Get an element with a default; prints \"wet\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "0EItdNBJL9go"
+   },
+   "outputs": [],
+   "source": [
+    "del d['fish']               # Remove an element from a dictionary\n",
+    "print(d.get('fish', 'N/A')) # \"fish\" is no longer a key; prints \"N/A\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "wqm4dRZNL9gr"
+   },
+   "source": [
+    "You can find all you need to know about dictionaries in the [documentation](https://docs.python.org/2/library/stdtypes.html#dict)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "IxwEqHlGL9gr"
+   },
+   "source": [
+    "It is easy to iterate over the keys in a dictionary:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "rYfz7ZKNL9gs"
+   },
+   "outputs": [],
+   "source": [
+    "d = {'person': 2, 'cat': 4, 'spider': 8}\n",
+    "for animal, legs in d.items():\n",
+    "    print('A {} has {} legs'.format(animal, legs))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "17sxiOpzL9gz"
+   },
+   "source": [
+    "Dictionary comprehensions: These are similar to list comprehensions, but allow you to easily construct dictionaries. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "8PB07imLL9gz"
+   },
+   "outputs": [],
+   "source": [
+    "nums = [0, 1, 2, 3, 4]\n",
+    "even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}\n",
+    "print(even_num_to_square)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "V9MHfUdvL9g2"
+   },
+   "source": [
+    "####Sets"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Rpm4UtNpL9g2"
+   },
+   "source": [
+    "A set is an unordered collection of distinct elements. As a simple example, consider the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "MmyaniLsL9g2"
+   },
+   "outputs": [],
+   "source": [
+    "animals = {'cat', 'dog'}\n",
+    "print('cat' in animals)   # Check if an element is in a set; prints \"True\"\n",
+    "print('fish' in animals)  # prints \"False\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ElJEyK86L9g6"
+   },
+   "outputs": [],
+   "source": [
+    "animals.add('fish')      # Add an element to a set\n",
+    "print('fish' in animals)\n",
+    "print(len(animals))       # Number of elements in a set;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "5uGmrxdPL9g9"
+   },
+   "outputs": [],
+   "source": [
+    "animals.add('cat')       # Adding an element that is already in the set does nothing\n",
+    "print(len(animals))\n",
+    "animals.remove('cat')    # Remove an element from a set\n",
+    "print(len(animals))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "zk2DbvLKL9g_"
+   },
+   "source": [
+    "_Loops_: Iterating over a set has the same syntax as iterating over a list; however since sets are unordered, you cannot make assumptions about the order in which you visit the elements of the set:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "K47KYNGyL9hA"
+   },
+   "outputs": [],
+   "source": [
+    "animals = {'cat', 'dog', 'fish'}\n",
+    "for idx, animal in enumerate(animals):\n",
+    "    print('#{}: {}'.format(idx + 1, animal))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "puq4S8buL9hC"
+   },
+   "source": [
+    "Set comprehensions: Like lists and dictionaries, we can easily construct sets using set comprehensions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "iw7k90k3L9hC"
+   },
+   "outputs": [],
+   "source": [
+    "from math import sqrt\n",
+    "print({int(sqrt(x)) for x in range(30)})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "qPsHSKB1L9hF"
+   },
+   "source": [
+    "####Tuples"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kucc0LKVL9hG"
+   },
+   "source": [
+    "A tuple is an (immutable) ordered list of values. A tuple is in many ways similar to a list; one of the most important differences is that tuples can be used as keys in dictionaries and as elements of sets, while lists cannot. Here is a trivial example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "9wHUyTKxL9hH"
+   },
+   "outputs": [],
+   "source": [
+    "d = {(x, x + 1): x for x in range(10)}  # Create a dictionary with tuple keys\n",
+    "t = (5, 6)       # Create a tuple\n",
+    "print(type(t))\n",
+    "print(d[t])\n",
+    "print(d[(1, 2)])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "iFON3Tm0CfIg"
+   },
+   "source": [
+    "##Loops"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7aXUmwT69XqK"
+   },
+   "source": [
+    "###`for` loop"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_DYz1j6QL9f_"
+   },
+   "source": [
+    "You can loop over the elements of a list like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "4cCOysfWL9gA"
+   },
+   "outputs": [],
+   "source": [
+    "animals = ['cat', 'dog', 'monkey']\n",
+    "for animal in animals:\n",
+    "    print(animal)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "KxIaQs7pL9gE"
+   },
+   "source": [
+    "If you want access to the index of each element within the body of a loop, use the built-in `enumerate` function:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JjGnDluWL9gF"
+   },
+   "outputs": [],
+   "source": [
+    "animals = ['cat', 'dog', 'monkey']\n",
+    "for idx, animal in enumerate(animals):\n",
+    "    print('#{}: {}'.format(idx + 1, animal))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Tlf5gPRy9jfV"
+   },
+   "source": [
+    "###`range()` function"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "pzgK4H6j-PyN"
+   },
+   "source": [
+    "If you need to iterate over a sequence of numbers, the built-in function `range()` comes in handy. It generates arithmetic progressions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "eNlqr8sn-TX5"
+   },
+   "outputs": [],
+   "source": [
+    "for i in range(5):\n",
+    "    print(i)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vfigt0cE-fpp"
+   },
+   "source": [
+    "The given end point is never part of the generated sequence; `range(10)` generates 10 values, the legal indices for items of a sequence of length 10. It is possible to let the range start at another number, or to specify a different increment (even negative; sometimes this is called the ‘step’):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "apwUH4Ar-o4P"
+   },
+   "outputs": [],
+   "source": [
+    "print(list(range(5, 10)))\n",
+    "print(list(range(0, 10, 3)))\n",
+    "print(list(range(-10, -100, -30)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mezbBTJqCmZy"
+   },
+   "source": [
+    "###`while` loop"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "A5qN9PZTCuvS"
+   },
+   "source": [
+    "With the `while` loop we can execute a set of statements as long as a condition is true."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "T0NbKi1hCyCE"
+   },
+   "outputs": [],
+   "source": [
+    "i = 1\n",
+    "while i < 6:\n",
+    "  print(i)\n",
+    "  i += 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uBXI2gMx9Dno"
+   },
+   "source": [
+    "## Control Flow Tools"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "q6aeyPu39PPC"
+   },
+   "source": [
+    "###`if` statement"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "eHUyBp-E_V-x"
+   },
+   "source": [
+    "Perhaps the most well-known statement type is the if statement. There can be zero or more `elif` parts, and the `else` part is optional. The keyword `elif` is short for `else if`, and is useful to avoid excessive indentation. An `if` … `elif` … `elif` … sequence is a substitute for the `switch` or `case` statements found in other languages. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "nD8ITrA__Z5D"
+   },
+   "outputs": [],
+   "source": [
+    "x = int(input(\"Please enter an integer: \"))\n",
+    "if x < 0:\n",
+    "    x = 0\n",
+    "    print('Negative changed to zero')\n",
+    "elif x == 0:\n",
+    "    print('Zero')\n",
+    "elif x == 1:\n",
+    "    print('Single')\n",
+    "else:\n",
+    "    print('More')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Y0CBMSRJ9sby"
+   },
+   "source": [
+    "###`break` and `continue` statements"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XrfS77Kzi91S"
+   },
+   "source": [
+    "The `break` statement, like in C, breaks out of the innermost enclosing `for` or `while` loop.\n",
+    "\n",
+    "Loop statements may have an else clause; it is executed when the loop terminates through exhaustion of the iterable (with `for`) or when the condition becomes false (with `while`), but not when the loop is terminated by a `break` statement. This is exemplified by the following loop, which searches for prime numbers:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "S2XoBEftjaXX"
+   },
+   "outputs": [],
+   "source": [
+    "for n in range(2, 10):\n",
+    "    for x in range(2, n):\n",
+    "        if n % x == 0:\n",
+    "            print(n, 'equals', x, '*', n//x)\n",
+    "            break\n",
+    "    else:\n",
+    "        # loop fell through without finding a factor\n",
+    "        print(n, 'is a prime number')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "b5pf2Vdbkl0_"
+   },
+   "source": [
+    "The `continue` statement, also borrowed from C, continues with the next iteration of the loop:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "swr6-rEwksE2"
+   },
+   "outputs": [],
+   "source": [
+    "for num in range(2, 10):\n",
+    "    if num % 2 == 0:\n",
+    "        print(\"Found an even number\", num)\n",
+    "        continue\n",
+    "    print(\"Found an odd number\", num)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "JVKNnslx95_d"
+   },
+   "source": [
+    "###`pass` statement"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-dZk28jllX6D"
+   },
+   "source": [
+    "The `pass` statement does nothing. It can be used when a statement is required syntactically but the program requires no action. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "DnJfJPkTldUz"
+   },
+   "outputs": [],
+   "source": [
+    "while True:\n",
+    "    pass  # Busy-wait for keyboard interrupt. Please press the stop button to stop execution."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-tWb6by_lkn3"
+   },
+   "source": [
+    "This is commonly used for creating minimal classes:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "57_9LZkplsSz"
+   },
+   "outputs": [],
+   "source": [
+    "class MyEmptyClass:\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "45jdssyFlxqo"
+   },
+   "source": [
+    "Another place `pass` can be used is as a place-holder for a function or conditional body when you are working on new code, allowing you to keep thinking at a more abstract level. The `pass` is silently ignored:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "0r9Dikptl4-1"
+   },
+   "outputs": [],
+   "source": [
+    "def initlog(*args):\n",
+    "    pass   # Remember to implement this!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "AXA4jrEOL9hM"
+   },
+   "source": [
+    "###Functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "WaRms-QfL9hN"
+   },
+   "source": [
+    "Python functions are defined using the `def` keyword. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "kiMDUr58L9hN"
+   },
+   "outputs": [],
+   "source": [
+    "def sign(x):\n",
+    "    if x > 0:\n",
+    "        return 'positive'\n",
+    "    elif x < 0:\n",
+    "        return 'negative'\n",
+    "    else:\n",
+    "        return 'zero'\n",
+    "\n",
+    "for x in [-1, 0, 1]:\n",
+    "    print(sign(x))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "U-QJFt8TL9hR"
+   },
+   "source": [
+    "We will often define functions to take optional keyword arguments, like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "PfsZ3DazL9hR"
+   },
+   "outputs": [],
+   "source": [
+    "def hello(name, loud=False):\n",
+    "    if loud:\n",
+    "        print('HELLO, {}'.format(name.upper()))\n",
+    "    else:\n",
+    "        print('Hello, {}!'.format(name))\n",
+    "\n",
+    "hello('Bob')\n",
+    "hello('Fred', loud=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ObA9PRtQL9hT"
+   },
+   "source": [
+    "###Classes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hAzL_lTkL9hU"
+   },
+   "source": [
+    "In object-oriented programming, a class is a template definition of the methods and variables in a particular kind of object. Thus, an object is a specific instance of a class; it contains real values instead of variables. For more details, on class in object oriented programming, please have a look on this [link](https://www.w3schools.com/java/java_oop.asp). The syntax for defining classes in Python is straightforward and can be done as follows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "RWdbaGigL9hU"
+   },
+   "outputs": [],
+   "source": [
+    "class Greeter:\n",
+    "\n",
+    "    # Constructor\n",
+    "    def __init__(self, name):\n",
+    "        self.name = name  # Create an instance variable\n",
+    "\n",
+    "    # Instance method\n",
+    "    def greet(self, loud=False):\n",
+    "        if loud:\n",
+    "          print('HELLO, {}'.format(self.name.upper()))\n",
+    "        else:\n",
+    "          print('Hello, {}!'.format(self.name))\n",
+    "\n",
+    "g = Greeter('Fred')  # Construct an instance of the Greeter class\n",
+    "g.greet()            # Call an instance method; prints \"Hello, Fred\"\n",
+    "g.greet(loud=True)   # Call an instance method; prints \"HELLO, FRED!\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3cfrOV4dL9hW"
+   },
+   "source": [
+    "##Numpy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fY12nHhyL9hX"
+   },
+   "source": [
+    "Numpy is the core library for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with these arrays. If you are already familiar with MATLAB, you might find this [tutorial](http://wiki.scipy.org/NumPy_for_Matlab_Users) useful to get started with Numpy. To use Numpy, we first need to import the `numpy` package."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2_lpLqwZpd-4"
+   },
+   "source": [
+    "### Importing a package"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hMmlsjljBbVE"
+   },
+   "source": [
+    "In Python, a package or a module can be imported in many different ways, some of which are shown below. For more details, please have a look on this [documentation](https://docs.python.org/3/tutorial/modules.html#more-on-modules).\n",
+    "\n",
+    "\n",
+    "```\n",
+    "import numpy            # import numpy, one can use it as numpy\n",
+    "import numpy as np      # import numpy and call it np\n",
+    "from numpy import *     # import all the modules from numpy\n",
+    "from numpy import sum   # import the \"sum\" function from numpy\n",
+    "```\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "58QdX8BLL9hZ"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np  # import numpy and call it np. So the sum function of numpy can be called as np.sum()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "DDx6v1EdL9hb"
+   },
+   "source": [
+    "###Arrays"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "f-Zv3f7LL9hc"
+   },
+   "source": [
+    "A numpy array is a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. The number of dimensions is the rank of the array; the shape of an array is a tuple of integers giving the size of the array along each dimension."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_eMTRnZRL9hc"
+   },
+   "source": [
+    "We can initialize numpy arrays from nested Python lists, and access elements using square brackets:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-l3JrGxCL9hc"
+   },
+   "outputs": [],
+   "source": [
+    "a = np.array([1, 2, 3])  # Create a rank 1 array\n",
+    "print(type(a), a.shape, a[0], a[1], a[2])\n",
+    "a[0] = 5                 # Change an element of the array\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ma6mk-kdL9hh"
+   },
+   "outputs": [],
+   "source": [
+    "b = np.array([[1,2,3],[4,5,6]])   # Create a rank 2 array\n",
+    "print(b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ymfSHAwtL9hj"
+   },
+   "outputs": [],
+   "source": [
+    "print(b.shape)\n",
+    "print(b[0, 0], b[0, 1], b[1, 0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "F2qwdyvuL9hn"
+   },
+   "source": [
+    "Numpy also provides many functions to create arrays:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "mVTN_EBqL9hn"
+   },
+   "outputs": [],
+   "source": [
+    "a = np.zeros((2,2))  # Create an array of all zeros\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "skiKlNmlL9h5"
+   },
+   "outputs": [],
+   "source": [
+    "b = np.ones((1,2))   # Create an array of all ones\n",
+    "print(b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "HtFsr03bL9h7"
+   },
+   "outputs": [],
+   "source": [
+    "c = np.full((2,2), 7) # Create a constant array\n",
+    "print(c)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-QcALHvkL9h9"
+   },
+   "outputs": [],
+   "source": [
+    "d = np.eye(2)        # Create a 2x2 identity matrix\n",
+    "print(d)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "RCpaYg9qL9iA"
+   },
+   "outputs": [],
+   "source": [
+    "e = np.random.random((2,2)) # Create an array filled with random values\n",
+    "print(e)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jI5qcSDfL9iC"
+   },
+   "source": [
+    "###Array indexing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "M-E4MUeVL9iC"
+   },
+   "source": [
+    "Numpy offers several ways to index into arrays.\n",
+    "\n",
+    "Slicing: Similar to Python lists, numpy arrays can be sliced. Since arrays may be multidimensional, you must specify a slice for each dimension of the array:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "wLWA0udwL9iD"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "# Create the following rank 2 array with shape (3, 4)\n",
+    "# [[ 1  2  3  4]\n",
+    "#  [ 5  6  7  8]\n",
+    "#  [ 9 10 11 12]]\n",
+    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
+    "\n",
+    "# Use slicing to pull out the subarray consisting of the first 2 rows\n",
+    "# and columns 1 and 2; b is the following array of shape (2, 2):\n",
+    "# [[2 3]\n",
+    "#  [6 7]]\n",
+    "b = a[:2, 1:3]\n",
+    "print(b)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "KahhtZKYL9iF"
+   },
+   "source": [
+    "A slice of an array is a view into the same data, so modifying it will modify the original array."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "1kmtaFHuL9iG"
+   },
+   "outputs": [],
+   "source": [
+    "print(a[0, 1])\n",
+    "b[0, 0] = 77    # b[0, 0] is the same piece of data as a[0, 1]\n",
+    "print(a[0, 1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_Zcf3zi-L9iI"
+   },
+   "source": [
+    "You can also mix integer indexing with slice indexing. However, doing so will yield an array of lower rank than the original array. Note that this is quite different from the way that MATLAB handles array slicing:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "G6lfbPuxL9iJ"
+   },
+   "outputs": [],
+   "source": [
+    "# Create the following rank 2 array with shape (3, 4)\n",
+    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NCye3NXhL9iL"
+   },
+   "source": [
+    "Two ways of accessing the data in the middle row of the array.\n",
+    "Mixing integer indexing with slices yields an array of lower rank,\n",
+    "while using only slices yields an array of the same rank as the\n",
+    "original array:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "EOiEMsmNL9iL"
+   },
+   "outputs": [],
+   "source": [
+    "row_r1 = a[1, :]    # Rank 1 view of the second row of a\n",
+    "row_r2 = a[1:2, :]  # Rank 2 view of the second row of a\n",
+    "row_r3 = a[[1], :]  # Rank 2 view of the second row of a\n",
+    "print(row_r1, row_r1.shape)\n",
+    "print(row_r2, row_r2.shape)\n",
+    "print(row_r3, row_r3.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JXu73pfDL9iN"
+   },
+   "outputs": [],
+   "source": [
+    "# We can make the same distinction when accessing columns of an array:\n",
+    "col_r1 = a[:, 1]\n",
+    "col_r2 = a[:, 1:2]\n",
+    "print(col_r1, col_r1.shape)\n",
+    "print()\n",
+    "print(col_r2, col_r2.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VP3916bOL9iP"
+   },
+   "source": [
+    "Integer array indexing: When you index into numpy arrays using slicing, the resulting array view will always be a subarray of the original array. In contrast, integer array indexing allows you to construct arbitrary arrays using the data from another array. Here is an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TBnWonIDL9iP"
+   },
+   "outputs": [],
+   "source": [
+    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
+    "\n",
+    "# An example of integer array indexing.\n",
+    "# The returned array will have shape (3,) and\n",
+    "print(a[[0, 1, 2], [0, 1, 0]])\n",
+    "\n",
+    "# The above example of integer array indexing is equivalent to this:\n",
+    "print(np.array([a[0, 0], a[1, 1], a[2, 0]]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "n7vuati-L9iR"
+   },
+   "outputs": [],
+   "source": [
+    "# When using integer array indexing, you can reuse the same\n",
+    "# element from the source array:\n",
+    "print(a[[0, 0], [1, 1]])\n",
+    "\n",
+    "# Equivalent to the previous integer array indexing example\n",
+    "print(np.array([a[0, 1], a[0, 1]]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kaipSLafL9iU"
+   },
+   "source": [
+    "One useful trick with integer array indexing is selecting or mutating one element from each row of a matrix:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ehqsV7TXL9iU"
+   },
+   "outputs": [],
+   "source": [
+    "# Create a new array from which we will select elements\n",
+    "a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pAPOoqy5L9iV"
+   },
+   "outputs": [],
+   "source": [
+    "# Create an array of indices\n",
+    "b = np.array([0, 2, 0, 1])\n",
+    "\n",
+    "# Select one element from each row of a using the indices in b\n",
+    "print(a[np.arange(4), b])  # Prints \"[ 1  6  7 11]\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6v1PdI1DL9ib"
+   },
+   "outputs": [],
+   "source": [
+    "# Mutate one element from each row of a using the indices in b\n",
+    "a[np.arange(4), b] += 10\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kaE8dBGgL9id"
+   },
+   "source": [
+    "Boolean array indexing: Boolean array indexing lets you pick out arbitrary elements of an array. Frequently this type of indexing is used to select the elements of an array that satisfy some condition. Here is an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "32PusjtKL9id"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
+    "\n",
+    "bool_idx = (a > 2)  # Find the elements of a that are bigger than 2;\n",
+    "                    # this returns a numpy array of Booleans of the same\n",
+    "                    # shape as a, where each slot of bool_idx tells\n",
+    "                    # whether that element of a is > 2.\n",
+    "\n",
+    "print(bool_idx)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "cb2IRMXaL9if"
+   },
+   "outputs": [],
+   "source": [
+    "# We use boolean array indexing to construct a rank 1 array\n",
+    "# consisting of the elements of a corresponding to the True values\n",
+    "# of bool_idx\n",
+    "print(a[bool_idx])\n",
+    "\n",
+    "# We can do all of the above in a single concise statement:\n",
+    "print(a[a > 2])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CdofMonAL9ih"
+   },
+   "source": [
+    "For brevity we have left out a lot of details about numpy array indexing; if you want to know more you should read the documentation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jTctwqdQL9ih"
+   },
+   "source": [
+    "###Datatypes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kSZQ1WkIL9ih"
+   },
+   "source": [
+    "Every numpy array is a grid of elements of the same type. Numpy provides a large set of numeric datatypes that you can use to construct arrays. Numpy tries to guess a datatype when you create an array, but functions that construct arrays usually also include an optional argument to explicitly specify the datatype. Here is an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "4za4O0m5L9ih"
+   },
+   "outputs": [],
+   "source": [
+    "x = np.array([1, 2])  # Let numpy choose the datatype\n",
+    "y = np.array([1.0, 2.0])  # Let numpy choose the datatype\n",
+    "z = np.array([1, 2], dtype=np.int64)  # Force a particular datatype\n",
+    "\n",
+    "print(x.dtype, y.dtype, z.dtype)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RLVIsZQpL9ik"
+   },
+   "source": [
+    "You can read all about numpy datatypes in the [documentation](http://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "TuB-fdhIL9ik"
+   },
+   "source": [
+    "###Array math"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "18e8V8elL9ik"
+   },
+   "source": [
+    "Basic mathematical functions operate elementwise on arrays, and are available both as operator overloads and as functions in the numpy module:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "gHKvBrSKL9il"
+   },
+   "outputs": [],
+   "source": [
+    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
+    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
+    "\n",
+    "# Elementwise sum; both produce the array\n",
+    "print(x + y)\n",
+    "print(np.add(x, y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "1fZtIAMxL9in"
+   },
+   "outputs": [],
+   "source": [
+    "# Elementwise difference; both produce the array\n",
+    "print(x - y)\n",
+    "print(np.subtract(x, y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "nil4AScML9io"
+   },
+   "outputs": [],
+   "source": [
+    "# Elementwise product; both produce the array\n",
+    "print(x * y)\n",
+    "print(np.multiply(x, y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "0JoA4lH6L9ip"
+   },
+   "outputs": [],
+   "source": [
+    "# Elementwise division; both produce the array\n",
+    "# [[ 0.2         0.33333333]\n",
+    "#  [ 0.42857143  0.5       ]]\n",
+    "print(x / y)\n",
+    "print(np.divide(x, y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "g0iZuA6bL9ir"
+   },
+   "outputs": [],
+   "source": [
+    "# Elementwise square root; produces the array\n",
+    "# [[ 1.          1.41421356]\n",
+    "#  [ 1.73205081  2.        ]]\n",
+    "print(np.sqrt(x))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "a5d_uujuL9it"
+   },
+   "source": [
+    "Note that unlike MATLAB, `*` is elementwise multiplication, not matrix multiplication. We instead use the dot function to compute inner products of vectors, to multiply a vector by a matrix, and to multiply matrices. dot is available both as a function in the numpy module and as an instance method of array objects:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "I3FnmoSeL9iu"
+   },
+   "outputs": [],
+   "source": [
+    "x = np.array([[1,2],[3,4]])\n",
+    "y = np.array([[5,6],[7,8]])\n",
+    "\n",
+    "v = np.array([9, 10])\n",
+    "w = np.array([11, 12])\n",
+    "\n",
+    "# Inner product of vectors; both produce 219\n",
+    "print(v.dot(w))\n",
+    "print(np.dot(v, w))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vmxPbrHASVeA"
+   },
+   "source": [
+    "You can also use the `@` operator which is equivalent to numpy's `dot` operator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "vyrWA-mXSdtt"
+   },
+   "outputs": [],
+   "source": [
+    "print(v @ w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "zvUODeTxL9iw"
+   },
+   "outputs": [],
+   "source": [
+    "# Matrix / vector product; both produce the rank 1 array [29 67]\n",
+    "print(x.dot(v))\n",
+    "print(np.dot(x, v))\n",
+    "print(x @ v)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "3V_3NzNEL9iy"
+   },
+   "outputs": [],
+   "source": [
+    "# Matrix / matrix product; both produce the rank 2 array\n",
+    "# [[19 22]\n",
+    "#  [43 50]]\n",
+    "print(x.dot(y))\n",
+    "print(np.dot(x, y))\n",
+    "print(x @ y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FbE-1If_L9i0"
+   },
+   "source": [
+    "Numpy provides many useful functions for performing computations on arrays; one of the most useful is `sum`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "DZUdZvPrL9i0"
+   },
+   "outputs": [],
+   "source": [
+    "x = np.array([[1,2],[3,4]])\n",
+    "\n",
+    "print(np.sum(x))  # Compute sum of all elements; prints \"10\"\n",
+    "print(np.sum(x, axis=0))  # Compute sum of each column; prints \"[4 6]\"\n",
+    "print(np.sum(x, axis=1))  # Compute sum of each row; prints \"[3 7]\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ahdVW4iUL9i3"
+   },
+   "source": [
+    "You can find the full list of mathematical functions provided by numpy in the [documentation](http://docs.scipy.org/doc/numpy/reference/routines.math.html).\n",
+    "\n",
+    "Apart from computing mathematical functions using arrays, we frequently need to reshape or otherwise manipulate data in arrays. The simplest example of this type of operation is transposing a matrix; to transpose a matrix, simply use the T attribute of an array object:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "63Yl1f3oL9i3"
+   },
+   "outputs": [],
+   "source": [
+    "print(x)\n",
+    "print(\"transpose\\n\", x.T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "mkk03eNIL9i4"
+   },
+   "outputs": [],
+   "source": [
+    "v = np.array([[1,2,3]])\n",
+    "print(v )\n",
+    "print(\"transpose\\n\", v.T)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "REfLrUTcL9i7"
+   },
+   "source": [
+    "###Broadcasting"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EygGAMWqL9i7"
+   },
+   "source": [
+    "Broadcasting is a powerful mechanism that allows numpy to work with arrays of different shapes when performing arithmetic operations. Frequently we have a smaller array and a larger array, and we want to use the smaller array multiple times to perform some operation on the larger array.\n",
+    "\n",
+    "For example, suppose that we want to add a constant vector to each row of a matrix. We could do it like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "WEEvkV1ZL9i7"
+   },
+   "outputs": [],
+   "source": [
+    "# We will add the vector v to each row of the matrix x,\n",
+    "# storing the result in the matrix y\n",
+    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
+    "v = np.array([1, 0, 1])\n",
+    "y = np.empty_like(x)   # Create an empty matrix with the same shape as x\n",
+    "\n",
+    "# Add the vector v to each row of the matrix x with an explicit loop\n",
+    "for i in range(4):\n",
+    "    y[i, :] = x[i, :] + v\n",
+    "\n",
+    "print(y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2OlXXupEL9i-"
+   },
+   "source": [
+    "This works; however when the matrix `x` is very large, computing an explicit loop in Python could be slow. Note that adding the vector v to each row of the matrix `x` is equivalent to forming a matrix `vv` by stacking multiple copies of `v` vertically, then performing elementwise summation of `x` and `vv`. We could implement this approach like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "vS7UwAQQL9i-"
+   },
+   "outputs": [],
+   "source": [
+    "vv = np.tile(v, (4, 1))  # Stack 4 copies of v on top of each other\n",
+    "print(vv)                # Prints \"[[1 0 1]\n",
+    "                         #          [1 0 1]\n",
+    "                         #          [1 0 1]\n",
+    "                         #          [1 0 1]]\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "N0hJphSIL9jA"
+   },
+   "outputs": [],
+   "source": [
+    "y = x + vv  # Add x and vv elementwise\n",
+    "print(y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "zHos6RJnL9jB"
+   },
+   "source": [
+    "Numpy broadcasting allows us to perform this computation without actually creating multiple copies of v. Consider this version, using broadcasting:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "vnYFb-gYL9jC"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "# We will add the vector v to each row of the matrix x,\n",
+    "# storing the result in the matrix y\n",
+    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
+    "v = np.array([1, 0, 1])\n",
+    "y = x + v  # Add v to each row of x using broadcasting\n",
+    "print(y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "08YyIURKL9jH"
+   },
+   "source": [
+    "The line `y = x + v` works even though `x` has shape `(4, 3)` and `v` has shape `(3,)` due to broadcasting; this line works as if v actually had shape `(4, 3)`, where each row was a copy of `v`, and the sum was performed elementwise.\n",
+    "\n",
+    "Broadcasting two arrays together follows these rules:\n",
+    "\n",
+    "1. If the arrays do not have the same rank, prepend the shape of the lower rank array with 1s until both shapes have the same length.\n",
+    "2. The two arrays are said to be compatible in a dimension if they have the same size in the dimension, or if one of the arrays has size 1 in that dimension.\n",
+    "3. The arrays can be broadcast together if they are compatible in all dimensions.\n",
+    "4. After broadcasting, each array behaves as if it had shape equal to the elementwise maximum of shapes of the two input arrays.\n",
+    "5. In any dimension where one array had size 1 and the other array had size greater than 1, the first array behaves as if it were copied along that dimension\n",
+    "\n",
+    "If this explanation does not make sense, try reading the explanation from the [documentation](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) or this [explanation](http://wiki.scipy.org/EricsBroadcastingDoc).\n",
+    "\n",
+    "Functions that support broadcasting are known as universal functions. You can find the list of all universal functions in the [documentation](http://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs).\n",
+    "\n",
+    "Here are some applications of broadcasting:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "EmQnwoM9L9jH"
+   },
+   "outputs": [],
+   "source": [
+    "# Compute outer product of vectors\n",
+    "v = np.array([1,2,3])  # v has shape (3,)\n",
+    "w = np.array([4,5])    # w has shape (2,)\n",
+    "# To compute an outer product, we first reshape v to be a column\n",
+    "# vector of shape (3, 1); we can then broadcast it against w to yield\n",
+    "# an output of shape (3, 2), which is the outer product of v and w:\n",
+    "\n",
+    "print(np.reshape(v, (3, 1)) * w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "PgotmpcnL9jK"
+   },
+   "outputs": [],
+   "source": [
+    "# Add a vector to each row of a matrix\n",
+    "x = np.array([[1,2,3], [4,5,6]])\n",
+    "# x has shape (2, 3) and v has shape (3,) so they broadcast to (2, 3),\n",
+    "# giving the following matrix:\n",
+    "\n",
+    "print(x + v)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "T5hKS1QaL9jK"
+   },
+   "outputs": [],
+   "source": [
+    "# Add a vector to each column of a matrix\n",
+    "# x has shape (2, 3) and w has shape (2,).\n",
+    "# If we transpose x then it has shape (3, 2) and can be broadcast\n",
+    "# against w to yield a result of shape (3, 2); transposing this result\n",
+    "# yields the final result of shape (2, 3) which is the matrix x with\n",
+    "# the vector w added to each column. Gives the following matrix:\n",
+    "\n",
+    "print((x.T + w).T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JDUrZUl6L9jN"
+   },
+   "outputs": [],
+   "source": [
+    "# Another solution is to reshape w to be a row vector of shape (2, 1);\n",
+    "# we can then broadcast it directly against x to produce the same\n",
+    "# output.\n",
+    "print(x + np.reshape(w, (2, 1)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "VzrEo4KGL9jP"
+   },
+   "outputs": [],
+   "source": [
+    "# Multiply a matrix by a constant:\n",
+    "# x has shape (2, 3). Numpy treats scalars as arrays of shape ();\n",
+    "# these can be broadcast together to shape (2, 3), producing the\n",
+    "# following array:\n",
+    "print(x * 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "89e2FXxFL9jQ"
+   },
+   "source": [
+    "Broadcasting typically makes your code more concise and faster, so you should strive to use it where possible."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "yi90439hpLR0"
+   },
+   "source": [
+    "### Numpy documentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "iF3ZtwVNL9jQ"
+   },
+   "source": [
+    "This brief overview has touched on many of the important things that you need to know about numpy, but is far from complete. Check out the [numpy reference](http://docs.scipy.org/doc/numpy/reference/) to find out much more about numpy."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "tEINf4bEL9jR"
+   },
+   "source": [
+    "##Matplotlib"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0hgVWLaXL9jR"
+   },
+   "source": [
+    "Matplotlib is a plotting library. In this section give a brief introduction to the `matplotlib.pyplot` module, which provides a plotting system similar to that of MATLAB."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "cmh_7c6KL9jR"
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jOsaA5hGL9jS"
+   },
+   "source": [
+    "By running this special iPython command, we will be displaying plots inline:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ijpsmwGnL9jT"
+   },
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "U5Z_oMoLL9jV"
+   },
+   "source": [
+    "###Plotting"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6QyFJ7dhL9jV"
+   },
+   "source": [
+    "The most important function in `matplotlib` is plot, which allows you to plot 2D data. Here is a simple example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pua52BGeL9jW"
+   },
+   "outputs": [],
+   "source": [
+    "# Compute the x and y coordinates for points on a sine curve\n",
+    "x = np.arange(0, 3 * np.pi, 0.1)\n",
+    "y = np.sin(x)\n",
+    "\n",
+    "# Plot the points using matplotlib\n",
+    "plt.plot(x, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9W2VAcLiL9jX"
+   },
+   "source": [
+    "With just a little bit of extra work we can easily plot multiple lines at once, and add a title, legend, and axis labels:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TfCQHJ5AL9jY"
+   },
+   "outputs": [],
+   "source": [
+    "y_sin = np.sin(x)\n",
+    "y_cos = np.cos(x)\n",
+    "\n",
+    "# Plot the points using matplotlib\n",
+    "plt.plot(x, y_sin)\n",
+    "plt.plot(x, y_cos)\n",
+    "plt.xlabel('x axis label')\n",
+    "plt.ylabel('y axis label')\n",
+    "plt.title('Sine and Cosine')\n",
+    "plt.legend(['Sine', 'Cosine'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "R5IeAY03L9ja"
+   },
+   "source": [
+    "###Subplots"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CfUzwJg0L9ja"
+   },
+   "source": [
+    "You can plot different things in the same figure using the subplot function. Here is an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "dM23yGH9L9ja"
+   },
+   "outputs": [],
+   "source": [
+    "# Compute the x and y coordinates for points on sine and cosine curves\n",
+    "x = np.arange(0, 3 * np.pi, 0.1)\n",
+    "y_sin = np.sin(x)\n",
+    "y_cos = np.cos(x)\n",
+    "\n",
+    "# Set up a subplot grid that has height 2 and width 1,\n",
+    "# and set the first such subplot as active.\n",
+    "plt.subplot(2, 1, 1)\n",
+    "\n",
+    "# Make the first plot\n",
+    "plt.plot(x, y_sin)\n",
+    "plt.title('Sine')\n",
+    "\n",
+    "# Set the second subplot as active, and make the second plot.\n",
+    "plt.subplot(2, 1, 2)\n",
+    "plt.plot(x, y_cos)\n",
+    "plt.title('Cosine')\n",
+    "\n",
+    "# Show the figure.\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "gLtsST5SL9jc"
+   },
+   "source": [
+    "You can read much more about the `subplot` function in the [documentation](http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.subplot)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7Zqndtogsq8J"
+   },
+   "source": [
+    "### Download images"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "4FFozuUm7OE5"
+   },
+   "source": [
+    "Lets download some images."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "cOEqkMl47VTP"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "if not os.path.exists('images.zip'):\n",
+    "  !wget --no-check-certificate https://empslocal.ex.ac.uk/people/staff/ad735/ECMM426/images.zip\n",
+    "  !unzip -q images.zip"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "cjKpKTNYsxcF"
+   },
+   "source": [
+    "You can use the `imread` and  the`imshow` function to respectively read and show images. Here is an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "LEep7wnTs5Si"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "img = plt.imread('images/lena.png')\n",
+    "img_tinted = img * [1, 0.85, 0.8]\n",
+    "\n",
+    "# Show the original image\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.imshow(img)\n",
+    "\n",
+    "# Show the tinted image\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.imshow(img_tinted)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "wOan27So8lpI"
+   },
+   "source": [
+    "## Scikit-learn"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uSki-HDorHgE"
+   },
+   "source": [
+    "[Scikit-learn](https://scikit-learn.org/stable/) is an open source machine learning library that supports supervised and unsupervised learning. It also provides various tools for model fitting, data preprocessing, model selection, model evaluation, and many other utilities."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "BOwTaL8x2QJ1"
+   },
+   "source": [
+    "### Moon dataset\n",
+    "Below we will consider a toy dataset, such as moon dataset and consider some classifiers from the Scikit-learn library to classify them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-wudgYDp1xO_"
+   },
+   "outputs": [],
+   "source": [
+    "# Create the moon dataset and plot\n",
+    "from sklearn.datasets import make_moons\n",
+    "\n",
+    "X, y = make_moons(n_samples=500, noise=0.30, random_state=42)\n",
+    "\n",
+    "id0 = y == 0\n",
+    "id1 = y == 1\n",
+    "plt.plot(X[id0, 0], X[id0, 1], 'bo', label='0')\n",
+    "plt.plot(X[id1, 0], X[id1, 1], 'ro', label='1')\n",
+    "plt.legend(loc=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XbIu90Rg2TvB"
+   },
+   "source": [
+    "### Dataset split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "QVDMPmL62EIr"
+   },
+   "outputs": [],
+   "source": [
+    "# Split into train and test sets\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uZNqoqgW31rp"
+   },
+   "source": [
+    "### Random forest classifier\n",
+    "Lets now train a random forest classifier from the scikit-learn library on the above training set and test it on the test set, and the compute the classification accuracy. Please check the [documentation](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn-ensemble-randomforestclassifier) of `RandomForestClassifier` for more details on its parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "RC8sl3QE5BjD"
+   },
+   "outputs": [],
+   "source": [
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "# Define the classifier\n",
+    "rnd_clf = RandomForestClassifier(n_estimators=500, max_leaf_nodes=16, n_jobs=-1, random_state=42)\n",
+    "# Training\n",
+    "rnd_clf.fit(X_train, y_train)\n",
+    "# Test\n",
+    "y_pred_rf = rnd_clf.predict(X_test)\n",
+    "# Classification accuracy\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "print(accuracy_score(y_test, y_pred_rf))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "T8JLXEV97i8c"
+   },
+   "source": [
+    "### Non-linear Support Vector Machine\n",
+    "Now lets do the same training and testing with a non-linear [Support Vector Machine (SVM)](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html) classifier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "av46bVVs8w08"
+   },
+   "outputs": [],
+   "source": [
+    "from sklearn.svm import SVC\n",
+    "# Define the non-linear classifier with radial basis function (rbf) kernel\n",
+    "nlin_svm_clf_1 = SVC(kernel=\"rbf\")\n",
+    "# Training\n",
+    "nlin_svm_clf_1.fit(X_train, y_train)\n",
+    "# Test\n",
+    "y_pred = nlin_svm_clf_1.predict(X_test)\n",
+    "# Classification accuracy\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "print(accuracy_score(y_pred, y_test))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "74nKsfA99pkb"
+   },
+   "source": [
+    "### Confusion matrix\n",
+    "A confusion matrix is a table that is used to define the performance of a classification algorithm. A confusion matrix visualizes and summarizes the performance of a classification algorithm. More details on how to compute confusion matrix can be found in the [documentation](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "aB73WGra-aEF"
+   },
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import confusion_matrix\n",
+    "confusion_matrix(y_test, y_pred)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Wp2DsEemAOub"
+   },
+   "source": [
+    "### Regression\n",
+    "\n",
+    "Now, lets consider the following function and train an [MLP regressor](https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html) to learn it.\n",
+    "\n",
+    "\\begin{equation}\n",
+    "y = f(x; \\mathbf{w}) = 5x^2 + 3\n",
+    "\\end{equation}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "C5Dzr0MLA3h8"
+   },
+   "outputs": [],
+   "source": [
+    "# Create the data that follow uniform distribution\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "X = np.random.uniform(-100, 100, 1000)\n",
+    "y = 5*(X*X) + 3\n",
+    "plt.scatter(X, y, s=10);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Lr2qn7zxCKcK"
+   },
+   "outputs": [],
+   "source": [
+    "# Split the dataset into train and test sets\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "UXpmCrg0CbeA"
+   },
+   "outputs": [],
+   "source": [
+    "from sklearn.neural_network import MLPRegressor\n",
+    "# Define an MLPRegressor\n",
+    "regr = MLPRegressor(hidden_layer_sizes=(10,), solver='lbfgs', activation='relu', max_iter=10000)\n",
+    "# Fit on the training data\n",
+    "regr = regr.fit(X_train.reshape(-1, 1), y_train)\n",
+    "# Predict using the multi-layer perceptron model\n",
+    "y_pred = regr.predict(X_test.reshape(-1, 1))\n",
+    "# Return the coefficient of determination of the prediction. The best score can be 1.\n",
+    "regr.score(X_test.reshape(-1, 1), y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vxAwaKWhq6z5"
+   },
+   "source": [
+    "## OpenCV"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7S04s4KFz3EO"
+   },
+   "source": [
+    "OpenCV is a library providing implementation of multitude of algorithms related to image processing, computer vision and machine learning. In this section, we will learn different image processing functions from the OpenCV library. For more details on OpenCV, please see the [OpenCV website](https://opencv.org/)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "oTcZ703E2Zxh"
+   },
+   "source": [
+    "### Data structures\n",
+    "\n",
+    "Colour images usually have three channels: red, green and blue and these channels are usually arranged in a certain order. Depending on this arrangement the image is termed in a certain way. For example, if the channels in an image are ordered in red (R), green (G) and blue (B), the image is called as RGB image. In OpenCV an image can be read by `cv2.imread()` function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "W_6NRQ762_fP"
+   },
+   "outputs": [],
+   "source": [
+    "# read an image\n",
+    "import cv2\n",
+    "img = cv2.imread('images/lena.png')\n",
+    "\n",
+    "# show image format (basically a 3-d array of pixel colour info, in BGR format)\n",
+    "print('Image shape: {}'.format(img.shape))\n",
+    "print('Image: {}'.format(img))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "aZPEVuGh_p8V",
+    "pycharm": {}
+   },
+   "source": [
+    "### Colour conversions\n",
+    "By default, OpenCV loads images in BGR format. This is why the famous image of Lena looks a bit weird. **Note:** we will use imshow function from Matplotlib to display the image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "uPBA122WEzXM",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# show image with matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "plt.imshow(img)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "T89Km6qqQs3t"
+   },
+   "source": [
+    "In OpenCV, a BGR image can be converted to an RGB image by the `cv2.cvtColor()` function as follows"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "_kIGhwKc_p8V",
+    "pycharm": {},
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# convert image to RGB colour space\n",
+    "img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
+    "\n",
+    "# show image with matplotlib\n",
+    "plt.imshow(img)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "8WYalGWXQs3u"
+   },
+   "source": [
+    "In a similar way, a BGR image can also be converted to grayscale image which has only a single channel. Converting an RGB image into a grayscale image involves summing up the individual (RGB) components with the weights (0.299, 0.587, 0.114). The OpenCV function `cv2.cvtColor()` can also be used to convert an RGB image into a grayscale image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "vpS6RcOV_p8Y",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# convert image to grayscale\n",
+    "gray_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\n",
+    "\n",
+    "print('Image shape: {}'.format(gray_img.shape))\n",
+    "# grayscale image represented as a 2-d array\n",
+    "print(gray_img)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "E1yoDp2hCihi",
+    "pycharm": {}
+   },
+   "source": [
+    "Gray images have single channel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "z2-K1pOh_p8a",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# plot the gray image, note the cmap parameter\n",
+    "plt.imshow(gray_img, cmap='gray')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "B_EOqF8qQs3v"
+   },
+   "source": [
+    "Colour to grayscale is a lossy conversion. However, in OpenCV a grayscale image can approximately be converted to a colour image using the `cv2.applyColorMap()` function according to the colour maps described at this [link](https://docs.opencv.org/4.x/d3/d50/group__imgproc__colormap.html)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "eOs27PQFSYrn",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "gray_img_col = cv2.applyColorMap(gray_img, cv2.COLORMAP_JET)\n",
+    "plt.imshow(gray_img_col)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "cE_h8sgbQs3w"
+   },
+   "source": [
+    "### Conversion from `uint8` to `float64` (`double`) and Normalization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-6aepcnKQs3w",
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "img_dble = cv2.normalize(img.astype('float64'), None, 0.0, 1.0, cv2.NORM_MINMAX)\n",
+    "print(img_dble)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "tOh1DQ5s5Iyg"
+   },
+   "outputs": [],
+   "source": [
+    "plt.imshow(img_dble)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "PxNoVeWkwqDF"
+   },
+   "source": [
+    "### Image processing\n",
+    "Below we will review some brief image processing tasks, such as image filtering, binarization, edge detection etc with OpenCV."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "iIt6E6uC5aMS"
+   },
+   "source": [
+    "#### Box Filtering"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dAvdTtHeKQJJ",
+    "pycharm": {}
+   },
+   "source": [
+    "In this filtering, each pixel value in an image is replaced by the weighted average of the neighborhood (defined by the filter mask) intensity values. The most commonly used filter is the Box filter which has equal weights. A 3×3 normalized box filter is shown below\n",
+    "\n",
+    "![box filter](https://i2.wp.com/theailearner.com/wp-content/uploads/2019/05/filter1.png?w=454&ssl=1)\n",
+    "\n",
+    "It is a good practice to normalize the filter, this is why the above filter is divided by 9. This is to make sure that the image does not get brighter or darker. You can also use an unnormalized box filter.\n",
+    "\n",
+    "OpenCV provides two inbuilt functions for averaging namely:\n",
+    "\n",
+    "* `cv2.blur()` that blurs an image using only the normalized box filter and\n",
+    "* `cv2.boxFilter()` which is more general, having the option of using either normalized or unnormalized box filter. Just pass an argument normalize=False to the function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "HVb5aZSNLaGK",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "img = cv2.cvtColor(cv2.imread('images/books.jpg'), cv2.COLOR_BGR2RGB)\n",
+    "plt.imshow(img)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "gS2OY6czd2oX",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "gray_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\n",
+    "blur_img = cv2.blur(gray_img, (10, 10))\n",
+    "plt.subplot(1, 2, 1); plt.imshow(gray_img, cmap='gray')\n",
+    "plt.subplot(1, 2, 2); plt.imshow(blur_img, cmap='gray')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "tOqyh7ZD5nW0"
+   },
+   "source": [
+    "#### Gaussian Filtering"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EhoKd7Is_p8y",
+    "pycharm": {}
+   },
+   "source": [
+    "In Gaussian filtering, instead of a box filter, a Gaussian kernel is used. In OpenCV, it is done with the function, `cv2.GaussianBlur()`. We should specify the width and height of the kernel which should be positive and odd. We also should specify the standard deviation in the X and Y directions, sigmaX and sigmaY respectively. If only sigmaX is specified, sigmaY is taken as the same as sigmaX. If both are given as zeros, they are calculated from the kernel size. Gaussian blurring is highly effective in removing Gaussian noise from an image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "R2qNZNzB_p8z",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "img = cv2.cvtColor(cv2.imread('images/oy.jpg'), cv2.COLOR_BGR2RGB)\n",
+    "plt.imshow(img)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "FcEcRBhT_p81",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# preproccess with blurring, with 5x5 kernel (note kernel size should be odd)\n",
+    "img_blur_small = cv2.GaussianBlur(img, (5, 5), 0)\n",
+    "plt.imshow(img_blur_small)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "GcpJwBNU_p83",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "img_blur_small = cv2.GaussianBlur(img, (5, 5), 25)\n",
+    "plt.imshow(img_blur_small)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "GW_zbFBx_p85",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "img_blur_large = cv2.GaussianBlur(img, (15,15), 0)\n",
+    "plt.imshow(img_blur_large)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "knYfkspQ5y0F"
+   },
+   "source": [
+    "#### Median Filtering"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "rFRJL4v1O7kt",
+    "pycharm": {}
+   },
+   "source": [
+    "This is a non-linear filtering technique. As clear from the name, this takes a median of all the pixels under the kernel area and replaces the central element with this median value. This is quite effective in reducing a certain type of noise (like salt-and-pepper noise) with considerably less edge blurring as compared to other linear filters of the same size. First create the function for creating noisy images with \"salt and pepper\" noise."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "dqMvcYl3u_S8",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "def add_sp_noise(image, amount=0.1):\n",
+    "    row, col, ch = image.shape\n",
+    "    s_vs_p = 0.5\n",
+    "    out = np.copy(image)\n",
+    "    # Salt mode\n",
+    "    num_salt = np.ceil(amount * image.size * s_vs_p)\n",
+    "    coords = [np.random.randint(0, i - 1, int(num_salt))\n",
+    "            for i in image.shape]\n",
+    "    out[coords[0], coords[1], coords[2]] = 1\n",
+    "\n",
+    "    # Pepper mode\n",
+    "    num_pepper = np.ceil(amount* image.size * (1. - s_vs_p))\n",
+    "    coords = [np.random.randint(0, i - 1, int(num_pepper))\n",
+    "            for i in image.shape]\n",
+    "    out[coords[0], coords[1], coords[2]] = 0\n",
+    "    return out"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NBNSgJgfDgqv",
+    "pycharm": {}
+   },
+   "source": [
+    "Load an image and apply \"salt and pepper\" noise and then try to smooth it with Gaussian and Median filter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ea2GEwfFQLR1",
+    "pycharm": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "img = cv2.cvtColor(cv2.imread('images/coins.jpg'), cv2.COLOR_BGR2RGB)\n",
+    "noisy_img = add_sp_noise(img, amount=0.1)\n",
+    "img_gaus = cv2.GaussianBlur(noisy_img, (5, 5), 3)\n",
+    "img_med = cv2.medianBlur(noisy_img, 5)\n",
+    "plt.subplot(1, 4, 1); plt.imshow(img); plt.title('Original')\n",
+    "plt.subplot(1, 4, 2); plt.imshow(noisy_img); plt.title('Salt & Pepper Noise')\n",
+    "plt.subplot(1, 4, 3); plt.imshow(img_gaus); plt.title('Gaussian Filtered')\n",
+    "plt.subplot(1, 4, 4); plt.imshow(img_med); plt.title('Median Filtered')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jBSFKfNp58ka"
+   },
+   "source": [
+    "#### Edge Detection"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XxeFuSii_p9N",
+    "pycharm": {}
+   },
+   "source": [
+    "Edge detection is an image processing technique for finding the boundaries of objects within images. It works by detecting discontinuities in brightness, colour, surface etc. Edge detection is used for image segmentation and data extraction in areas such as image processing, computer vision, and machine vision. OpenCV provides the `cv2.Canny()` function to compute edges in an image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-utaqZp5SDP7",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "cups = cv2.cvtColor(cv2.imread('images/cups.jpg'), cv2.COLOR_BGR2RGB)\n",
+    "plt.imshow(cups)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "7Ko1a2jmSM-M",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# preprocess by blurring and grayscale\n",
+    "cups_preprocessed  = cv2.cvtColor(cv2.GaussianBlur(cups, (7,7), 0), cv2.COLOR_RGB2GRAY)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "a8-A44piSmwd",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# find binary image with thresholding\n",
+    "low_thresh = 120\n",
+    "high_thresh = 200\n",
+    "_, cups_thresh = cv2.threshold(cups_preprocessed, low_thresh, 255, cv2.THRESH_BINARY)\n",
+    "plt.imshow(cv2.cvtColor(cups_thresh, cv2.COLOR_GRAY2RGB))\n",
+    "\n",
+    "_, cups_thresh_hi = cv2.threshold(cups_preprocessed, high_thresh, 255, cv2.THRESH_BINARY)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "lVNkDIgDRuci",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# find binary image with edges\n",
+    "cups_edges = cv2.Canny(cups_preprocessed, threshold1=90, threshold2=110)\n",
+    "plt.imshow(cv2.cvtColor(cups_edges, cv2.COLOR_GRAY2RGB))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-XOcVQ4hqP4R"
+   },
+   "source": [
+    "## SciPy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "tAWDvNu5qn4b"
+   },
+   "source": [
+    "Numpy provides a high-performance multidimensional array and basic tools to compute with and manipulate these arrays. [SciPy](http://docs.scipy.org/doc/scipy/reference/) builds on this, and provides a large number of functions that operate on numpy arrays and are useful for different types of scientific and engineering applications. The best way to get familiar with SciPy is to [browse the documentation](https://docs.scipy.org/doc/scipy/reference/index.html). SciPy provides important functionalities for reading and writing MATLAB files, which show below.\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ajs-UbqSrWk0"
+   },
+   "source": [
+    "###MATLAB files"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HoT2zazhrZ5m"
+   },
+   "source": [
+    "The functions `scipy.io.loadmat` and `scipy.io.savemat` allow you to respectively read and write MATLAB files. You can read about them [in the documentation](http://docs.scipy.org/doc/scipy/reference/io.html)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "iMtaY6Bzr7-w"
+   },
+   "source": [
+    "###Distance between points"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1tq9Mtwkr_s0"
+   },
+   "source": [
+    "SciPy defines some useful functions for computing distances between sets of points.\n",
+    "\n",
+    "The function `scipy.spatial.distance.pdist` computes the distance between all pairs of points in a given set:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "EwlHRO0jsJBI"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from scipy.spatial.distance import pdist, squareform\n",
+    "\n",
+    "# Create the following array where each row is a point in 2D space:\n",
+    "# [[0 1]\n",
+    "#  [1 0]\n",
+    "#  [2 0]]\n",
+    "x = np.array([[0, 1], [1, 0], [2, 0]])\n",
+    "print(x)\n",
+    "\n",
+    "# Compute the Euclidean distance between all rows of x.\n",
+    "# d[i, j] is the Euclidean distance between x[i, :] and x[j, :],\n",
+    "# and d is the following array:\n",
+    "# [[ 0.          1.41421356  2.23606798]\n",
+    "#  [ 1.41421356  0.          1.        ]\n",
+    "#  [ 2.23606798  1.          0.        ]]\n",
+    "d = squareform(pdist(x, 'euclidean'))\n",
+    "print(d)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dzYk_QSfsSXO"
+   },
+   "source": [
+    "A similar function (`scipy.spatial.distance.cdist`) computes the distance between all pairs across two sets of points; you can read about it [in the documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.cdist.html)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "d3XD7jVkU9Z3"
+   },
+   "source": [
+    "#### Acknowledgement\n",
+    "This tutorial was originally written by [Justin Johnson](https://web.eecs.umich.edu/~justincj/) for CS231n at the Stanford University. This version has been adapted and modified by [Anjan Dutta](https://www.surrey.ac.uk/people/anjan-dutta) for the Spring 2023 edition of [EEEM068](https://catalogue.surrey.ac.uk/2022-3/module/EEEM068) module at the University of Surrey."
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "include_colab_link": true,
+   "name": "colab-tutorial.ipynb",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

Downloads/.ipynb_checkpoints/Python Tutorial-checkpoint.ipynb

@@ -0,0 +1,3313 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "view-in-github"
+   },
+   "source": [
+    "<a href=\"https://colab.research.google.com/github/AnjanDutta/EEEM068/blob/main/Notebooks/Python_Tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dzNng6vCL9eP"
+   },
+   "source": [
+    "<H1 style=\"text-align: center\">EEEM068 - Applied Machine Learning</H1>\n",
+    "<H1 style=\"text-align: center\">Workshop 01</H1>\n",
+    "<H1 style=\"text-align: center\">Python Tutorial</H1>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "qVrTo-LhL9eS"
+   },
+   "source": [
+    "##Introduction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9t1gKp9PL9eV"
+   },
+   "source": [
+    "Python is a great general purpose programming language on its own, but with the help of a few popular libraries, such as numpy, scipy, matplotlib it becomes a powerful environment for scientific computing.\n",
+    "\n",
+    "We expect that many of you to have some experience with Python and numpy. Nevertheless, for the rest of you, this tutorial will serve as a quick crash course both on the Python programming language and on the use of Python for scientific computing.\n",
+    "\n",
+    "Some of you may have previous knowledge in Matlab, in which case we also recommend the [NumPy for Matlab users](https://numpy.org/doc/stable/user/numpy-for-matlab-users.html) page."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "U1PvreR9L9eW"
+   },
+   "source": [
+    "In this tutorial, we will cover:\n",
+    "\n",
+    "* Basic Python: Basic data types (Containers, Lists, Dictionaries, Sets, Tuples), Functions, Classes\n",
+    "* Numpy: Arrays, Array indexing, Datatypes, Array math, Broadcasting\n",
+    "* Matplotlib: Plotting, Subplots, Images\n",
+    "* Scikit-learn: Toy dataset, Classifier, Confusion matrix, Regressor\n",
+    "* OpenCV: Image, Image representation, Colour and datatype conversion, Image processing\n",
+    "* SciPy: I/O of MATLAB files, Distance functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-O99OrwPtGii"
+   },
+   "source": [
+    "## Python Versions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "nxvEkGXPM3Xh"
+   },
+   "source": [
+    "Please note that as of February 2026, Colab is using Python 3.12.12. Therefore, we will be using Python 3.12 for this iteration of the course. More details on Python 3.12 can be found in the [documentation](https://docs.python.org/3.12/tutorial/index.html). You can check your Python version at the command line by running `python --version`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "1L4Am0QATgOc"
+   },
+   "outputs": [],
+   "source": [
+    "!python --version"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "JAFKYgrpL9eY"
+   },
+   "source": [
+    "##Basics of Python"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RbFS6tdgL9ea"
+   },
+   "source": [
+    "Python is an easy to learn, high-level, dynamically typed multiparadigm programming language. Python code is often said to be almost like pseudocode, since it allows you to express very powerful ideas in very few lines of code while being very readable. As an example, here is an implementation of the classic quicksort algorithm in Python:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "cYb0pjh1L9eb"
+   },
+   "outputs": [],
+   "source": [
+    "def quicksort(arr):\n",
+    "    if len(arr) <= 1:\n",
+    "        return arr\n",
+    "    pivot = arr[len(arr) // 2]\n",
+    "    left = [x for x in arr if x < pivot]\n",
+    "    middle = [x for x in arr if x == pivot]\n",
+    "    right = [x for x in arr if x > pivot]\n",
+    "    return quicksort(left) + middle + quicksort(right)\n",
+    "\n",
+    "print(quicksort([3,6,8,10,1,2,1]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NwS_hu4xL9eo"
+   },
+   "source": [
+    "###Basic data types"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "DL5sMSZ9L9eq"
+   },
+   "source": [
+    "####Numbers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "MGS0XEWoL9er"
+   },
+   "source": [
+    "Integers and floats work as you would expect from other languages:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "KheDr_zDL9es"
+   },
+   "outputs": [],
+   "source": [
+    "x = 3\n",
+    "print(x, type(x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "sk_8DFcuL9ey"
+   },
+   "outputs": [],
+   "source": [
+    "print(x + 1)   # Addition\n",
+    "print(x - 1)   # Subtraction\n",
+    "print(x * 2)   # Multiplication\n",
+    "print(x ** 2)  # Exponentiation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "U4Jl8K0tL9e4"
+   },
+   "outputs": [],
+   "source": [
+    "x += 1\n",
+    "print(x)\n",
+    "x *= 2\n",
+    "print(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "w-nZ0Sg_L9e9"
+   },
+   "outputs": [],
+   "source": [
+    "y = 2.5\n",
+    "print(type(y))\n",
+    "print(y, y + 1, y * 2, y ** 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "r2A9ApyaL9fB"
+   },
+   "source": [
+    "Note that unlike many languages (such as C and C++) Python does not have unary increment (x++) or decrement (x--) operators.\n",
+    "\n",
+    "Python also has built-in types for long integers and complex numbers; you can find all of the details in the [documentation](https://docs.python.org/3.8/library/stdtypes.html#numeric-types-int-float-long-complex)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EqRS7qhBL9fC"
+   },
+   "source": [
+    "####Booleans"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Nv_LIVOJL9fD"
+   },
+   "source": [
+    "Python implements all of the usual operators for Boolean logic, but uses English words rather than symbols (`&&`, `||`, etc.):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "RvoImwgGL9fE"
+   },
+   "outputs": [],
+   "source": [
+    "t, f = True, False\n",
+    "print(type(t))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "YQgmQfOgL9fI"
+   },
+   "source": [
+    "Now we let's look at the operations:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6zYm7WzCL9fK"
+   },
+   "outputs": [],
+   "source": [
+    "print(t and f) # Logical AND;\n",
+    "print(t or f)  # Logical OR;\n",
+    "print(not t)   # Logical NOT;\n",
+    "print(t != f)  # Logical XOR;"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "UQnQWFEyL9fP"
+   },
+   "source": [
+    "####Strings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "AijEDtPFL9fP"
+   },
+   "outputs": [],
+   "source": [
+    "hello = 'hello'   # String literals can use single quotes\n",
+    "world = \"world\"   # or double quotes; it does not matter\n",
+    "print(hello, len(hello))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "saDeaA7hL9fT"
+   },
+   "outputs": [],
+   "source": [
+    "hw = hello + ' ' + world  # String concatenation\n",
+    "print(hw)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Nji1_UjYL9fY"
+   },
+   "outputs": [],
+   "source": [
+    "hw12 = '{} {} {}'.format(hello, world, 12)  # string formatting\n",
+    "print(hw12)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "bUpl35bIL9fc"
+   },
+   "source": [
+    "String objects have a bunch of useful methods; for example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "VOxGatlsL9fd"
+   },
+   "outputs": [],
+   "source": [
+    "s = \"hello\"\n",
+    "print(s.capitalize())  # Capitalize a string\n",
+    "print(s.upper())       # Convert a string to uppercase; prints \"HELLO\"\n",
+    "print(s.rjust(7))      # Right-justify a string, padding with spaces\n",
+    "print(s.center(7))     # Center a string, padding with spaces\n",
+    "print(s.replace('l', '(ell)'))  # Replace all instances of one substring with another\n",
+    "print('  world '.strip())  # Strip leading and trailing whitespace"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "06cayXLtL9fi"
+   },
+   "source": [
+    "You can find a list of all string methods in the [documentation](https://docs.python.org/3.7/library/stdtypes.html#string-methods)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "p-6hClFjL9fk"
+   },
+   "source": [
+    "###Containers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FD9H18eQL9fk"
+   },
+   "source": [
+    "Python includes several built-in container types: lists, dictionaries, sets, and tuples."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "UsIWOe0LL9fn"
+   },
+   "source": [
+    "####Lists"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "wzxX7rgWL9fn"
+   },
+   "source": [
+    "A list is the Python equivalent of an array, but is resizeable and can contain elements of different types:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "hk3A8pPcL9fp"
+   },
+   "outputs": [],
+   "source": [
+    "xs = [3, 1, 2]   # Create a list\n",
+    "print(xs, xs[2])\n",
+    "print(xs[-1])    # Negative indices count from the end of the list; prints \"2\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "YCjCy_0_L9ft"
+   },
+   "outputs": [],
+   "source": [
+    "xs[2] = 'foo'    # Lists can be heterogeneous, i.e. it can contain elements of different types\n",
+    "print(xs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "vJ0x5cF-L9fx"
+   },
+   "outputs": [],
+   "source": [
+    "xs.append('bar') # Add a new element to the end of the list\n",
+    "print(xs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "cxVCNRTNL9f1"
+   },
+   "outputs": [],
+   "source": [
+    "x = xs.pop()     # Remove and return the last element of the list\n",
+    "print(x, xs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ilyoyO34L9f4"
+   },
+   "source": [
+    "As usual, you can find all the gory details about lists in the [documentation](https://docs.python.org/3.7/tutorial/datastructures.html#more-on-lists)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ovahhxd_L9f5"
+   },
+   "source": [
+    "####Slicing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "YeSYKhv9L9f6"
+   },
+   "source": [
+    "In addition to accessing list elements one at a time, Python provides concise syntax to access sublists; this is known as slicing:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ninq666bL9f6"
+   },
+   "outputs": [],
+   "source": [
+    "nums = list(range(5))   # range is a built-in function that creates a list of integers\n",
+    "print(nums)             # Prints \"[0, 1, 2, 3, 4]\"\n",
+    "print(nums[2:4])        # Get a slice from index 2 to 4 (exclusive); prints \"[2, 3]\"\n",
+    "print(nums[2:])         # Get a slice from index 2 to the end; prints \"[2, 3, 4]\"\n",
+    "print(nums[:2])         # Get a slice from the start to index 2 (exclusive); prints \"[0, 1]\"\n",
+    "print(nums[:])          # Get a slice of the whole list; prints [\"0, 1, 2, 3, 4]\"\n",
+    "print(nums[:-1])        # Slice indices can be negative; prints [\"0, 1, 2, 3]\"\n",
+    "nums[2:4] = [8, 9]      # Assign a new sublist to a slice\n",
+    "print(nums)             # Prints \"[0, 1, 8, 9, 4]\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "arrLCcMyL9gK"
+   },
+   "source": [
+    "####List comprehensions:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "5Qn2jU_pL9gL"
+   },
+   "source": [
+    "When programming, frequently we want to transform one type of data into another. As a simple example, consider the following code that computes square numbers:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "IVNEwoMXL9gL"
+   },
+   "outputs": [],
+   "source": [
+    "nums = [0, 1, 2, 3, 4]\n",
+    "squares = []\n",
+    "for x in nums:\n",
+    "    squares.append(x ** 2)\n",
+    "print(squares)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7DmKVUFaL9gQ"
+   },
+   "source": [
+    "You can make this code simpler using a list comprehension:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "kZxsUfV6L9gR"
+   },
+   "outputs": [],
+   "source": [
+    "nums = [0, 1, 2, 3, 4]\n",
+    "squares = [x ** 2 for x in nums]\n",
+    "print(squares)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-D8ARK7tL9gV"
+   },
+   "source": [
+    "List comprehensions can also contain conditions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "yUtgOyyYL9gV"
+   },
+   "outputs": [],
+   "source": [
+    "nums = [0, 1, 2, 3, 4]\n",
+    "even_squares = [x ** 2 for x in nums if x % 2 == 0]\n",
+    "print(even_squares)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "H8xsUEFpL9gZ"
+   },
+   "source": [
+    "####Dictionaries"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kkjAGMAJL9ga"
+   },
+   "source": [
+    "A dictionary stores (key, value) pairs, similar to a `Map` in Java or an object in Javascript. You can use it like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "XBYI1MrYL9gb"
+   },
+   "outputs": [],
+   "source": [
+    "d = {'cat': 'cute', 'dog': 'furry'}     # Create a new dictionary with some data\n",
+    "print(d['cat'])                         # Get an entry from a dictionary; prints \"cute\"\n",
+    "print('cat' in d)                       # Check if a dictionary has a given key; prints \"True\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pS7e-G-HL9gf"
+   },
+   "outputs": [],
+   "source": [
+    "d['fish'] = 'wet'   # Set an entry in a dictionary\n",
+    "print(d['fish'])    # Prints \"wet\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "tFY065ItL9gi"
+   },
+   "outputs": [],
+   "source": [
+    "print(d['monkey'])  # KeyError: 'monkey' not a key of d"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "8TjbEWqML9gl"
+   },
+   "outputs": [],
+   "source": [
+    "print(d.get('monkey', 'N/A'))  # Get an element with a default; prints \"N/A\"\n",
+    "print(d.get('fish', 'N/A'))    # Get an element with a default; prints \"wet\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "0EItdNBJL9go"
+   },
+   "outputs": [],
+   "source": [
+    "del d['fish']               # Remove an element from a dictionary\n",
+    "print(d.get('fish', 'N/A')) # \"fish\" is no longer a key; prints \"N/A\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "wqm4dRZNL9gr"
+   },
+   "source": [
+    "You can find all you need to know about dictionaries in the [documentation](https://docs.python.org/2/library/stdtypes.html#dict)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "IxwEqHlGL9gr"
+   },
+   "source": [
+    "It is easy to iterate over the keys in a dictionary:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "rYfz7ZKNL9gs"
+   },
+   "outputs": [],
+   "source": [
+    "d = {'person': 2, 'cat': 4, 'spider': 8}\n",
+    "for animal, legs in d.items():\n",
+    "    print('A {} has {} legs'.format(animal, legs))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "17sxiOpzL9gz"
+   },
+   "source": [
+    "Dictionary comprehensions: These are similar to list comprehensions, but allow you to easily construct dictionaries. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "8PB07imLL9gz"
+   },
+   "outputs": [],
+   "source": [
+    "nums = [0, 1, 2, 3, 4]\n",
+    "even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}\n",
+    "print(even_num_to_square)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "V9MHfUdvL9g2"
+   },
+   "source": [
+    "####Sets"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Rpm4UtNpL9g2"
+   },
+   "source": [
+    "A set is an unordered collection of distinct elements. As a simple example, consider the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "MmyaniLsL9g2"
+   },
+   "outputs": [],
+   "source": [
+    "animals = {'cat', 'dog'}\n",
+    "print('cat' in animals)   # Check if an element is in a set; prints \"True\"\n",
+    "print('fish' in animals)  # prints \"False\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ElJEyK86L9g6"
+   },
+   "outputs": [],
+   "source": [
+    "animals.add('fish')      # Add an element to a set\n",
+    "print('fish' in animals)\n",
+    "print(len(animals))       # Number of elements in a set;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "5uGmrxdPL9g9"
+   },
+   "outputs": [],
+   "source": [
+    "animals.add('cat')       # Adding an element that is already in the set does nothing\n",
+    "print(len(animals))\n",
+    "animals.remove('cat')    # Remove an element from a set\n",
+    "print(len(animals))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "zk2DbvLKL9g_"
+   },
+   "source": [
+    "_Loops_: Iterating over a set has the same syntax as iterating over a list; however since sets are unordered, you cannot make assumptions about the order in which you visit the elements of the set:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "K47KYNGyL9hA"
+   },
+   "outputs": [],
+   "source": [
+    "animals = {'cat', 'dog', 'fish'}\n",
+    "for idx, animal in enumerate(animals):\n",
+    "    print('#{}: {}'.format(idx + 1, animal))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "puq4S8buL9hC"
+   },
+   "source": [
+    "Set comprehensions: Like lists and dictionaries, we can easily construct sets using set comprehensions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "iw7k90k3L9hC"
+   },
+   "outputs": [],
+   "source": [
+    "from math import sqrt\n",
+    "print({int(sqrt(x)) for x in range(30)})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "qPsHSKB1L9hF"
+   },
+   "source": [
+    "####Tuples"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kucc0LKVL9hG"
+   },
+   "source": [
+    "A tuple is an (immutable) ordered list of values. A tuple is in many ways similar to a list; one of the most important differences is that tuples can be used as keys in dictionaries and as elements of sets, while lists cannot. Here is a trivial example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "9wHUyTKxL9hH"
+   },
+   "outputs": [],
+   "source": [
+    "d = {(x, x + 1): x for x in range(10)}  # Create a dictionary with tuple keys\n",
+    "t = (5, 6)       # Create a tuple\n",
+    "print(type(t))\n",
+    "print(d[t])\n",
+    "print(d[(1, 2)])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "iFON3Tm0CfIg"
+   },
+   "source": [
+    "##Loops"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7aXUmwT69XqK"
+   },
+   "source": [
+    "###`for` loop"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_DYz1j6QL9f_"
+   },
+   "source": [
+    "You can loop over the elements of a list like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "4cCOysfWL9gA"
+   },
+   "outputs": [],
+   "source": [
+    "animals = ['cat', 'dog', 'monkey']\n",
+    "for animal in animals:\n",
+    "    print(animal)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "KxIaQs7pL9gE"
+   },
+   "source": [
+    "If you want access to the index of each element within the body of a loop, use the built-in `enumerate` function:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JjGnDluWL9gF"
+   },
+   "outputs": [],
+   "source": [
+    "animals = ['cat', 'dog', 'monkey']\n",
+    "for idx, animal in enumerate(animals):\n",
+    "    print('#{}: {}'.format(idx + 1, animal))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Tlf5gPRy9jfV"
+   },
+   "source": [
+    "###`range()` function"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "pzgK4H6j-PyN"
+   },
+   "source": [
+    "If you need to iterate over a sequence of numbers, the built-in function `range()` comes in handy. It generates arithmetic progressions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "eNlqr8sn-TX5"
+   },
+   "outputs": [],
+   "source": [
+    "for i in range(5):\n",
+    "    print(i)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vfigt0cE-fpp"
+   },
+   "source": [
+    "The given end point is never part of the generated sequence; `range(10)` generates 10 values, the legal indices for items of a sequence of length 10. It is possible to let the range start at another number, or to specify a different increment (even negative; sometimes this is called the ‘step’):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "apwUH4Ar-o4P"
+   },
+   "outputs": [],
+   "source": [
+    "print(list(range(5, 10)))\n",
+    "print(list(range(0, 10, 3)))\n",
+    "print(list(range(-10, -100, -30)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "mezbBTJqCmZy"
+   },
+   "source": [
+    "###`while` loop"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "A5qN9PZTCuvS"
+   },
+   "source": [
+    "With the `while` loop we can execute a set of statements as long as a condition is true."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "T0NbKi1hCyCE"
+   },
+   "outputs": [],
+   "source": [
+    "i = 1\n",
+    "while i < 6:\n",
+    "  print(i)\n",
+    "  i += 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uBXI2gMx9Dno"
+   },
+   "source": [
+    "## Control Flow Tools"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "q6aeyPu39PPC"
+   },
+   "source": [
+    "###`if` statement"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "eHUyBp-E_V-x"
+   },
+   "source": [
+    "Perhaps the most well-known statement type is the if statement. There can be zero or more `elif` parts, and the `else` part is optional. The keyword `elif` is short for `else if`, and is useful to avoid excessive indentation. An `if` … `elif` … `elif` … sequence is a substitute for the `switch` or `case` statements found in other languages. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "nD8ITrA__Z5D"
+   },
+   "outputs": [],
+   "source": [
+    "x = int(input(\"Please enter an integer: \"))\n",
+    "if x < 0:\n",
+    "    x = 0\n",
+    "    print('Negative changed to zero')\n",
+    "elif x == 0:\n",
+    "    print('Zero')\n",
+    "elif x == 1:\n",
+    "    print('Single')\n",
+    "else:\n",
+    "    print('More')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Y0CBMSRJ9sby"
+   },
+   "source": [
+    "###`break` and `continue` statements"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XrfS77Kzi91S"
+   },
+   "source": [
+    "The `break` statement, like in C, breaks out of the innermost enclosing `for` or `while` loop.\n",
+    "\n",
+    "Loop statements may have an else clause; it is executed when the loop terminates through exhaustion of the iterable (with `for`) or when the condition becomes false (with `while`), but not when the loop is terminated by a `break` statement. This is exemplified by the following loop, which searches for prime numbers:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "S2XoBEftjaXX"
+   },
+   "outputs": [],
+   "source": [
+    "for n in range(2, 10):\n",
+    "    for x in range(2, n):\n",
+    "        if n % x == 0:\n",
+    "            print(n, 'equals', x, '*', n//x)\n",
+    "            break\n",
+    "    else:\n",
+    "        # loop fell through without finding a factor\n",
+    "        print(n, 'is a prime number')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "b5pf2Vdbkl0_"
+   },
+   "source": [
+    "The `continue` statement, also borrowed from C, continues with the next iteration of the loop:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "swr6-rEwksE2"
+   },
+   "outputs": [],
+   "source": [
+    "for num in range(2, 10):\n",
+    "    if num % 2 == 0:\n",
+    "        print(\"Found an even number\", num)\n",
+    "        continue\n",
+    "    print(\"Found an odd number\", num)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "JVKNnslx95_d"
+   },
+   "source": [
+    "###`pass` statement"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-dZk28jllX6D"
+   },
+   "source": [
+    "The `pass` statement does nothing. It can be used when a statement is required syntactically but the program requires no action. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "DnJfJPkTldUz"
+   },
+   "outputs": [],
+   "source": [
+    "while True:\n",
+    "    pass  # Busy-wait for keyboard interrupt. Please press the stop button to stop execution."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-tWb6by_lkn3"
+   },
+   "source": [
+    "This is commonly used for creating minimal classes:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "57_9LZkplsSz"
+   },
+   "outputs": [],
+   "source": [
+    "class MyEmptyClass:\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "45jdssyFlxqo"
+   },
+   "source": [
+    "Another place `pass` can be used is as a place-holder for a function or conditional body when you are working on new code, allowing you to keep thinking at a more abstract level. The `pass` is silently ignored:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "0r9Dikptl4-1"
+   },
+   "outputs": [],
+   "source": [
+    "def initlog(*args):\n",
+    "    pass   # Remember to implement this!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "AXA4jrEOL9hM"
+   },
+   "source": [
+    "###Functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "WaRms-QfL9hN"
+   },
+   "source": [
+    "Python functions are defined using the `def` keyword. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "kiMDUr58L9hN"
+   },
+   "outputs": [],
+   "source": [
+    "def sign(x):\n",
+    "    if x > 0:\n",
+    "        return 'positive'\n",
+    "    elif x < 0:\n",
+    "        return 'negative'\n",
+    "    else:\n",
+    "        return 'zero'\n",
+    "\n",
+    "for x in [-1, 0, 1]:\n",
+    "    print(sign(x))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "U-QJFt8TL9hR"
+   },
+   "source": [
+    "We will often define functions to take optional keyword arguments, like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "PfsZ3DazL9hR"
+   },
+   "outputs": [],
+   "source": [
+    "def hello(name, loud=False):\n",
+    "    if loud:\n",
+    "        print('HELLO, {}'.format(name.upper()))\n",
+    "    else:\n",
+    "        print('Hello, {}!'.format(name))\n",
+    "\n",
+    "hello('Bob')\n",
+    "hello('Fred', loud=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ObA9PRtQL9hT"
+   },
+   "source": [
+    "###Classes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hAzL_lTkL9hU"
+   },
+   "source": [
+    "In object-oriented programming, a class is a template definition of the methods and variables in a particular kind of object. Thus, an object is a specific instance of a class; it contains real values instead of variables. For more details, on class in object oriented programming, please have a look on this [link](https://www.w3schools.com/java/java_oop.asp). The syntax for defining classes in Python is straightforward and can be done as follows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "RWdbaGigL9hU"
+   },
+   "outputs": [],
+   "source": [
+    "class Greeter:\n",
+    "\n",
+    "    # Constructor\n",
+    "    def __init__(self, name):\n",
+    "        self.name = name  # Create an instance variable\n",
+    "\n",
+    "    # Instance method\n",
+    "    def greet(self, loud=False):\n",
+    "        if loud:\n",
+    "          print('HELLO, {}'.format(self.name.upper()))\n",
+    "        else:\n",
+    "          print('Hello, {}!'.format(self.name))\n",
+    "\n",
+    "g = Greeter('Fred')  # Construct an instance of the Greeter class\n",
+    "g.greet()            # Call an instance method; prints \"Hello, Fred\"\n",
+    "g.greet(loud=True)   # Call an instance method; prints \"HELLO, FRED!\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3cfrOV4dL9hW"
+   },
+   "source": [
+    "##Numpy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fY12nHhyL9hX"
+   },
+   "source": [
+    "Numpy is the core library for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with these arrays. If you are already familiar with MATLAB, you might find this [tutorial](http://wiki.scipy.org/NumPy_for_Matlab_Users) useful to get started with Numpy. To use Numpy, we first need to import the `numpy` package."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2_lpLqwZpd-4"
+   },
+   "source": [
+    "### Importing a package"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hMmlsjljBbVE"
+   },
+   "source": [
+    "In Python, a package or a module can be imported in many different ways, some of which are shown below. For more details, please have a look on this [documentation](https://docs.python.org/3/tutorial/modules.html#more-on-modules).\n",
+    "\n",
+    "\n",
+    "```\n",
+    "import numpy            # import numpy, one can use it as numpy\n",
+    "import numpy as np      # import numpy and call it np\n",
+    "from numpy import *     # import all the modules from numpy\n",
+    "from numpy import sum   # import the \"sum\" function from numpy\n",
+    "```\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "58QdX8BLL9hZ"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np  # import numpy and call it np. So the sum function of numpy can be called as np.sum()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "DDx6v1EdL9hb"
+   },
+   "source": [
+    "###Arrays"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "f-Zv3f7LL9hc"
+   },
+   "source": [
+    "A numpy array is a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. The number of dimensions is the rank of the array; the shape of an array is a tuple of integers giving the size of the array along each dimension."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_eMTRnZRL9hc"
+   },
+   "source": [
+    "We can initialize numpy arrays from nested Python lists, and access elements using square brackets:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-l3JrGxCL9hc"
+   },
+   "outputs": [],
+   "source": [
+    "a = np.array([1, 2, 3])  # Create a rank 1 array\n",
+    "print(type(a), a.shape, a[0], a[1], a[2])\n",
+    "a[0] = 5                 # Change an element of the array\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ma6mk-kdL9hh"
+   },
+   "outputs": [],
+   "source": [
+    "b = np.array([[1,2,3],[4,5,6]])   # Create a rank 2 array\n",
+    "print(b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ymfSHAwtL9hj"
+   },
+   "outputs": [],
+   "source": [
+    "print(b.shape)\n",
+    "print(b[0, 0], b[0, 1], b[1, 0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "F2qwdyvuL9hn"
+   },
+   "source": [
+    "Numpy also provides many functions to create arrays:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "mVTN_EBqL9hn"
+   },
+   "outputs": [],
+   "source": [
+    "a = np.zeros((2,2))  # Create an array of all zeros\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "skiKlNmlL9h5"
+   },
+   "outputs": [],
+   "source": [
+    "b = np.ones((1,2))   # Create an array of all ones\n",
+    "print(b)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "HtFsr03bL9h7"
+   },
+   "outputs": [],
+   "source": [
+    "c = np.full((2,2), 7) # Create a constant array\n",
+    "print(c)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-QcALHvkL9h9"
+   },
+   "outputs": [],
+   "source": [
+    "d = np.eye(2)        # Create a 2x2 identity matrix\n",
+    "print(d)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "RCpaYg9qL9iA"
+   },
+   "outputs": [],
+   "source": [
+    "e = np.random.random((2,2)) # Create an array filled with random values\n",
+    "print(e)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jI5qcSDfL9iC"
+   },
+   "source": [
+    "###Array indexing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "M-E4MUeVL9iC"
+   },
+   "source": [
+    "Numpy offers several ways to index into arrays.\n",
+    "\n",
+    "Slicing: Similar to Python lists, numpy arrays can be sliced. Since arrays may be multidimensional, you must specify a slice for each dimension of the array:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "wLWA0udwL9iD"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "# Create the following rank 2 array with shape (3, 4)\n",
+    "# [[ 1  2  3  4]\n",
+    "#  [ 5  6  7  8]\n",
+    "#  [ 9 10 11 12]]\n",
+    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
+    "\n",
+    "# Use slicing to pull out the subarray consisting of the first 2 rows\n",
+    "# and columns 1 and 2; b is the following array of shape (2, 2):\n",
+    "# [[2 3]\n",
+    "#  [6 7]]\n",
+    "b = a[:2, 1:3]\n",
+    "print(b)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "KahhtZKYL9iF"
+   },
+   "source": [
+    "A slice of an array is a view into the same data, so modifying it will modify the original array."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "1kmtaFHuL9iG"
+   },
+   "outputs": [],
+   "source": [
+    "print(a[0, 1])\n",
+    "b[0, 0] = 77    # b[0, 0] is the same piece of data as a[0, 1]\n",
+    "print(a[0, 1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "_Zcf3zi-L9iI"
+   },
+   "source": [
+    "You can also mix integer indexing with slice indexing. However, doing so will yield an array of lower rank than the original array. Note that this is quite different from the way that MATLAB handles array slicing:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "G6lfbPuxL9iJ"
+   },
+   "outputs": [],
+   "source": [
+    "# Create the following rank 2 array with shape (3, 4)\n",
+    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NCye3NXhL9iL"
+   },
+   "source": [
+    "Two ways of accessing the data in the middle row of the array.\n",
+    "Mixing integer indexing with slices yields an array of lower rank,\n",
+    "while using only slices yields an array of the same rank as the\n",
+    "original array:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "EOiEMsmNL9iL"
+   },
+   "outputs": [],
+   "source": [
+    "row_r1 = a[1, :]    # Rank 1 view of the second row of a\n",
+    "row_r2 = a[1:2, :]  # Rank 2 view of the second row of a\n",
+    "row_r3 = a[[1], :]  # Rank 2 view of the second row of a\n",
+    "print(row_r1, row_r1.shape)\n",
+    "print(row_r2, row_r2.shape)\n",
+    "print(row_r3, row_r3.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JXu73pfDL9iN"
+   },
+   "outputs": [],
+   "source": [
+    "# We can make the same distinction when accessing columns of an array:\n",
+    "col_r1 = a[:, 1]\n",
+    "col_r2 = a[:, 1:2]\n",
+    "print(col_r1, col_r1.shape)\n",
+    "print()\n",
+    "print(col_r2, col_r2.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VP3916bOL9iP"
+   },
+   "source": [
+    "Integer array indexing: When you index into numpy arrays using slicing, the resulting array view will always be a subarray of the original array. In contrast, integer array indexing allows you to construct arbitrary arrays using the data from another array. Here is an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TBnWonIDL9iP"
+   },
+   "outputs": [],
+   "source": [
+    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
+    "\n",
+    "# An example of integer array indexing.\n",
+    "# The returned array will have shape (3,) and\n",
+    "print(a[[0, 1, 2], [0, 1, 0]])\n",
+    "\n",
+    "# The above example of integer array indexing is equivalent to this:\n",
+    "print(np.array([a[0, 0], a[1, 1], a[2, 0]]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "n7vuati-L9iR"
+   },
+   "outputs": [],
+   "source": [
+    "# When using integer array indexing, you can reuse the same\n",
+    "# element from the source array:\n",
+    "print(a[[0, 0], [1, 1]])\n",
+    "\n",
+    "# Equivalent to the previous integer array indexing example\n",
+    "print(np.array([a[0, 1], a[0, 1]]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kaipSLafL9iU"
+   },
+   "source": [
+    "One useful trick with integer array indexing is selecting or mutating one element from each row of a matrix:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ehqsV7TXL9iU"
+   },
+   "outputs": [],
+   "source": [
+    "# Create a new array from which we will select elements\n",
+    "a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pAPOoqy5L9iV"
+   },
+   "outputs": [],
+   "source": [
+    "# Create an array of indices\n",
+    "b = np.array([0, 2, 0, 1])\n",
+    "\n",
+    "# Select one element from each row of a using the indices in b\n",
+    "print(a[np.arange(4), b])  # Prints \"[ 1  6  7 11]\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "6v1PdI1DL9ib"
+   },
+   "outputs": [],
+   "source": [
+    "# Mutate one element from each row of a using the indices in b\n",
+    "a[np.arange(4), b] += 10\n",
+    "print(a)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kaE8dBGgL9id"
+   },
+   "source": [
+    "Boolean array indexing: Boolean array indexing lets you pick out arbitrary elements of an array. Frequently this type of indexing is used to select the elements of an array that satisfy some condition. Here is an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "32PusjtKL9id"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
+    "\n",
+    "bool_idx = (a > 2)  # Find the elements of a that are bigger than 2;\n",
+    "                    # this returns a numpy array of Booleans of the same\n",
+    "                    # shape as a, where each slot of bool_idx tells\n",
+    "                    # whether that element of a is > 2.\n",
+    "\n",
+    "print(bool_idx)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "cb2IRMXaL9if"
+   },
+   "outputs": [],
+   "source": [
+    "# We use boolean array indexing to construct a rank 1 array\n",
+    "# consisting of the elements of a corresponding to the True values\n",
+    "# of bool_idx\n",
+    "print(a[bool_idx])\n",
+    "\n",
+    "# We can do all of the above in a single concise statement:\n",
+    "print(a[a > 2])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CdofMonAL9ih"
+   },
+   "source": [
+    "For brevity we have left out a lot of details about numpy array indexing; if you want to know more you should read the documentation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jTctwqdQL9ih"
+   },
+   "source": [
+    "###Datatypes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kSZQ1WkIL9ih"
+   },
+   "source": [
+    "Every numpy array is a grid of elements of the same type. Numpy provides a large set of numeric datatypes that you can use to construct arrays. Numpy tries to guess a datatype when you create an array, but functions that construct arrays usually also include an optional argument to explicitly specify the datatype. Here is an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "4za4O0m5L9ih"
+   },
+   "outputs": [],
+   "source": [
+    "x = np.array([1, 2])  # Let numpy choose the datatype\n",
+    "y = np.array([1.0, 2.0])  # Let numpy choose the datatype\n",
+    "z = np.array([1, 2], dtype=np.int64)  # Force a particular datatype\n",
+    "\n",
+    "print(x.dtype, y.dtype, z.dtype)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "RLVIsZQpL9ik"
+   },
+   "source": [
+    "You can read all about numpy datatypes in the [documentation](http://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "TuB-fdhIL9ik"
+   },
+   "source": [
+    "###Array math"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "18e8V8elL9ik"
+   },
+   "source": [
+    "Basic mathematical functions operate elementwise on arrays, and are available both as operator overloads and as functions in the numpy module:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "gHKvBrSKL9il"
+   },
+   "outputs": [],
+   "source": [
+    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
+    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
+    "\n",
+    "# Elementwise sum; both produce the array\n",
+    "print(x + y)\n",
+    "print(np.add(x, y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "1fZtIAMxL9in"
+   },
+   "outputs": [],
+   "source": [
+    "# Elementwise difference; both produce the array\n",
+    "print(x - y)\n",
+    "print(np.subtract(x, y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "nil4AScML9io"
+   },
+   "outputs": [],
+   "source": [
+    "# Elementwise product; both produce the array\n",
+    "print(x * y)\n",
+    "print(np.multiply(x, y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "0JoA4lH6L9ip"
+   },
+   "outputs": [],
+   "source": [
+    "# Elementwise division; both produce the array\n",
+    "# [[ 0.2         0.33333333]\n",
+    "#  [ 0.42857143  0.5       ]]\n",
+    "print(x / y)\n",
+    "print(np.divide(x, y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "g0iZuA6bL9ir"
+   },
+   "outputs": [],
+   "source": [
+    "# Elementwise square root; produces the array\n",
+    "# [[ 1.          1.41421356]\n",
+    "#  [ 1.73205081  2.        ]]\n",
+    "print(np.sqrt(x))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "a5d_uujuL9it"
+   },
+   "source": [
+    "Note that unlike MATLAB, `*` is elementwise multiplication, not matrix multiplication. We instead use the dot function to compute inner products of vectors, to multiply a vector by a matrix, and to multiply matrices. dot is available both as a function in the numpy module and as an instance method of array objects:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "I3FnmoSeL9iu"
+   },
+   "outputs": [],
+   "source": [
+    "x = np.array([[1,2],[3,4]])\n",
+    "y = np.array([[5,6],[7,8]])\n",
+    "\n",
+    "v = np.array([9, 10])\n",
+    "w = np.array([11, 12])\n",
+    "\n",
+    "# Inner product of vectors; both produce 219\n",
+    "print(v.dot(w))\n",
+    "print(np.dot(v, w))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vmxPbrHASVeA"
+   },
+   "source": [
+    "You can also use the `@` operator which is equivalent to numpy's `dot` operator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "vyrWA-mXSdtt"
+   },
+   "outputs": [],
+   "source": [
+    "print(v @ w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "zvUODeTxL9iw"
+   },
+   "outputs": [],
+   "source": [
+    "# Matrix / vector product; both produce the rank 1 array [29 67]\n",
+    "print(x.dot(v))\n",
+    "print(np.dot(x, v))\n",
+    "print(x @ v)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "3V_3NzNEL9iy"
+   },
+   "outputs": [],
+   "source": [
+    "# Matrix / matrix product; both produce the rank 2 array\n",
+    "# [[19 22]\n",
+    "#  [43 50]]\n",
+    "print(x.dot(y))\n",
+    "print(np.dot(x, y))\n",
+    "print(x @ y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "FbE-1If_L9i0"
+   },
+   "source": [
+    "Numpy provides many useful functions for performing computations on arrays; one of the most useful is `sum`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "DZUdZvPrL9i0"
+   },
+   "outputs": [],
+   "source": [
+    "x = np.array([[1,2],[3,4]])\n",
+    "\n",
+    "print(np.sum(x))  # Compute sum of all elements; prints \"10\"\n",
+    "print(np.sum(x, axis=0))  # Compute sum of each column; prints \"[4 6]\"\n",
+    "print(np.sum(x, axis=1))  # Compute sum of each row; prints \"[3 7]\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ahdVW4iUL9i3"
+   },
+   "source": [
+    "You can find the full list of mathematical functions provided by numpy in the [documentation](http://docs.scipy.org/doc/numpy/reference/routines.math.html).\n",
+    "\n",
+    "Apart from computing mathematical functions using arrays, we frequently need to reshape or otherwise manipulate data in arrays. The simplest example of this type of operation is transposing a matrix; to transpose a matrix, simply use the T attribute of an array object:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "63Yl1f3oL9i3"
+   },
+   "outputs": [],
+   "source": [
+    "print(x)\n",
+    "print(\"transpose\\n\", x.T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "mkk03eNIL9i4"
+   },
+   "outputs": [],
+   "source": [
+    "v = np.array([[1,2,3]])\n",
+    "print(v )\n",
+    "print(\"transpose\\n\", v.T)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "REfLrUTcL9i7"
+   },
+   "source": [
+    "###Broadcasting"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EygGAMWqL9i7"
+   },
+   "source": [
+    "Broadcasting is a powerful mechanism that allows numpy to work with arrays of different shapes when performing arithmetic operations. Frequently we have a smaller array and a larger array, and we want to use the smaller array multiple times to perform some operation on the larger array.\n",
+    "\n",
+    "For example, suppose that we want to add a constant vector to each row of a matrix. We could do it like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "WEEvkV1ZL9i7"
+   },
+   "outputs": [],
+   "source": [
+    "# We will add the vector v to each row of the matrix x,\n",
+    "# storing the result in the matrix y\n",
+    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
+    "v = np.array([1, 0, 1])\n",
+    "y = np.empty_like(x)   # Create an empty matrix with the same shape as x\n",
+    "\n",
+    "# Add the vector v to each row of the matrix x with an explicit loop\n",
+    "for i in range(4):\n",
+    "    y[i, :] = x[i, :] + v\n",
+    "\n",
+    "print(y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2OlXXupEL9i-"
+   },
+   "source": [
+    "This works; however when the matrix `x` is very large, computing an explicit loop in Python could be slow. Note that adding the vector v to each row of the matrix `x` is equivalent to forming a matrix `vv` by stacking multiple copies of `v` vertically, then performing elementwise summation of `x` and `vv`. We could implement this approach like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "vS7UwAQQL9i-"
+   },
+   "outputs": [],
+   "source": [
+    "vv = np.tile(v, (4, 1))  # Stack 4 copies of v on top of each other\n",
+    "print(vv)                # Prints \"[[1 0 1]\n",
+    "                         #          [1 0 1]\n",
+    "                         #          [1 0 1]\n",
+    "                         #          [1 0 1]]\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "N0hJphSIL9jA"
+   },
+   "outputs": [],
+   "source": [
+    "y = x + vv  # Add x and vv elementwise\n",
+    "print(y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "zHos6RJnL9jB"
+   },
+   "source": [
+    "Numpy broadcasting allows us to perform this computation without actually creating multiple copies of v. Consider this version, using broadcasting:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "vnYFb-gYL9jC"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "# We will add the vector v to each row of the matrix x,\n",
+    "# storing the result in the matrix y\n",
+    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
+    "v = np.array([1, 0, 1])\n",
+    "y = x + v  # Add v to each row of x using broadcasting\n",
+    "print(y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "08YyIURKL9jH"
+   },
+   "source": [
+    "The line `y = x + v` works even though `x` has shape `(4, 3)` and `v` has shape `(3,)` due to broadcasting; this line works as if v actually had shape `(4, 3)`, where each row was a copy of `v`, and the sum was performed elementwise.\n",
+    "\n",
+    "Broadcasting two arrays together follows these rules:\n",
+    "\n",
+    "1. If the arrays do not have the same rank, prepend the shape of the lower rank array with 1s until both shapes have the same length.\n",
+    "2. The two arrays are said to be compatible in a dimension if they have the same size in the dimension, or if one of the arrays has size 1 in that dimension.\n",
+    "3. The arrays can be broadcast together if they are compatible in all dimensions.\n",
+    "4. After broadcasting, each array behaves as if it had shape equal to the elementwise maximum of shapes of the two input arrays.\n",
+    "5. In any dimension where one array had size 1 and the other array had size greater than 1, the first array behaves as if it were copied along that dimension\n",
+    "\n",
+    "If this explanation does not make sense, try reading the explanation from the [documentation](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) or this [explanation](http://wiki.scipy.org/EricsBroadcastingDoc).\n",
+    "\n",
+    "Functions that support broadcasting are known as universal functions. You can find the list of all universal functions in the [documentation](http://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs).\n",
+    "\n",
+    "Here are some applications of broadcasting:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "EmQnwoM9L9jH"
+   },
+   "outputs": [],
+   "source": [
+    "# Compute outer product of vectors\n",
+    "v = np.array([1,2,3])  # v has shape (3,)\n",
+    "w = np.array([4,5])    # w has shape (2,)\n",
+    "# To compute an outer product, we first reshape v to be a column\n",
+    "# vector of shape (3, 1); we can then broadcast it against w to yield\n",
+    "# an output of shape (3, 2), which is the outer product of v and w:\n",
+    "\n",
+    "print(np.reshape(v, (3, 1)) * w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "PgotmpcnL9jK"
+   },
+   "outputs": [],
+   "source": [
+    "# Add a vector to each row of a matrix\n",
+    "x = np.array([[1,2,3], [4,5,6]])\n",
+    "# x has shape (2, 3) and v has shape (3,) so they broadcast to (2, 3),\n",
+    "# giving the following matrix:\n",
+    "\n",
+    "print(x + v)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "T5hKS1QaL9jK"
+   },
+   "outputs": [],
+   "source": [
+    "# Add a vector to each column of a matrix\n",
+    "# x has shape (2, 3) and w has shape (2,).\n",
+    "# If we transpose x then it has shape (3, 2) and can be broadcast\n",
+    "# against w to yield a result of shape (3, 2); transposing this result\n",
+    "# yields the final result of shape (2, 3) which is the matrix x with\n",
+    "# the vector w added to each column. Gives the following matrix:\n",
+    "\n",
+    "print((x.T + w).T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "JDUrZUl6L9jN"
+   },
+   "outputs": [],
+   "source": [
+    "# Another solution is to reshape w to be a row vector of shape (2, 1);\n",
+    "# we can then broadcast it directly against x to produce the same\n",
+    "# output.\n",
+    "print(x + np.reshape(w, (2, 1)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "VzrEo4KGL9jP"
+   },
+   "outputs": [],
+   "source": [
+    "# Multiply a matrix by a constant:\n",
+    "# x has shape (2, 3). Numpy treats scalars as arrays of shape ();\n",
+    "# these can be broadcast together to shape (2, 3), producing the\n",
+    "# following array:\n",
+    "print(x * 2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "89e2FXxFL9jQ"
+   },
+   "source": [
+    "Broadcasting typically makes your code more concise and faster, so you should strive to use it where possible."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "yi90439hpLR0"
+   },
+   "source": [
+    "### Numpy documentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "iF3ZtwVNL9jQ"
+   },
+   "source": [
+    "This brief overview has touched on many of the important things that you need to know about numpy, but is far from complete. Check out the [numpy reference](http://docs.scipy.org/doc/numpy/reference/) to find out much more about numpy."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "tEINf4bEL9jR"
+   },
+   "source": [
+    "##Matplotlib"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "0hgVWLaXL9jR"
+   },
+   "source": [
+    "Matplotlib is a plotting library. In this section give a brief introduction to the `matplotlib.pyplot` module, which provides a plotting system similar to that of MATLAB."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "cmh_7c6KL9jR"
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jOsaA5hGL9jS"
+   },
+   "source": [
+    "By running this special iPython command, we will be displaying plots inline:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ijpsmwGnL9jT"
+   },
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "U5Z_oMoLL9jV"
+   },
+   "source": [
+    "###Plotting"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "6QyFJ7dhL9jV"
+   },
+   "source": [
+    "The most important function in `matplotlib` is plot, which allows you to plot 2D data. Here is a simple example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "pua52BGeL9jW"
+   },
+   "outputs": [],
+   "source": [
+    "# Compute the x and y coordinates for points on a sine curve\n",
+    "x = np.arange(0, 3 * np.pi, 0.1)\n",
+    "y = np.sin(x)\n",
+    "\n",
+    "# Plot the points using matplotlib\n",
+    "plt.plot(x, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "9W2VAcLiL9jX"
+   },
+   "source": [
+    "With just a little bit of extra work we can easily plot multiple lines at once, and add a title, legend, and axis labels:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "TfCQHJ5AL9jY"
+   },
+   "outputs": [],
+   "source": [
+    "y_sin = np.sin(x)\n",
+    "y_cos = np.cos(x)\n",
+    "\n",
+    "# Plot the points using matplotlib\n",
+    "plt.plot(x, y_sin)\n",
+    "plt.plot(x, y_cos)\n",
+    "plt.xlabel('x axis label')\n",
+    "plt.ylabel('y axis label')\n",
+    "plt.title('Sine and Cosine')\n",
+    "plt.legend(['Sine', 'Cosine'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "R5IeAY03L9ja"
+   },
+   "source": [
+    "###Subplots"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CfUzwJg0L9ja"
+   },
+   "source": [
+    "You can plot different things in the same figure using the subplot function. Here is an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "dM23yGH9L9ja"
+   },
+   "outputs": [],
+   "source": [
+    "# Compute the x and y coordinates for points on sine and cosine curves\n",
+    "x = np.arange(0, 3 * np.pi, 0.1)\n",
+    "y_sin = np.sin(x)\n",
+    "y_cos = np.cos(x)\n",
+    "\n",
+    "# Set up a subplot grid that has height 2 and width 1,\n",
+    "# and set the first such subplot as active.\n",
+    "plt.subplot(2, 1, 1)\n",
+    "\n",
+    "# Make the first plot\n",
+    "plt.plot(x, y_sin)\n",
+    "plt.title('Sine')\n",
+    "\n",
+    "# Set the second subplot as active, and make the second plot.\n",
+    "plt.subplot(2, 1, 2)\n",
+    "plt.plot(x, y_cos)\n",
+    "plt.title('Cosine')\n",
+    "\n",
+    "# Show the figure.\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "gLtsST5SL9jc"
+   },
+   "source": [
+    "You can read much more about the `subplot` function in the [documentation](http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.subplot)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7Zqndtogsq8J"
+   },
+   "source": [
+    "### Download images"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "4FFozuUm7OE5"
+   },
+   "source": [
+    "Lets download some images."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "cOEqkMl47VTP"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "if not os.path.exists('images.zip'):\n",
+    "  !wget --no-check-certificate https://empslocal.ex.ac.uk/people/staff/ad735/ECMM426/images.zip\n",
+    "  !unzip -q images.zip"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "cjKpKTNYsxcF"
+   },
+   "source": [
+    "You can use the `imread` and  the`imshow` function to respectively read and show images. Here is an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "LEep7wnTs5Si"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "img = plt.imread('images/lena.png')\n",
+    "img_tinted = img * [1, 0.85, 0.8]\n",
+    "\n",
+    "# Show the original image\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.imshow(img)\n",
+    "\n",
+    "# Show the tinted image\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.imshow(img_tinted)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "wOan27So8lpI"
+   },
+   "source": [
+    "## Scikit-learn"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uSki-HDorHgE"
+   },
+   "source": [
+    "[Scikit-learn](https://scikit-learn.org/stable/) is an open source machine learning library that supports supervised and unsupervised learning. It also provides various tools for model fitting, data preprocessing, model selection, model evaluation, and many other utilities."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "BOwTaL8x2QJ1"
+   },
+   "source": [
+    "### Moon dataset\n",
+    "Below we will consider a toy dataset, such as moon dataset and consider some classifiers from the Scikit-learn library to classify them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-wudgYDp1xO_"
+   },
+   "outputs": [],
+   "source": [
+    "# Create the moon dataset and plot\n",
+    "from sklearn.datasets import make_moons\n",
+    "\n",
+    "X, y = make_moons(n_samples=500, noise=0.30, random_state=42)\n",
+    "\n",
+    "id0 = y == 0\n",
+    "id1 = y == 1\n",
+    "plt.plot(X[id0, 0], X[id0, 1], 'bo', label='0')\n",
+    "plt.plot(X[id1, 0], X[id1, 1], 'ro', label='1')\n",
+    "plt.legend(loc=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XbIu90Rg2TvB"
+   },
+   "source": [
+    "### Dataset split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "QVDMPmL62EIr"
+   },
+   "outputs": [],
+   "source": [
+    "# Split into train and test sets\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uZNqoqgW31rp"
+   },
+   "source": [
+    "### Random forest classifier\n",
+    "Lets now train a random forest classifier from the scikit-learn library on the above training set and test it on the test set, and the compute the classification accuracy. Please check the [documentation](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn-ensemble-randomforestclassifier) of `RandomForestClassifier` for more details on its parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "RC8sl3QE5BjD"
+   },
+   "outputs": [],
+   "source": [
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "# Define the classifier\n",
+    "rnd_clf = RandomForestClassifier(n_estimators=500, max_leaf_nodes=16, n_jobs=-1, random_state=42)\n",
+    "# Training\n",
+    "rnd_clf.fit(X_train, y_train)\n",
+    "# Test\n",
+    "y_pred_rf = rnd_clf.predict(X_test)\n",
+    "# Classification accuracy\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "print(accuracy_score(y_test, y_pred_rf))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "T8JLXEV97i8c"
+   },
+   "source": [
+    "### Non-linear Support Vector Machine\n",
+    "Now lets do the same training and testing with a non-linear [Support Vector Machine (SVM)](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html) classifier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "av46bVVs8w08"
+   },
+   "outputs": [],
+   "source": [
+    "from sklearn.svm import SVC\n",
+    "# Define the non-linear classifier with radial basis function (rbf) kernel\n",
+    "nlin_svm_clf_1 = SVC(kernel=\"rbf\")\n",
+    "# Training\n",
+    "nlin_svm_clf_1.fit(X_train, y_train)\n",
+    "# Test\n",
+    "y_pred = nlin_svm_clf_1.predict(X_test)\n",
+    "# Classification accuracy\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "print(accuracy_score(y_pred, y_test))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "74nKsfA99pkb"
+   },
+   "source": [
+    "### Confusion matrix\n",
+    "A confusion matrix is a table that is used to define the performance of a classification algorithm. A confusion matrix visualizes and summarizes the performance of a classification algorithm. More details on how to compute confusion matrix can be found in the [documentation](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "aB73WGra-aEF"
+   },
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import confusion_matrix\n",
+    "confusion_matrix(y_test, y_pred)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Wp2DsEemAOub"
+   },
+   "source": [
+    "### Regression\n",
+    "\n",
+    "Now, lets consider the following function and train an [MLP regressor](https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html) to learn it.\n",
+    "\n",
+    "\\begin{equation}\n",
+    "y = f(x; \\mathbf{w}) = 5x^2 + 3\n",
+    "\\end{equation}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "C5Dzr0MLA3h8"
+   },
+   "outputs": [],
+   "source": [
+    "# Create the data that follow uniform distribution\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "X = np.random.uniform(-100, 100, 1000)\n",
+    "y = 5*(X*X) + 3\n",
+    "plt.scatter(X, y, s=10);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "Lr2qn7zxCKcK"
+   },
+   "outputs": [],
+   "source": [
+    "# Split the dataset into train and test sets\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "UXpmCrg0CbeA"
+   },
+   "outputs": [],
+   "source": [
+    "from sklearn.neural_network import MLPRegressor\n",
+    "# Define an MLPRegressor\n",
+    "regr = MLPRegressor(hidden_layer_sizes=(10,), solver='lbfgs', activation='relu', max_iter=10000)\n",
+    "# Fit on the training data\n",
+    "regr = regr.fit(X_train.reshape(-1, 1), y_train)\n",
+    "# Predict using the multi-layer perceptron model\n",
+    "y_pred = regr.predict(X_test.reshape(-1, 1))\n",
+    "# Return the coefficient of determination of the prediction. The best score can be 1.\n",
+    "regr.score(X_test.reshape(-1, 1), y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vxAwaKWhq6z5"
+   },
+   "source": [
+    "## OpenCV"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7S04s4KFz3EO"
+   },
+   "source": [
+    "OpenCV is a library providing implementation of multitude of algorithms related to image processing, computer vision and machine learning. In this section, we will learn different image processing functions from the OpenCV library. For more details on OpenCV, please see the [OpenCV website](https://opencv.org/)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "oTcZ703E2Zxh"
+   },
+   "source": [
+    "### Data structures\n",
+    "\n",
+    "Colour images usually have three channels: red, green and blue and these channels are usually arranged in a certain order. Depending on this arrangement the image is termed in a certain way. For example, if the channels in an image are ordered in red (R), green (G) and blue (B), the image is called as RGB image. In OpenCV an image can be read by `cv2.imread()` function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "W_6NRQ762_fP"
+   },
+   "outputs": [],
+   "source": [
+    "# read an image\n",
+    "import cv2\n",
+    "img = cv2.imread('images/lena.png')\n",
+    "\n",
+    "# show image format (basically a 3-d array of pixel colour info, in BGR format)\n",
+    "print('Image shape: {}'.format(img.shape))\n",
+    "print('Image: {}'.format(img))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "aZPEVuGh_p8V",
+    "pycharm": {}
+   },
+   "source": [
+    "### Colour conversions\n",
+    "By default, OpenCV loads images in BGR format. This is why the famous image of Lena looks a bit weird. **Note:** we will use imshow function from Matplotlib to display the image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "uPBA122WEzXM",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# show image with matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "plt.imshow(img)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "T89Km6qqQs3t"
+   },
+   "source": [
+    "In OpenCV, a BGR image can be converted to an RGB image by the `cv2.cvtColor()` function as follows"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "_kIGhwKc_p8V",
+    "pycharm": {},
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# convert image to RGB colour space\n",
+    "img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
+    "\n",
+    "# show image with matplotlib\n",
+    "plt.imshow(img)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "8WYalGWXQs3u"
+   },
+   "source": [
+    "In a similar way, a BGR image can also be converted to grayscale image which has only a single channel. Converting an RGB image into a grayscale image involves summing up the individual (RGB) components with the weights (0.299, 0.587, 0.114). The OpenCV function `cv2.cvtColor()` can also be used to convert an RGB image into a grayscale image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "vpS6RcOV_p8Y",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# convert image to grayscale\n",
+    "gray_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\n",
+    "\n",
+    "print('Image shape: {}'.format(gray_img.shape))\n",
+    "# grayscale image represented as a 2-d array\n",
+    "print(gray_img)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "E1yoDp2hCihi",
+    "pycharm": {}
+   },
+   "source": [
+    "Gray images have single channel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "z2-K1pOh_p8a",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# plot the gray image, note the cmap parameter\n",
+    "plt.imshow(gray_img, cmap='gray')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "B_EOqF8qQs3v"
+   },
+   "source": [
+    "Colour to grayscale is a lossy conversion. However, in OpenCV a grayscale image can approximately be converted to a colour image using the `cv2.applyColorMap()` function according to the colour maps described at this [link](https://docs.opencv.org/4.x/d3/d50/group__imgproc__colormap.html)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "eOs27PQFSYrn",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "gray_img_col = cv2.applyColorMap(gray_img, cv2.COLORMAP_JET)\n",
+    "plt.imshow(gray_img_col)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "cE_h8sgbQs3w"
+   },
+   "source": [
+    "### Conversion from `uint8` to `float64` (`double`) and Normalization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-6aepcnKQs3w",
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "img_dble = cv2.normalize(img.astype('float64'), None, 0.0, 1.0, cv2.NORM_MINMAX)\n",
+    "print(img_dble)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "tOh1DQ5s5Iyg"
+   },
+   "outputs": [],
+   "source": [
+    "plt.imshow(img_dble)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "PxNoVeWkwqDF"
+   },
+   "source": [
+    "### Image processing\n",
+    "Below we will review some brief image processing tasks, such as image filtering, binarization, edge detection etc with OpenCV."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "iIt6E6uC5aMS"
+   },
+   "source": [
+    "#### Box Filtering"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dAvdTtHeKQJJ",
+    "pycharm": {}
+   },
+   "source": [
+    "In this filtering, each pixel value in an image is replaced by the weighted average of the neighborhood (defined by the filter mask) intensity values. The most commonly used filter is the Box filter which has equal weights. A 3×3 normalized box filter is shown below\n",
+    "\n",
+    "![box filter](https://i2.wp.com/theailearner.com/wp-content/uploads/2019/05/filter1.png?w=454&ssl=1)\n",
+    "\n",
+    "It is a good practice to normalize the filter, this is why the above filter is divided by 9. This is to make sure that the image does not get brighter or darker. You can also use an unnormalized box filter.\n",
+    "\n",
+    "OpenCV provides two inbuilt functions for averaging namely:\n",
+    "\n",
+    "* `cv2.blur()` that blurs an image using only the normalized box filter and\n",
+    "* `cv2.boxFilter()` which is more general, having the option of using either normalized or unnormalized box filter. Just pass an argument normalize=False to the function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "HVb5aZSNLaGK",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "img = cv2.cvtColor(cv2.imread('images/books.jpg'), cv2.COLOR_BGR2RGB)\n",
+    "plt.imshow(img)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "gS2OY6czd2oX",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "gray_img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\n",
+    "blur_img = cv2.blur(gray_img, (10, 10))\n",
+    "plt.subplot(1, 2, 1); plt.imshow(gray_img, cmap='gray')\n",
+    "plt.subplot(1, 2, 2); plt.imshow(blur_img, cmap='gray')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "tOqyh7ZD5nW0"
+   },
+   "source": [
+    "#### Gaussian Filtering"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EhoKd7Is_p8y",
+    "pycharm": {}
+   },
+   "source": [
+    "In Gaussian filtering, instead of a box filter, a Gaussian kernel is used. In OpenCV, it is done with the function, `cv2.GaussianBlur()`. We should specify the width and height of the kernel which should be positive and odd. We also should specify the standard deviation in the X and Y directions, sigmaX and sigmaY respectively. If only sigmaX is specified, sigmaY is taken as the same as sigmaX. If both are given as zeros, they are calculated from the kernel size. Gaussian blurring is highly effective in removing Gaussian noise from an image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "R2qNZNzB_p8z",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "img = cv2.cvtColor(cv2.imread('images/oy.jpg'), cv2.COLOR_BGR2RGB)\n",
+    "plt.imshow(img)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "FcEcRBhT_p81",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# preproccess with blurring, with 5x5 kernel (note kernel size should be odd)\n",
+    "img_blur_small = cv2.GaussianBlur(img, (5, 5), 0)\n",
+    "plt.imshow(img_blur_small)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "GcpJwBNU_p83",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "img_blur_small = cv2.GaussianBlur(img, (5, 5), 25)\n",
+    "plt.imshow(img_blur_small)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "GW_zbFBx_p85",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "img_blur_large = cv2.GaussianBlur(img, (15,15), 0)\n",
+    "plt.imshow(img_blur_large)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "knYfkspQ5y0F"
+   },
+   "source": [
+    "#### Median Filtering"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "rFRJL4v1O7kt",
+    "pycharm": {}
+   },
+   "source": [
+    "This is a non-linear filtering technique. As clear from the name, this takes a median of all the pixels under the kernel area and replaces the central element with this median value. This is quite effective in reducing a certain type of noise (like salt-and-pepper noise) with considerably less edge blurring as compared to other linear filters of the same size. First create the function for creating noisy images with \"salt and pepper\" noise."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "dqMvcYl3u_S8",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "def add_sp_noise(image, amount=0.1):\n",
+    "    row, col, ch = image.shape\n",
+    "    s_vs_p = 0.5\n",
+    "    out = np.copy(image)\n",
+    "    # Salt mode\n",
+    "    num_salt = np.ceil(amount * image.size * s_vs_p)\n",
+    "    coords = [np.random.randint(0, i - 1, int(num_salt))\n",
+    "            for i in image.shape]\n",
+    "    out[coords[0], coords[1], coords[2]] = 1\n",
+    "\n",
+    "    # Pepper mode\n",
+    "    num_pepper = np.ceil(amount* image.size * (1. - s_vs_p))\n",
+    "    coords = [np.random.randint(0, i - 1, int(num_pepper))\n",
+    "            for i in image.shape]\n",
+    "    out[coords[0], coords[1], coords[2]] = 0\n",
+    "    return out"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "NBNSgJgfDgqv",
+    "pycharm": {}
+   },
+   "source": [
+    "Load an image and apply \"salt and pepper\" noise and then try to smooth it with Gaussian and Median filter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "ea2GEwfFQLR1",
+    "pycharm": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "img = cv2.cvtColor(cv2.imread('images/coins.jpg'), cv2.COLOR_BGR2RGB)\n",
+    "noisy_img = add_sp_noise(img, amount=0.1)\n",
+    "img_gaus = cv2.GaussianBlur(noisy_img, (5, 5), 3)\n",
+    "img_med = cv2.medianBlur(noisy_img, 5)\n",
+    "plt.subplot(1, 4, 1); plt.imshow(img); plt.title('Original')\n",
+    "plt.subplot(1, 4, 2); plt.imshow(noisy_img); plt.title('Salt & Pepper Noise')\n",
+    "plt.subplot(1, 4, 3); plt.imshow(img_gaus); plt.title('Gaussian Filtered')\n",
+    "plt.subplot(1, 4, 4); plt.imshow(img_med); plt.title('Median Filtered')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "jBSFKfNp58ka"
+   },
+   "source": [
+    "#### Edge Detection"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XxeFuSii_p9N",
+    "pycharm": {}
+   },
+   "source": [
+    "Edge detection is an image processing technique for finding the boundaries of objects within images. It works by detecting discontinuities in brightness, colour, surface etc. Edge detection is used for image segmentation and data extraction in areas such as image processing, computer vision, and machine vision. OpenCV provides the `cv2.Canny()` function to compute edges in an image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "-utaqZp5SDP7",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "cups = cv2.cvtColor(cv2.imread('images/cups.jpg'), cv2.COLOR_BGR2RGB)\n",
+    "plt.imshow(cups)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "7Ko1a2jmSM-M",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# preprocess by blurring and grayscale\n",
+    "cups_preprocessed  = cv2.cvtColor(cv2.GaussianBlur(cups, (7,7), 0), cv2.COLOR_RGB2GRAY)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "a8-A44piSmwd",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# find binary image with thresholding\n",
+    "low_thresh = 120\n",
+    "high_thresh = 200\n",
+    "_, cups_thresh = cv2.threshold(cups_preprocessed, low_thresh, 255, cv2.THRESH_BINARY)\n",
+    "plt.imshow(cv2.cvtColor(cups_thresh, cv2.COLOR_GRAY2RGB))\n",
+    "\n",
+    "_, cups_thresh_hi = cv2.threshold(cups_preprocessed, high_thresh, 255, cv2.THRESH_BINARY)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "lVNkDIgDRuci",
+    "pycharm": {}
+   },
+   "outputs": [],
+   "source": [
+    "# find binary image with edges\n",
+    "cups_edges = cv2.Canny(cups_preprocessed, threshold1=90, threshold2=110)\n",
+    "plt.imshow(cv2.cvtColor(cups_edges, cv2.COLOR_GRAY2RGB))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-XOcVQ4hqP4R"
+   },
+   "source": [
+    "## SciPy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "tAWDvNu5qn4b"
+   },
+   "source": [
+    "Numpy provides a high-performance multidimensional array and basic tools to compute with and manipulate these arrays. [SciPy](http://docs.scipy.org/doc/scipy/reference/) builds on this, and provides a large number of functions that operate on numpy arrays and are useful for different types of scientific and engineering applications. The best way to get familiar with SciPy is to [browse the documentation](https://docs.scipy.org/doc/scipy/reference/index.html). SciPy provides important functionalities for reading and writing MATLAB files, which show below.\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ajs-UbqSrWk0"
+   },
+   "source": [
+    "###MATLAB files"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "HoT2zazhrZ5m"
+   },
+   "source": [
+    "The functions `scipy.io.loadmat` and `scipy.io.savemat` allow you to respectively read and write MATLAB files. You can read about them [in the documentation](http://docs.scipy.org/doc/scipy/reference/io.html)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "iMtaY6Bzr7-w"
+   },
+   "source": [
+    "###Distance between points"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1tq9Mtwkr_s0"
+   },
+   "source": [
+    "SciPy defines some useful functions for computing distances between sets of points.\n",
+    "\n",
+    "The function `scipy.spatial.distance.pdist` computes the distance between all pairs of points in a given set:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "EwlHRO0jsJBI"
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from scipy.spatial.distance import pdist, squareform\n",
+    "\n",
+    "# Create the following array where each row is a point in 2D space:\n",
+    "# [[0 1]\n",
+    "#  [1 0]\n",
+    "#  [2 0]]\n",
+    "x = np.array([[0, 1], [1, 0], [2, 0]])\n",
+    "print(x)\n",
+    "\n",
+    "# Compute the Euclidean distance between all rows of x.\n",
+    "# d[i, j] is the Euclidean distance between x[i, :] and x[j, :],\n",
+    "# and d is the following array:\n",
+    "# [[ 0.          1.41421356  2.23606798]\n",
+    "#  [ 1.41421356  0.          1.        ]\n",
+    "#  [ 2.23606798  1.          0.        ]]\n",
+    "d = squareform(pdist(x, 'euclidean'))\n",
+    "print(d)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dzYk_QSfsSXO"
+   },
+   "source": [
+    "A similar function (`scipy.spatial.distance.cdist`) computes the distance between all pairs across two sets of points; you can read about it [in the documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.cdist.html)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "d3XD7jVkU9Z3"
+   },
+   "source": [
+    "#### Acknowledgement\n",
+    "This tutorial was originally written by [Justin Johnson](https://web.eecs.umich.edu/~justincj/) for CS231n at the Stanford University. This version has been adapted and modified by [Anjan Dutta](https://www.surrey.ac.uk/people/anjan-dutta) for the Spring 2023 edition of [EEEM068](https://catalogue.surrey.ac.uk/2022-3/module/EEEM068) module at the University of Surrey."
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "include_colab_link": true,
+   "name": "colab-tutorial.ipynb",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

Downloads/.~lock.deformation_experiments(3).pptx#

@@ -0,0 +1 @@
+,rk01499,otter34.eps.surrey.ac.uk,04.07.2026 12:19,file:///user/HS400/rk01499/.config/libreoffice/4;

Downloads/deformation_experiments(1).pptx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:096e84b359a596e84faf7f2756fd674a5ad0d9d43b04bf325e8c647c34ff773a
+size 298687

Downloads/deformation_experiments(2).pptx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1813487f48ef15c4b51c6c7bed6d397a3523237c5aaaea6b8bf7b7b76f1c2511
+size 496442

Downloads/deformation_experiments(3).pptx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:573cba301f2ebd3051bf7626390220d268b2b1d0356aaf41a500c663b116080c
+size 504332

Downloads/deformation_experiments.pptx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:096e84b359a596e84faf7f2756fd674a5ad0d9d43b04bf325e8c647c34ff773a
+size 298687

Downloads/geometric_solver(1).py

@@ -0,0 +1,1147 @@
+"""
+Geometric Solver for Multi-Object Sketch Animation
+===================================================
+Pipeline:
+    SVG + text instruction
+        -> Stage 1: Qwen keyframe prompt decomposition
+        -> Stage 2: Grounding DINO object segmentation + control point assignment
+        -> Stage 3: Qwen semantic motion plan per object per keyframe
+        -> Stage 4: Geometric solver (skeleton + skinning + interpolation)
+        -> Stage 5: Rasterize frames -> Wan2.2 adjacent pairs -> final video
+
+Dependencies:
+    pip install controlnet-aux cairosvg scipy numpy pillow svgpathtools
+    pip install torch torchvision transformers
+    pip install openai  # for Qwen/GPT-4 API calls
+"""
+
+import os
+import io
+import json
+import numpy as np
+from PIL import Image, ImageDraw
+from scipy.interpolate import CubicSpline
+import xml.etree.ElementTree as ET
+import cairosvg
+import torch
+
+
+# =============================================================================
+# STAGE 1 — QWEN KEYFRAME PROMPT DECOMPOSITION
+# =============================================================================
+
+def decompose_keyframe_prompts(image_path, text_instruction, n_keyframes=5, client=None):
+    """
+    Give image + text instruction to Qwen/GPT-4
+    Returns ordered list of keyframe semantic descriptions
+
+    Args:
+        image_path:        path to rasterized sketch image
+        text_instruction:  e.g. "basketball player takes a jump shot toward hoop"
+        n_keyframes:       number of keyframes to decompose into
+        client:            OpenAI-compatible API client
+
+    Returns:
+        list of keyframe description strings
+    """
+    import base64
+
+    with open(image_path, "rb") as f:
+        image_b64 = base64.b64encode(f.read()).decode("utf-8")
+
+    prompt = f"""
+You are given a sketch image and a motion description.
+Decompose the motion into exactly {n_keyframes} ordered keyframe descriptions.
+
+Motion: {text_instruction}
+
+Rules:
+- Each keyframe must describe the state of ALL objects in the scene
+- Descriptions must be temporally ordered (start to end)
+- Each description should be 1-2 sentences
+- Focus on pose, position, and inter-object relationships
+- Output ONLY a JSON array of {n_keyframes} strings, nothing else
+
+Example output format:
+["player standing, ball at hip", "player crouching, ball gripped", ...]
+"""
+
+    # --- replace with your actual API call ---
+    # response = client.chat.completions.create(
+    #     model="gpt-4o",
+    #     messages=[{
+    #         "role": "user",
+    #         "content": [
+    #             {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_b64}"}},
+    #             {"type": "text", "text": prompt}
+    #         ]
+    #     }]
+    # )
+    # raw = response.choices[0].message.content
+    # keyframe_prompts = json.loads(raw)
+
+    # --- MOCK OUTPUT for basketball example ---
+    keyframe_prompts = [
+        "player standing upright, ball held at hip height with both hands, hoop visible in background",
+        "player crouching with knees bent, ball pulled back toward chest, preparing to jump",
+        "player leaving ground, arm extending upward with ball, body rising",
+        "player at peak height, arm fully extended above head, ball releasing from fingertips toward hoop",
+        "player descending, arm following through, ball mid-arc toward hoop"
+    ]
+
+    return keyframe_prompts
+
+
+# =============================================================================
+# STAGE 2 — OBJECT SEGMENTATION + CONTROL POINT ASSIGNMENT
+# =============================================================================
+
+def rasterize_svg(svg_path, width=512, height=512):
+    """Convert SVG to raster numpy array"""
+    png_data = cairosvg.svg2png(
+        url=svg_path,
+        output_width=width,
+        output_height=height
+    )
+    image = Image.open(io.BytesIO(png_data)).convert("RGB")
+    return np.array(image)
+
+
+def get_object_bounding_boxes(image_array, object_names):
+    """
+    Run Grounding DINO to get bounding boxes per object
+
+    Args:
+        image_array:   numpy HxWx3 image
+        object_names:  list of object name strings e.g. ["player", "basketball", "hoop"]
+
+    Returns:
+        dict {object_name: [x, y, w, h]}
+    """
+    # --- real Grounding DINO call ---
+    # from groundingdino.util.inference import load_model, predict
+    # model = load_model(...)
+    # boxes, logits, phrases = predict(model, image, text_prompt, ...)
+
+    # --- MOCK for basketball example (pixel coordinates at 512x512) ---
+    bounding_boxes = {
+        "player":     [6,   16,  129, 212],
+        "basketball": [165, 52,  51,  49],
+        "hoop":       [380, 80,  60,  40]
+    }
+    return bounding_boxes
+
+
+def parse_svg_control_points(svg_path):
+    """
+    Parse all cubic bezier control points from SVG
+
+    Returns:
+        list of dicts: {id, x, y, path_id, point_type}
+        point_type: 'anchor' or 'control'
+    """
+    try:
+        from svgpathtools import svg2paths
+        paths, attributes = svg2paths(svg_path)
+    except Exception as e:
+        print(f"svgpathtools failed: {e}. Using fallback ET parser.")
+        return _parse_svg_fallback(svg_path)
+
+    control_points = []
+    point_id = 0
+
+    for path_idx, path in enumerate(paths):
+        for segment in path:
+            # CubicBezier: start, control1, control2, end
+            pts = [segment.start, segment.control1,
+                   segment.control2, segment.end]
+            types = ['anchor', 'control', 'control', 'anchor']
+
+            for pt, ptype in zip(pts, types):
+                control_points.append({
+                    'id':         point_id,
+                    'x':          pt.real,
+                    'y':          pt.imag,
+                    'path_id':    path_idx,
+                    'point_type': ptype
+                })
+                point_id += 1
+
+    return control_points
+
+
+def _parse_svg_fallback(svg_path):
+    """Fallback SVG parser using ElementTree"""
+    import re
+    tree = ET.parse(svg_path)
+    root = tree.getroot()
+
+    ns_map = {'svg': 'http://www.w3.org/2000/svg'}
+    control_points = []
+    point_id = 0
+
+    for path_idx, elem in enumerate(
+        root.iter('{http://www.w3.org/2000/svg}path')
+    ):
+        d = elem.get('d', '')
+        nums = re.findall(r'[-+]?\d*\.?\d+', d)
+        coords = [float(n) for n in nums]
+
+        for i in range(0, len(coords) - 1, 2):
+            control_points.append({
+                'id':         point_id,
+                'x':          coords[i],
+                'y':          coords[i + 1],
+                'path_id':    path_idx,
+                'point_type': 'anchor'
+            })
+            point_id += 1
+
+    return control_points
+
+
+def assign_control_points_to_objects(control_points, bounding_boxes, svg_width=512, svg_height=512):
+    """
+    Assign each control point to the object whose bounding box
+    center is nearest to the point.
+
+    Uses MoSketch's nearest-center strategy.
+
+    Returns:
+        dict {object_name: [list of control point dicts]}
+    """
+    object_assignments = {name: [] for name in bounding_boxes}
+    object_assignments['unassigned'] = []
+
+    # compute bounding box centers
+    centers = {}
+    for name, bb in bounding_boxes.items():
+        x, y, w, h = bb
+        centers[name] = np.array([x + w / 2, y + h / 2])
+
+    object_names = list(centers.keys())
+    center_array = np.array([centers[n] for n in object_names])
+
+    for pt in control_points:
+        pt_pos = np.array([pt['x'], pt['y']])
+
+        # scale to image coordinates if SVG uses different coordinate space
+        pt_pos_scaled = pt_pos * np.array([
+            512 / svg_width,
+            512 / svg_height
+        ])
+
+        distances = np.linalg.norm(center_array - pt_pos_scaled, axis=1)
+        nearest_idx = np.argmin(distances)
+        nearest_name = object_names[nearest_idx]
+
+        pt['assigned_object'] = nearest_name
+        pt['distance_to_center'] = distances[nearest_idx]
+        object_assignments[nearest_name].append(pt)
+
+    return object_assignments
+
+
+# =============================================================================
+# STAGE 3 — SEMANTIC MOTION PLAN PER OBJECT PER KEYFRAME
+# =============================================================================
+
+def get_semantic_motion_plan(
+    image_path,
+    bounding_boxes,
+    keyframe_prompts,
+    client=None
+):
+    """
+    Give Qwen: image + BB assignments + keyframe prompts
+    Returns: per-object per-keyframe semantic pose descriptions
+
+    Returns:
+        dict {object_name: {keyframe_idx: semantic_description}}
+    """
+    import base64
+    with open(image_path, "rb") as f:
+        image_b64 = base64.b64encode(f.read()).decode("utf-8")
+
+    bb_str = json.dumps(bounding_boxes, indent=2)
+    kf_str = json.dumps(
+        {i: p for i, p in enumerate(keyframe_prompts)},
+        indent=2
+    )
+
+    prompt = f"""
+You are given a sketch image with detected objects at these bounding boxes:
+{bb_str}
+
+The animation has these keyframe descriptions:
+{kf_str}
+
+For each object at each keyframe, describe its specific pose state.
+Use vocabulary from this list where possible:
+- Arms: "arm at side", "arm extended upward", "arm pulling back", "arm extended forward"
+- Legs: "legs straight", "crouching", "jumping", "kicking", "landing"
+- Torso: "torso upright", "torso leaning forward", "torso rotating right"
+- Position: "stationary", "moving left", "moving right", "rising", "falling"
+
+Output ONLY a JSON object, no other text.
+Format:
+{{
+  "player": {{
+    "0": "torso upright, arm at side, legs straight",
+    "1": "crouching, arm pulling back, legs bent",
+    ...
+  }},
+  "basketball": {{
+    "0": "stationary at hip",
+    "1": "moving upward",
+    ...
+  }}
+}}
+"""
+
+    # --- replace with actual API call ---
+    # response = client.chat.completions.create(...)
+    # plan = json.loads(response.choices[0].message.content)
+
+    # --- MOCK for basketball example ---
+    plan = {
+        "player": {
+            "0": "torso upright, arm at side, legs straight, stationary",
+            "1": "crouching, arm pulling back, legs bent",
+            "2": "torso leaning forward, arm extended upward, jumping",
+            "3": "torso upright, arm fully extended upward, peak height",
+            "4": "torso leaning forward, arm extended forward, landing"
+        },
+        "basketball": {
+            "0": "stationary at hip level",
+            "1": "moving upward, held by player",
+            "2": "rising, releasing from hand",
+            "3": "peak arc, mid-air",
+            "4": "falling, descending toward hoop"
+        },
+        "hoop": {
+            "0": "stationary",
+            "1": "stationary",
+            "2": "stationary",
+            "3": "stationary",
+            "4": "stationary"
+        }
+    }
+
+    return plan
+
+
+# =============================================================================
+# STAGE 4 — GEOMETRIC SOLVER
+# =============================================================================
+
+# --- 4a: Skeleton Extraction via DWPose ---
+
+SKELETON_HIERARCHY = {
+    # child -> parent
+    "right_elbow":   "right_shoulder",
+    "right_wrist":   "right_elbow",
+    "left_elbow":    "left_shoulder",
+    "left_wrist":    "left_elbow",
+    "right_knee":    "right_hip",
+    "right_ankle":   "right_knee",
+    "left_knee":     "left_hip",
+    "left_ankle":    "left_knee",
+    "right_shoulder":"neck",
+    "left_shoulder": "neck",
+    "neck":          "nose",
+    "right_hip":     "spine",
+    "left_hip":      "spine",
+}
+
+# COCO keypoint order from DWPose
+COCO_KEYPOINTS = [
+    "nose", "left_eye", "right_eye", "left_ear", "right_ear",
+    "left_shoulder", "right_shoulder", "left_elbow", "right_elbow",
+    "left_wrist", "right_wrist", "left_hip", "right_hip",
+    "left_knee", "right_knee", "left_ankle", "right_ankle"
+]
+
+
+def extract_skeleton_dwpose(image_array):
+    """
+    Run DWPose on rasterized sketch image
+    Returns joint positions dict {joint_name: (x, y)}
+    Returns None if no person detected
+    """
+    try:
+        from controlnet_aux import DWposeDetector
+        detector = DWposeDetector()
+        pil_image = Image.fromarray(image_array)
+        result = detector(pil_image, return_pil=False)
+
+        # result is dict with 'bodies' containing keypoints
+        if result is None or 'bodies' not in result:
+            print("DWPose: no person detected")
+            return None
+
+        keypoints = result['bodies']['candidate']  # shape: (N, 2)
+
+        joints = {}
+        for idx, name in enumerate(COCO_KEYPOINTS):
+            if idx < len(keypoints):
+                kp = keypoints[idx]
+                # confidence threshold
+                if len(kp) > 2 and kp[2] < 0.3:
+                    continue
+                joints[name] = (float(kp[0]), float(kp[1]))
+
+        return joints
+
+    except ImportError:
+        print("controlnet_aux not installed. Using mock skeleton.")
+        return _mock_skeleton_basketball()
+    except Exception as e:
+        print(f"DWPose failed: {e}. Using mock skeleton.")
+        return _mock_skeleton_basketball()
+
+
+def _mock_skeleton_basketball():
+    """Mock skeleton for basketball player at 512x512"""
+    return {
+        "nose":           (71,  28),
+        "neck":           (71,  55),
+        "right_shoulder": (50,  75),
+        "left_shoulder":  (92,  75),
+        "right_elbow":    (35,  115),
+        "left_elbow":     (107, 115),
+        "right_wrist":    (25,  150),
+        "left_wrist":     (117, 150),
+        "right_hip":      (55,  155),
+        "left_hip":       (87,  155),
+        "spine":          (71,  115),
+        "right_knee":     (50,  195),
+        "left_knee":      (92,  195),
+        "right_ankle":    (45,  228),
+        "left_ankle":     (97,  228),
+    }
+
+
+def assign_control_points_to_joints(control_points_for_object, joints):
+    """
+    For each control point in an object, find nearest joint
+    Returns dict {point_id: joint_name}
+    """
+    if not joints:
+        return {}
+
+    joint_names = list(joints.keys())
+    joint_positions = np.array([joints[j] for j in joint_names])
+
+    point_to_joint = {}
+    for pt in control_points_for_object:
+        pt_pos = np.array([pt['x'], pt['y']])
+        distances = np.linalg.norm(joint_positions - pt_pos, axis=1)
+        nearest_joint = joint_names[np.argmin(distances)]
+        point_to_joint[pt['id']] = nearest_joint
+
+    return point_to_joint
+
+
+# --- 4b: Semantic to Joint Angles ---
+
+SEMANTIC_TO_POSE = {
+    # ARM STATES
+    "arm at side": {
+        "right_shoulder": 0,   "right_elbow": 10,
+        "left_shoulder":  0,   "left_elbow":  10
+    },
+    "arm pulling back": {
+        "right_shoulder": -30, "right_elbow": 90,
+        "left_shoulder":  30,  "left_elbow":  45
+    },
+    "arm extended upward": {
+        "right_shoulder": -150, "right_elbow": 170,
+        "left_shoulder":  -150, "left_elbow":  170
+    },
+    "arm fully extended upward": {
+        "right_shoulder": -170, "right_elbow": 175,
+        "left_shoulder":  -170, "left_elbow":  175
+    },
+    "arm extended forward": {
+        "right_shoulder": -90, "right_elbow": 160,
+        "left_shoulder":  -90, "left_elbow":  160
+    },
+
+    # LEG STATES
+    "legs straight": {
+        "right_hip": 0,   "right_knee": 0,
+        "left_hip":  0,   "left_knee":  0
+    },
+    "legs bent": {
+        "right_hip": -30, "right_knee": -60,
+        "left_hip":  -30, "left_knee":  -60
+    },
+    "crouching": {
+        "right_hip": -45, "right_knee": -90,
+        "left_hip":  -45, "left_knee":  -90
+    },
+    "jumping": {
+        "right_hip": 20,  "right_knee": 150,
+        "left_hip":  20,  "left_knee":  150
+    },
+    "landing": {
+        "right_hip": -20, "right_knee": -40,
+        "left_hip":  -20, "left_knee":  -40
+    },
+    "kicking": {
+        "right_hip": -70, "right_knee": 160,
+        "left_hip":  10,  "left_knee":  0
+    },
+
+    # TORSO STATES
+    "torso upright": {
+        "spine": 0
+    },
+    "torso leaning forward": {
+        "spine": 25
+    },
+    "torso rotating right": {
+        "spine": 20
+    },
+
+    # VERTICAL POSITION (affects bounding box center y)
+    "stationary":     {"_translate_y": 0},
+    "rising":         {"_translate_y": -15},
+    "peak height":    {"_translate_y": -30},
+    "falling":        {"_translate_y": -20},
+    "moving left":    {"_translate_x": -20},
+    "moving right":   {"_translate_x": 20},
+}
+
+
+def parse_semantic_to_joint_angles(semantic_description):
+    """
+    Match semantic description string to joint angle dict
+    Multiple keywords can match and get merged
+
+    Returns:
+        dict {joint_name: angle_degrees}
+        plus optional _translate_x, _translate_y keys
+    """
+    desc_lower = semantic_description.lower()
+    merged = {}
+
+    for key, angles in SEMANTIC_TO_POSE.items():
+        if key in desc_lower:
+            # later matches override earlier ones for same joint
+            merged.update(angles)
+
+    return merged
+
+
+# --- 4c: Compute Joint Transforms ---
+
+def compute_rotation_matrix(angle_degrees):
+    """2D rotation matrix"""
+    theta = np.radians(angle_degrees)
+    return np.array([
+        [np.cos(theta), -np.sin(theta)],
+        [np.sin(theta),  np.cos(theta)]
+    ])
+
+
+def compute_joint_transforms(initial_joints, target_joint_angles):
+    """
+    Compute per-joint rotation transforms
+    relative to initial skeleton pose
+
+    Returns:
+        dict {joint_name: {R: 2x2 matrix, pivot: (x,y)}}
+    """
+    transforms = {}
+
+    for joint_name, target_angle in target_joint_angles.items():
+        if joint_name.startswith('_'):
+            continue  # skip translation keys
+        if joint_name not in initial_joints:
+            continue
+
+        # treat target_angle as absolute rotation from neutral
+        R = compute_rotation_matrix(target_angle)
+        pivot = np.array(initial_joints[joint_name])
+
+        transforms[joint_name] = {
+            'R':     R,
+            'pivot': pivot
+        }
+
+    return transforms
+
+
+def apply_skinning(
+    control_points_for_object,
+    point_to_joint,
+    transforms,
+    translation,
+    initial_positions
+):
+    """
+    Apply joint transforms to control points
+    Propagates through skeleton hierarchy
+
+    Args:
+        control_points_for_object: list of control point dicts
+        point_to_joint:            {point_id: joint_name}
+        transforms:                {joint_name: {R, pivot}}
+        translation:               (dx, dy) global translation
+        initial_positions:         {point_id: (x, y)} at frame 0
+
+    Returns:
+        {point_id: (new_x, new_y)}
+    """
+    new_positions = {}
+
+    for pt in control_points_for_object:
+        pt_id = pt['id']
+        joint = point_to_joint.get(pt_id)
+
+        if joint is None or pt_id not in initial_positions:
+            # no assignment — apply translation only
+            init_pos = np.array([pt['x'], pt['y']])
+            new_positions[pt_id] = tuple(init_pos + np.array(translation))
+            continue
+
+        pt_pos = np.array(initial_positions[pt_id])
+
+        # walk up skeleton hierarchy applying transforms
+        current_joint = joint
+        accumulated_pos = pt_pos.copy()
+        visited = set()
+
+        while current_joint in transforms:
+            if current_joint in visited:
+                break
+            visited.add(current_joint)
+
+            T = transforms[current_joint]
+            accumulated_pos = (
+                T['R'] @ (accumulated_pos - T['pivot']) + T['pivot']
+            )
+
+            parent = SKELETON_HIERARCHY.get(current_joint)
+            if parent is None:
+                break
+            current_joint = parent
+
+        # apply global translation
+        accumulated_pos += np.array(translation)
+        new_positions[pt_id] = tuple(accumulated_pos)
+
+    return new_positions
+
+
+# --- 4d: Full Keyframe Position Computation ---
+
+def compute_keyframe_positions(
+    object_assignments,
+    point_to_joint_map,
+    initial_joints,
+    semantic_plan,
+    bounding_boxes
+):
+    """
+    For each keyframe, compute new control point positions
+    for all objects based on semantic plan
+
+    Returns:
+        {keyframe_idx: {point_id: (x, y)}}
+    """
+    # store initial positions
+    all_points = []
+    for pts in object_assignments.values():
+        all_points.extend(pts)
+
+    initial_positions = {
+        pt['id']: (pt['x'], pt['y'])
+        for pt in all_points
+    }
+
+    keyframe_indices = sorted(
+        int(k) for k in list(semantic_plan.values())[0].keys()
+    )
+
+    keyframe_positions = {}
+
+    for kf_idx in keyframe_indices:
+        frame_positions = dict(initial_positions)  # start from initial
+
+        for obj_name, obj_points in object_assignments.items():
+            if obj_name == 'unassigned' or not obj_points:
+                continue
+
+            obj_plan = semantic_plan.get(obj_name, {})
+            description = obj_plan.get(str(kf_idx), "stationary")
+
+            joint_angles = parse_semantic_to_joint_angles(description)
+
+            # extract translations
+            dx = joint_angles.pop('_translate_x', 0)
+            dy = joint_angles.pop('_translate_y', 0)
+            translation = (dx, dy)
+
+            if obj_name == 'player' and initial_joints:
+                transforms = compute_joint_transforms(
+                    initial_joints,
+                    joint_angles
+                )
+                pt_to_joint = point_to_joint_map.get(obj_name, {})
+                new_pos = apply_skinning(
+                    obj_points,
+                    pt_to_joint,
+                    transforms,
+                    translation,
+                    initial_positions
+                )
+            else:
+                # rigid objects: bounding box center translation
+                bb = bounding_boxes.get(obj_name, [0, 0, 50, 50])
+                new_pos = {}
+                for pt in obj_points:
+                    init = np.array(initial_positions[pt['id']])
+                    new_pos[pt['id']] = tuple(init + np.array(translation))
+
+            frame_positions.update(new_pos)
+
+        keyframe_positions[kf_idx] = frame_positions
+
+    return keyframe_positions, initial_positions
+
+
+# --- 4e: Contact Constraints ---
+
+def enforce_contact_constraints(keyframe_positions, constraints):
+    """
+    Force contact between two points at specified frames
+
+    constraints: list of dicts:
+    [
+        {
+            "frame": 2,
+            "anchor_point_id": 205,   # basketball center
+            "target_point_id": 117,   # player right wrist
+            "type": "contact"
+        }
+    ]
+    """
+    for c in constraints:
+        frame = c['frame']
+        if frame not in keyframe_positions:
+            continue
+
+        anchor_id = c['anchor_point_id']
+        target_id = c['target_point_id']
+
+        if target_id in keyframe_positions[frame]:
+            ref_pos = keyframe_positions[frame][target_id]
+            keyframe_positions[frame][anchor_id] = ref_pos
+
+    return keyframe_positions
+
+
+# --- 4f: Cubic Spline Interpolation ---
+
+def interpolate_keyframes(keyframe_positions, n_frames=16):
+    """
+    Interpolate control point positions between keyframes
+    using cubic spline
+
+    Returns:
+        {frame_idx: {point_id: (x, y)}} for all n_frames
+    """
+    kf_indices = sorted(keyframe_positions.keys())
+
+    if len(kf_indices) < 2:
+        raise ValueError("Need at least 2 keyframes to interpolate")
+
+    # scale keyframe indices to cover full frame range
+    kf_scaled = [
+        int(i * (n_frames - 1) / (len(kf_indices) - 1))
+        for i in range(len(kf_indices))
+    ]
+
+    point_ids = list(keyframe_positions[kf_indices[0]].keys())
+
+    all_frames = {f: {} for f in range(n_frames)}
+
+    for pt_id in point_ids:
+        xs = [keyframe_positions[kf][pt_id][0] for kf in kf_indices]
+        ys = [keyframe_positions[kf][pt_id][1] for kf in kf_indices]
+
+        if len(set(xs)) == 1 and len(set(ys)) == 1:
+            # stationary point — skip interpolation
+            for f in range(n_frames):
+                all_frames[f][pt_id] = (xs[0], ys[0])
+            continue
+
+        try:
+            cs_x = CubicSpline(kf_scaled, xs, bc_type='not-a-knot')
+            cs_y = CubicSpline(kf_scaled, ys, bc_type='not-a-knot')
+
+            for f in range(n_frames):
+                all_frames[f][pt_id] = (
+                    float(cs_x(f)),
+                    float(cs_y(f))
+                )
+        except Exception:
+            # fall back to linear
+            for f in range(n_frames):
+                all_frames[f][pt_id] = (
+                    float(np.interp(f, kf_scaled, xs)),
+                    float(np.interp(f, kf_scaled, ys))
+                )
+
+    return all_frames
+
+
+# =============================================================================
+# STAGE 5 — RASTERIZE FRAME SEQUENCE
+# =============================================================================
+
+def update_svg_control_points(svg_path, frame_positions):
+    """
+    Update SVG path data with new control point positions
+    Returns modified SVG as bytes
+    """
+    with open(svg_path, 'r') as f:
+        svg_content = f.read()
+
+    # NOTE: full SVG path rewriting requires svgpathtools
+    # This is a simplified version — replace with full
+    # path reconstruction for production use
+
+    tree = ET.parse(svg_path)
+    ET.register_namespace('', 'http://www.w3.org/2000/svg')
+
+    svg_bytes = ET.tostring(
+        tree.getroot(),
+        encoding='unicode'
+    ).encode('utf-8')
+
+    return svg_bytes
+
+
+def rasterize_frame(svg_path, frame_positions, width=512, height=512):
+    """
+    Rasterize one frame with updated control point positions
+    Returns PIL Image
+    """
+    svg_bytes = update_svg_control_points(svg_path, frame_positions)
+
+    png_data = cairosvg.svg2png(
+        bytestring=svg_bytes,
+        output_width=width,
+        output_height=height
+    )
+
+    return Image.open(io.BytesIO(png_data)).convert("RGB")
+
+
+def generate_frame_sequence(svg_path, all_frame_positions, output_dir, width=512, height=512):
+    """
+    Generate and save all rasterized frames
+
+    Returns:
+        list of saved frame paths in order
+    """
+    os.makedirs(output_dir, exist_ok=True)
+    frame_paths = []
+
+    for frame_idx in sorted(all_frame_positions.keys()):
+        positions = all_frame_positions[frame_idx]
+        frame_img = rasterize_frame(svg_path, positions, width, height)
+
+        frame_path = os.path.join(output_dir, f"frame_{frame_idx:04d}.png")
+        frame_img.save(frame_path)
+        frame_paths.append(frame_path)
+
+        if frame_idx % 4 == 0:
+            print(f"  Rasterized frame {frame_idx}/{len(all_frame_positions)}")
+
+    return frame_paths
+
+
+# =============================================================================
+# VISUALISATION UTILITIES
+# =============================================================================
+
+def visualise_skeleton(image_array, joints, save_path=None):
+    """Draw detected skeleton joints on image"""
+    img = Image.fromarray(image_array).convert("RGB")
+    draw = ImageDraw.Draw(img)
+
+    colors = {
+        'arm':   'red',
+        'leg':   'blue',
+        'torso': 'green',
+        'head':  'yellow'
+    }
+
+    joint_color_map = {
+        'nose': 'yellow', 'neck': 'green', 'spine': 'green',
+        'right_shoulder': 'red',  'left_shoulder': 'red',
+        'right_elbow':    'red',  'left_elbow':    'red',
+        'right_wrist':    'red',  'left_wrist':    'red',
+        'right_hip':      'blue', 'left_hip':      'blue',
+        'right_knee':     'blue', 'left_knee':     'blue',
+        'right_ankle':    'blue', 'left_ankle':    'blue',
+    }
+
+    for joint_name, (x, y) in joints.items():
+        color = joint_color_map.get(joint_name, 'white')
+        r = 5
+        draw.ellipse([x - r, y - r, x + r, y + r], fill=color, outline='black')
+        draw.text((x + 6, y - 6), joint_name.split('_')[-1][:3], fill=color)
+
+    # draw skeleton connections
+    connections = [
+        ('nose', 'neck'), ('neck', 'right_shoulder'), ('neck', 'left_shoulder'),
+        ('right_shoulder', 'right_elbow'), ('right_elbow', 'right_wrist'),
+        ('left_shoulder', 'left_elbow'), ('left_elbow', 'left_wrist'),
+        ('neck', 'spine'), ('spine', 'right_hip'), ('spine', 'left_hip'),
+        ('right_hip', 'right_knee'), ('right_knee', 'right_ankle'),
+        ('left_hip', 'left_knee'), ('left_knee', 'left_ankle'),
+    ]
+
+    for j1, j2 in connections:
+        if j1 in joints and j2 in joints:
+            draw.line([joints[j1], joints[j2]], fill='white', width=2)
+
+    if save_path:
+        img.save(save_path)
+        print(f"Skeleton visualisation saved: {save_path}")
+
+    return img
+
+
+def visualise_point_assignments(image_array, control_points, object_assignments, save_path=None):
+    """Colour control points by object assignment"""
+    img = Image.fromarray(image_array).convert("RGB")
+    draw = ImageDraw.Draw(img)
+
+    object_colors = {
+        'player':     'red',
+        'basketball': 'orange',
+        'hoop':       'cyan',
+        'unassigned': 'gray'
+    }
+
+    for obj_name, points in object_assignments.items():
+        color = object_colors.get(obj_name, 'white')
+        for pt in points:
+            x, y = pt['x'], pt['y']
+            r = 3
+            draw.ellipse([x - r, y - r, x + r, y + r], fill=color)
+
+    if save_path:
+        img.save(save_path)
+        print(f"Point assignment visualisation saved: {save_path}")
+
+    return img
+
+
+# =============================================================================
+# FULL PIPELINE
+# =============================================================================
+
+def run_pipeline(
+    svg_path,
+    text_instruction,
+    output_dir="output_frames",
+    n_keyframes=5,
+    n_frames=16,
+    contact_constraints=None,
+    client=None
+):
+    """
+    Run full geometric solver pipeline
+
+    Args:
+        svg_path:            path to input SVG file
+        text_instruction:    motion description string
+        output_dir:          where to save rasterized frames
+        n_keyframes:         number of motion keyframes
+        n_frames:            total output frames
+        contact_constraints: list of contact constraint dicts
+        client:              LLM API client
+
+    Returns:
+        list of frame image paths
+    """
+    print("=" * 60)
+    print("GEOMETRIC SOLVER PIPELINE")
+    print("=" * 60)
+
+    os.makedirs(output_dir, exist_ok=True)
+    vis_dir = os.path.join(output_dir, "visualisations")
+    os.makedirs(vis_dir, exist_ok=True)
+
+    # ----- Stage 1: Keyframe Prompt Decomposition -----
+    print("\n[Stage 1] Decomposing keyframe prompts...")
+    raster_path = os.path.join(output_dir, "input_raster.png")
+    image_array = rasterize_svg(svg_path)
+    Image.fromarray(image_array).save(raster_path)
+
+    keyframe_prompts = decompose_keyframe_prompts(
+        raster_path, text_instruction, n_keyframes, client
+    )
+    print(f"  Got {len(keyframe_prompts)} keyframe prompts")
+    for i, kp in enumerate(keyframe_prompts):
+        print(f"  kf{i}: {kp}")
+
+    # ----- Stage 2: Object Segmentation -----
+    print("\n[Stage 2] Segmenting objects...")
+    object_names_from_instruction = ["player", "basketball", "hoop"]
+    bounding_boxes = get_object_bounding_boxes(image_array, object_names_from_instruction)
+    print(f"  Bounding boxes: {bounding_boxes}")
+
+    control_points = parse_svg_control_points(svg_path)
+    print(f"  Parsed {len(control_points)} control points from SVG")
+
+    object_assignments = assign_control_points_to_objects(
+        control_points, bounding_boxes
+    )
+    for obj, pts in object_assignments.items():
+        print(f"  {obj}: {len(pts)} control points assigned")
+
+    vis_path = os.path.join(vis_dir, "point_assignments.png")
+    visualise_point_assignments(image_array, control_points, object_assignments, vis_path)
+
+    # ----- Stage 3: Semantic Motion Plan -----
+    print("\n[Stage 3] Getting semantic motion plan...")
+    semantic_plan = get_semantic_motion_plan(
+        raster_path, bounding_boxes, keyframe_prompts, client
+    )
+    print("  Semantic plan:")
+    for obj, plan in semantic_plan.items():
+        print(f"  [{obj}]")
+        for kf, desc in plan.items():
+            print(f"    kf{kf}: {desc}")
+
+    # ----- Stage 4: Geometric Solver -----
+    print("\n[Stage 4] Running geometric solver...")
+
+    # 4a: skeleton extraction
+    print("  Extracting skeleton via DWPose...")
+    initial_joints = extract_skeleton_dwpose(image_array)
+    if initial_joints:
+        print(f"  Detected {len(initial_joints)} joints")
+        vis_path = os.path.join(vis_dir, "skeleton.png")
+        visualise_skeleton(image_array, initial_joints, vis_path)
+    else:
+        print("  WARNING: No skeleton detected. Falling back to BB translation.")
+
+    # 4b: assign control points to joints
+    point_to_joint_map = {}
+    if initial_joints:
+        player_points = object_assignments.get('player', [])
+        point_to_joint_map['player'] = assign_control_points_to_joints(
+            player_points, initial_joints
+        )
+        print(f"  Assigned {len(point_to_joint_map['player'])} player points to joints")
+
+    # 4c: compute keyframe positions
+    print("  Computing keyframe positions...")
+    keyframe_positions, initial_positions = compute_keyframe_positions(
+        object_assignments,
+        point_to_joint_map,
+        initial_joints,
+        semantic_plan,
+        bounding_boxes
+    )
+    print(f"  Computed positions for {len(keyframe_positions)} keyframes")
+
+    # 4d: enforce contact constraints
+    if contact_constraints:
+        print(f"  Enforcing {len(contact_constraints)} contact constraints...")
+        keyframe_positions = enforce_contact_constraints(
+            keyframe_positions, contact_constraints
+        )
+
+    # 4e: interpolate between keyframes
+    print("  Interpolating between keyframes...")
+    all_frame_positions = interpolate_keyframes(keyframe_positions, n_frames)
+    print(f"  Generated positions for {len(all_frame_positions)} frames")
+
+    # ----- Stage 5: Rasterize Frames -----
+    print("\n[Stage 5] Rasterizing frame sequence...")
+    frame_paths = generate_frame_sequence(
+        svg_path, all_frame_positions,
+        os.path.join(output_dir, "frames")
+    )
+    print(f"  Saved {len(frame_paths)} frames to {output_dir}/frames/")
+
+    print("\n" + "=" * 60)
+    print("PIPELINE COMPLETE")
+    print(f"Frames saved to: {output_dir}/frames/")
+    print(f"Visualisations:  {output_dir}/visualisations/")
+    print("Next step: feed adjacent frame pairs to Wan2.2")
+    print("=" * 60)
+
+    return frame_paths
+
+
+# =============================================================================
+# ENTRY POINT — BASKETBALL EXAMPLE
+# =============================================================================
+
+if __name__ == "__main__":
+
+    # contact constraints for basketball example:
+    # at keyframe 2 (ball releasing), basketball center
+    # should be at player's right wrist position
+    # NOTE: replace point IDs with actual IDs from your SVG
+    contact_constraints = [
+        {
+            "frame":            2,
+            "anchor_point_id":  200,   # basketball center point
+            "target_point_id":  117,   # player right wrist point
+            "type":             "contact"
+        }
+    ]
+
+    # --- set your SVG path here ---
+    SVG_PATH = "basketball_sketch.svg"
+
+    if not os.path.exists(SVG_PATH):
+        print(f"SVG not found at {SVG_PATH}")
+        print("Upload your basketball sketch SVG and set SVG_PATH")
+        print("\nTo test without SVG, running skeleton mock only...\n")
+
+        # test skeleton + semantic parsing without SVG
+        mock_image = np.ones((512, 512, 3), dtype=np.uint8) * 240
+        joints = extract_skeleton_dwpose(mock_image)
+
+        print("Mock skeleton joints:")
+        for j, pos in joints.items():
+            print(f"  {j}: {pos}")
+
+        desc = "crouching, arm extended upward, jumping"
+        angles = parse_semantic_to_joint_angles(desc)
+        print(f"\nSemantic parse of '{desc}':")
+        print(json.dumps(angles, indent=2))
+
+    else:
+        frame_paths = run_pipeline(
+            svg_path=SVG_PATH,
+            text_instruction=(
+                "A basketball player takes a jump shot, "
+                "aiming for the hoop, with the basketball "
+                "mid-air and heading towards the hoop."
+            ),
+            output_dir="basketball_output",
+            n_keyframes=5,
+            n_frames=16,
+            contact_constraints=contact_constraints
+        )
+
+        print(f"\nGenerated {len(frame_paths)} frames.")
+        print("Feed to Wan2.2 using adjacent pairs:")
+        print("  (frame_0000.png, frame_0001.png) -> clip_0")
+        print("  (frame_0001.png, frame_0002.png) -> clip_1")
+        print("  ...")

Downloads/handover_summary(1).md

@@ -0,0 +1,220 @@
+# MoSketch Pipeline Handover Summary
+**Date:** June 2026  
+**Project:** Multi-object sketch animation pipeline replacing MoSketch's SDS optimisation
+
+---
+
+## Research Contribution
+Replace MoSketch's SDS test-time optimisation (~1hr/clip) with:
+1. Feedforward LLM-based motion planning (Qwen2.5-7B)
+2. Geometric solver (rigid translation of SVG control points)
+3. Wan2.2 video synthesis (not yet integrated — VRAM constraint)
+
+Uses MoSketch's pre-computed stroke assignments for fair comparison.
+Cite as: "identical segmentation to MoSketch for fair evaluation."
+
+---
+
+## Server Environment
+- Server: `otter34`, user `rk01499`
+- Conda env: `/scratch/rk01499/anaconda3/envs/mosketch/` (Python 3.8)
+- ALWAYS use full path: `/scratch/rk01499/anaconda3/envs/mosketch/bin/python`
+- GPU: RTX A4000 (16GB VRAM) — only ~2GB free when Qwen loaded
+- `python` alias breaks between sessions — always use full path
+
+---
+
+## Key File Locations
+
+### Pipeline Files
+| File | Location | Status |
+|------|----------|--------|
+| `mosketch_pipeline_v3.py` | `/scratch/rk01499/MoSketch_svg/` | Working baseline |
+| `mosketch_pipeline_v5.py` | `/scratch/rk01499/MoSketch_svg/` | v3 + intent planner (current) |
+| `stage3_intent_planner.py` | `/scratch/rk01499/MoSketch_svg/` | Intent-based Stage 3 module |
+
+### Data
+| Resource | Location |
+|----------|----------|
+| SVG files | `/user/HS400/rk01499/my_scratch/MoSketch/data/raw/60sketches/svg/` |
+| PNG files | `/user/HS400/rk01499/my_scratch/MoSketch/data/raw/60sketches/png/` |
+| Captions | `/user/HS400/rk01499/my_scratch/MoSketch/data/raw/60sketches/caption.txt` |
+| Semantic assignments | `/user/HS400/rk01499/my_scratch/MoSketch/data/processed/{name}/{name}_semantic.txt` |
+| v3 outputs | `/user/HS400/rk01499/my_scratch/MoSketch/output_geometric_v3/` |
+| v5 outputs | `/user/HS400/rk01499/my_scratch/MoSketch/output_geometric_v5/` |
+
+### Models
+| Model | Location |
+|-------|----------|
+| Qwen2.5-7B | `/user/HS400/rk01499/my_scratch/models/qwen2.5-7b/` |
+| Qwen2.5-14B | `/scratch/rk01499/models/qwen2.5-14b/` |
+| Grounding DINO | `/user/HS400/rk01499/my_scratch/models/groundingdino_swint_ogc.pth` |
+| ModelScope T2V 1.7B | `/scratch/rk01499/MoSketch/text-to-video-ms-1.7b/` |
+| Wan2.2 | NOT downloaded — needs 28GB, 482GB free on /scratch |
+
+---
+
+## Pipeline Architecture (v5 — current)
+
+```
+SVG + caption
+  → Stage 1: Qwen keyframe decomposition (5 descriptions)
+  → Stage 2: Read _semantic.txt stroke assignments
+  → Stage 2b: Parse SVG paths, assign to objects, compute bounding boxes
+  → Stage 3: Intent planner (stage3_intent_planner.py)
+             Qwen outputs: endpoint, path, group, contact_kf, group_after_kf
+             Geometry computes: actual pixel trajectories
+  → Stage 4: Geometric solver (rigid translation of control points)
+  → Stage 5A: Pipeline A — 5 sparse keyframes
+     Stage 5B: Pipeline B — 16 cubic-spline-interpolated frames
+```
+
+---
+
+## Stage 3 Intent Planner (stage3_intent_planner.py)
+
+### Intent Schema
+```json
+{
+  "object_name": {
+    "endpoint":       "other_object | left_edge | right_edge | top | bottom | stationary",
+    "path":           "straight | arc_up | arc_down | follow | circular | downward",
+    "group":          "other_object | independent",
+    "contact_kf":     3,
+    "group_after_kf": "other_object | null"
+  }
+}
+```
+
+### Path Types
+- `straight` — direct line from start to end
+- `arc_up` — parabolic rise then fall (projectiles, throws, jumps)
+- `arc_down` — dips then recovers (rollercoaster)
+- `follow` — copies another object's displacement (smoke trails shell)
+- `circular` — orbits a center point (satellite)
+- `downward` — falls straight down (liquid)
+
+### Key Features
+- **Two-pass trajectory computation**: independent objects first, followers second
+- **Post-contact grouping**: frisbee joins dog's trajectory after contact_kf
+- **Dynamic endpoint**: frisbee targets dog's position at contact_kf, not initial position
+- **Upper quarter contact**: endpoint uses top 25% of target bbox (mouth not belly)
+
+### Unit Tests
+```bash
+/scratch/rk01499/anaconda3/envs/mosketch/bin/python stage3_intent_planner.py
+```
+Both cannon1 and dog3 tests pass. Frisbee follows dog at kf4: PASS
+
+---
+
+## Known Issues and Fixes Applied
+
+### Fixed
+- cairosvg 2.7.1 black image bug → `preprocess_svg()` adds white bg + converts rgb() to hex
+- Qwen JSON parsing failures → `parse_qwen_json()` extracts JSON between first { and last }
+- Shell jumping to cannon at kf0 → locked start (kf0 = actual centroid)
+- Smoke moving toward cannon → intent planner `group=shell` (smoke follows shell)
+- Shell falling instead of flying → motion hints added to prompt
+- All paths assigned to one object → using MoSketch _semantic.txt instead of DINO
+
+### Known Limitations (document in paper)
+- No video generation yet (Wan2.2 needs 28GB, 16GB VRAM with Qwen loaded)
+- Curved road following not implemented (carfp15, carfp36, carfp38, carfp48, carside13)
+- Non-rigid deformation not implemented (Wan2.2 handles this)
+- Contact events approximate (frisbee reaches dog bbox centroid area)
+- Dog not moving in dog3 (Qwen still plans it stationary despite hints — last known issue)
+- Uses MoSketch pre-computed segmentation (own DINO+SAM deferred to future work)
+
+---
+
+## Run Commands
+
+```bash
+# single sketch
+/scratch/rk01499/anaconda3/envs/mosketch/bin/python mosketch_pipeline_v5.py --sketch cannon1
+
+# all 60 sketches
+/scratch/rk01499/anaconda3/envs/mosketch/bin/python mosketch_pipeline_v5.py --all
+
+# pipeline A only (faster)
+/scratch/rk01499/anaconda3/envs/mosketch/bin/python mosketch_pipeline_v5.py --all --pipeline A
+
+# unit tests for intent planner
+/scratch/rk01499/anaconda3/envs/mosketch/bin/python stage3_intent_planner.py
+```
+
+---
+
+## Immediate Next Steps
+
+1. **Fix dog not moving** — dog3 intent has `endpoint=stationary` despite caption saying "sprints forward". Add stronger hint to prompt or post-process to detect stationary animals described as moving.
+
+2. **Download Wan2.2** for video synthesis:
+```bash
+/scratch/rk01499/anaconda3/envs/mosketch/bin/python -c "
+from huggingface_hub import snapshot_download
+snapshot_download(
+    repo_id='Wan-AI/Wan2.1-FLF2V-14B-720P-diffusers',
+    local_dir='/scratch/rk01499/models/wan-flf2v',
+    ignore_patterns=['*.md', '*.txt']
+)
+"
+```
+Need to kill Qwen process first to free VRAM. Run keyframe generation and video synthesis as separate scripts.
+
+3. **Run all 60 with v5** and compare against v3 outputs to measure improvement.
+
+4. **Modularise code** into:
+   - `config.py` — paths and constants
+   - `models.py` — Qwen loading
+   - `data.py` — caption loader, semantic reader
+   - `svg_parser.py` — SVG parsing, path assignment
+   - `planner.py` — wraps stage3_intent_planner
+   - `solver.py` — geometric solver
+   - `renderer.py` — rasterization, pipeline A/B
+   - `pipeline.py` — main entry point
+
+5. **Implement own DINO+SAM segmentation** for unseen sketch generalisation (deferred — use MoSketch files for now).
+
+---
+
+## Semantic File Format
+```
+object_name<TAB>stroke_idx1,stroke_idx2,...
+```
+Example (carfp36):
+```
+road        1,2,44,45,...,79
+jeep        0,3,4,...,43
+motorcycle  80,81,...,168
+```
+Background objects (road, ground, sky) never move.
+
+---
+
+## cairosvg Fix (CRITICAL — without this all frames are black)
+```python
+def preprocess_svg(svg_path=None, svg_content=None):
+    if svg_content is None:
+        with open(svg_path, 'r') as f:
+            svg_content = f.read()
+    svg_content = svg_content.replace('<g>', '<g><rect width="256" height="256" fill="white"/>', 1)
+    svg_content = re.sub(r'stroke="rgb\(0,\s*0,\s*0\)"', 'stroke="#000000"', svg_content)
+    return svg_content.encode('utf-8')
+```
+
+---
+
+## Motion Types Across 60 Sketches
+| Type | Count | Path | Examples |
+|------|-------|------|---------|
+| Projectile arc | 12 | arc_up | cannon, frisbee, basketball, dolphin |
+| Horizontal approach | 14 | straight | two cars, predator+prey, cat+mouse |
+| Vertical motion | 8 | straight up/down | airplane, shuttle, rappel, ladder |
+| Follow/trail | 7 | follow | smoke+cannon, carriage+horse |
+| Curved road | 5 | arc_road (not impl) | carfp15/36/38/48, carside13 |
+| Stationary | 8 | stationary | eating, grazing, couple |
+| Rotation/orbit | 3 | circular | satellite, rollercoaster |
+| Pour/flow | 3 | downward | bottle, ice splash |
+

Downloads/handover_summary.md

@@ -0,0 +1,220 @@
+# MoSketch Pipeline Handover Summary
+**Date:** June 2026  
+**Project:** Multi-object sketch animation pipeline replacing MoSketch's SDS optimisation
+
+---
+
+## Research Contribution
+Replace MoSketch's SDS test-time optimisation (~1hr/clip) with:
+1. Feedforward LLM-based motion planning (Qwen2.5-7B)
+2. Geometric solver (rigid translation of SVG control points)
+3. Wan2.2 video synthesis (not yet integrated — VRAM constraint)
+
+Uses MoSketch's pre-computed stroke assignments for fair comparison.
+Cite as: "identical segmentation to MoSketch for fair evaluation."
+
+---
+
+## Server Environment
+- Server: `otter34`, user `rk01499`
+- Conda env: `/scratch/rk01499/anaconda3/envs/mosketch/` (Python 3.8)
+- ALWAYS use full path: `/scratch/rk01499/anaconda3/envs/mosketch/bin/python`
+- GPU: RTX A4000 (16GB VRAM) — only ~2GB free when Qwen loaded
+- `python` alias breaks between sessions — always use full path
+
+---
+
+## Key File Locations
+
+### Pipeline Files
+| File | Location | Status |
+|------|----------|--------|
+| `mosketch_pipeline_v3.py` | `/scratch/rk01499/MoSketch_svg/` | Working baseline |
+| `mosketch_pipeline_v5.py` | `/scratch/rk01499/MoSketch_svg/` | v3 + intent planner (current) |
+| `stage3_intent_planner.py` | `/scratch/rk01499/MoSketch_svg/` | Intent-based Stage 3 module |
+
+### Data
+| Resource | Location |
+|----------|----------|
+| SVG files | `/user/HS400/rk01499/my_scratch/MoSketch/data/raw/60sketches/svg/` |
+| PNG files | `/user/HS400/rk01499/my_scratch/MoSketch/data/raw/60sketches/png/` |
+| Captions | `/user/HS400/rk01499/my_scratch/MoSketch/data/raw/60sketches/caption.txt` |
+| Semantic assignments | `/user/HS400/rk01499/my_scratch/MoSketch/data/processed/{name}/{name}_semantic.txt` |
+| v3 outputs | `/user/HS400/rk01499/my_scratch/MoSketch/output_geometric_v3/` |
+| v5 outputs | `/user/HS400/rk01499/my_scratch/MoSketch/output_geometric_v5/` |
+
+### Models
+| Model | Location |
+|-------|----------|
+| Qwen2.5-7B | `/user/HS400/rk01499/my_scratch/models/qwen2.5-7b/` |
+| Qwen2.5-14B | `/scratch/rk01499/models/qwen2.5-14b/` |
+| Grounding DINO | `/user/HS400/rk01499/my_scratch/models/groundingdino_swint_ogc.pth` |
+| ModelScope T2V 1.7B | `/scratch/rk01499/MoSketch/text-to-video-ms-1.7b/` |
+| Wan2.2 | NOT downloaded — needs 28GB, 482GB free on /scratch |
+
+---
+
+## Pipeline Architecture (v5 — current)
+
+```
+SVG + caption
+  → Stage 1: Qwen keyframe decomposition (5 descriptions)
+  → Stage 2: Read _semantic.txt stroke assignments
+  → Stage 2b: Parse SVG paths, assign to objects, compute bounding boxes
+  → Stage 3: Intent planner (stage3_intent_planner.py)
+             Qwen outputs: endpoint, path, group, contact_kf, group_after_kf
+             Geometry computes: actual pixel trajectories
+  → Stage 4: Geometric solver (rigid translation of control points)
+  → Stage 5A: Pipeline A — 5 sparse keyframes
+     Stage 5B: Pipeline B — 16 cubic-spline-interpolated frames
+```
+
+---
+
+## Stage 3 Intent Planner (stage3_intent_planner.py)
+
+### Intent Schema
+```json
+{
+  "object_name": {
+    "endpoint":       "other_object | left_edge | right_edge | top | bottom | stationary",
+    "path":           "straight | arc_up | arc_down | follow | circular | downward",
+    "group":          "other_object | independent",
+    "contact_kf":     3,
+    "group_after_kf": "other_object | null"
+  }
+}
+```
+
+### Path Types
+- `straight` — direct line from start to end
+- `arc_up` — parabolic rise then fall (projectiles, throws, jumps)
+- `arc_down` — dips then recovers (rollercoaster)
+- `follow` — copies another object's displacement (smoke trails shell)
+- `circular` — orbits a center point (satellite)
+- `downward` — falls straight down (liquid)
+
+### Key Features
+- **Two-pass trajectory computation**: independent objects first, followers second
+- **Post-contact grouping**: frisbee joins dog's trajectory after contact_kf
+- **Dynamic endpoint**: frisbee targets dog's position at contact_kf, not initial position
+- **Upper quarter contact**: endpoint uses top 25% of target bbox (mouth not belly)
+
+### Unit Tests
+```bash
+/scratch/rk01499/anaconda3/envs/mosketch/bin/python stage3_intent_planner.py
+```
+Both cannon1 and dog3 tests pass. Frisbee follows dog at kf4: PASS
+
+---
+
+## Known Issues and Fixes Applied
+
+### Fixed
+- cairosvg 2.7.1 black image bug → `preprocess_svg()` adds white bg + converts rgb() to hex
+- Qwen JSON parsing failures → `parse_qwen_json()` extracts JSON between first { and last }
+- Shell jumping to cannon at kf0 → locked start (kf0 = actual centroid)
+- Smoke moving toward cannon → intent planner `group=shell` (smoke follows shell)
+- Shell falling instead of flying → motion hints added to prompt
+- All paths assigned to one object → using MoSketch _semantic.txt instead of DINO
+
+### Known Limitations (document in paper)
+- No video generation yet (Wan2.2 needs 28GB, 16GB VRAM with Qwen loaded)
+- Curved road following not implemented (carfp15, carfp36, carfp38, carfp48, carside13)
+- Non-rigid deformation not implemented (Wan2.2 handles this)
+- Contact events approximate (frisbee reaches dog bbox centroid area)
+- Dog not moving in dog3 (Qwen still plans it stationary despite hints — last known issue)
+- Uses MoSketch pre-computed segmentation (own DINO+SAM deferred to future work)
+
+---
+
+## Run Commands
+
+```bash
+# single sketch
+/scratch/rk01499/anaconda3/envs/mosketch/bin/python mosketch_pipeline_v5.py --sketch cannon1
+
+# all 60 sketches
+/scratch/rk01499/anaconda3/envs/mosketch/bin/python mosketch_pipeline_v5.py --all
+
+# pipeline A only (faster)
+/scratch/rk01499/anaconda3/envs/mosketch/bin/python mosketch_pipeline_v5.py --all --pipeline A
+
+# unit tests for intent planner
+/scratch/rk01499/anaconda3/envs/mosketch/bin/python stage3_intent_planner.py
+```
+
+---
+
+## Immediate Next Steps
+
+1. **Fix dog not moving** — dog3 intent has `endpoint=stationary` despite caption saying "sprints forward". Add stronger hint to prompt or post-process to detect stationary animals described as moving.
+
+2. **Download Wan2.2** for video synthesis:
+```bash
+/scratch/rk01499/anaconda3/envs/mosketch/bin/python -c "
+from huggingface_hub import snapshot_download
+snapshot_download(
+    repo_id='Wan-AI/Wan2.1-FLF2V-14B-720P-diffusers',
+    local_dir='/scratch/rk01499/models/wan-flf2v',
+    ignore_patterns=['*.md', '*.txt']
+)
+"
+```
+Need to kill Qwen process first to free VRAM. Run keyframe generation and video synthesis as separate scripts.
+
+3. **Run all 60 with v5** and compare against v3 outputs to measure improvement.
+
+4. **Modularise code** into:
+   - `config.py` — paths and constants
+   - `models.py` — Qwen loading
+   - `data.py` — caption loader, semantic reader
+   - `svg_parser.py` — SVG parsing, path assignment
+   - `planner.py` — wraps stage3_intent_planner
+   - `solver.py` — geometric solver
+   - `renderer.py` — rasterization, pipeline A/B
+   - `pipeline.py` — main entry point
+
+5. **Implement own DINO+SAM segmentation** for unseen sketch generalisation (deferred — use MoSketch files for now).
+
+---
+
+## Semantic File Format
+```
+object_name<TAB>stroke_idx1,stroke_idx2,...
+```
+Example (carfp36):
+```
+road        1,2,44,45,...,79
+jeep        0,3,4,...,43
+motorcycle  80,81,...,168
+```
+Background objects (road, ground, sky) never move.
+
+---
+
+## cairosvg Fix (CRITICAL — without this all frames are black)
+```python
+def preprocess_svg(svg_path=None, svg_content=None):
+    if svg_content is None:
+        with open(svg_path, 'r') as f:
+            svg_content = f.read()
+    svg_content = svg_content.replace('<g>', '<g><rect width="256" height="256" fill="white"/>', 1)
+    svg_content = re.sub(r'stroke="rgb\(0,\s*0,\s*0\)"', 'stroke="#000000"', svg_content)
+    return svg_content.encode('utf-8')
+```
+
+---
+
+## Motion Types Across 60 Sketches
+| Type | Count | Path | Examples |
+|------|-------|------|---------|
+| Projectile arc | 12 | arc_up | cannon, frisbee, basketball, dolphin |
+| Horizontal approach | 14 | straight | two cars, predator+prey, cat+mouse |
+| Vertical motion | 8 | straight up/down | airplane, shuttle, rappel, ladder |
+| Follow/trail | 7 | follow | smoke+cannon, carriage+horse |
+| Curved road | 5 | arc_road (not impl) | carfp15/36/38/48, carside13 |
+| Stationary | 8 | stationary | eating, grazing, couple |
+| Rotation/orbit | 3 | circular | satellite, rollercoaster |
+| Pour/flow | 3 | downward | bottle, ice splash |
+

Downloads/lbs_seam_constrained(1).py

@@ -0,0 +1,222 @@
+"""
+Reference: point-level Linear Blend Skinning with HARD seam constraints.
+
+Use this to diff against your existing test_lbs.py. The two things to check
+in your own code:
+
+  1. Are skinning weights computed PER CONTROL POINT, not per stroke?
+     (per-stroke weighting still tears at joints, just less visibly)
+  2. Do stroke endpoints that coincide in the rest pose get IDENTICAL
+     rest-pose coordinates AND identical weight vectors, forced
+     explicitly — not just "close because the kernel is smooth"?
+     Matching weights alone is NOT sufficient; the rest positions must
+     also be snapped together, or a nonlinear per-joint transform
+     (rotation) still maps the two near-identical points to different
+     outputs.
+
+Smooth inverse-distance weighting alone reduces tearing but does not
+guarantee zero gap at a seam. Hard-constraining seam pairs to share both
+a rest position and a weight vector guarantees it by construction,
+regardless of whether the per-joint transform is rotation, scale, or
+both.
+"""
+
+import numpy as np
+from scipy.spatial import cKDTree
+
+
+# ---------------------------------------------------------------------------
+# 1. Skinning weights: per POINT, inverse-distance to each joint
+# ---------------------------------------------------------------------------
+
+def compute_skinning_weights(points, joints, power=2.0, eps=1e-6):
+    """
+    points: (N, 2) array of ALL control points across ALL strokes, flattened.
+            Do NOT compute this per-stroke and re-run per stroke — every
+            point in the whole sketch must be weighted against every joint
+            in one pass so shared/seam points are handled consistently.
+    joints: (J, 2) array of joint centers.
+
+    Returns:
+        weights: (N, J) array, each row sums to 1.
+    """
+    points = np.asarray(points, dtype=float)
+    joints = np.asarray(joints, dtype=float)
+
+    # (N, J) distance matrix
+    diff = points[:, None, :] - joints[None, :, :]
+    dist = np.linalg.norm(diff, axis=2)
+    dist = np.maximum(dist, eps)
+
+    inv = 1.0 / (dist ** power)
+    weights = inv / inv.sum(axis=1, keepdims=True)
+    return weights
+
+
+# ---------------------------------------------------------------------------
+# 2. Seam detection: find stroke endpoints that coincide in rest pose
+# ---------------------------------------------------------------------------
+
+def find_seam_groups(stroke_endpoints, tol=2.0):
+    """
+    stroke_endpoints: list of (point_index, xy) for every stroke START/END
+                       point (the points most likely to be shared joints
+                       between adjacent strokes, e.g. leg-to-torso).
+    tol: pixel distance below which two endpoints are considered "the same
+         point" and must move together.
+
+    Returns:
+        list of lists, each inner list = point indices that must share
+        one weight vector (a seam group).
+    """
+    idxs = np.array([i for i, _ in stroke_endpoints])
+    coords = np.array([xy for _, xy in stroke_endpoints])
+
+    tree = cKDTree(coords)
+    pairs = tree.query_pairs(r=tol)
+
+    # union-find to merge transitive seam groups (A-B, B-C => A-B-C)
+    parent = {i: i for i in idxs}
+
+    def find(x):
+        while parent[x] != x:
+            parent[x] = parent[parent[x]]
+            x = parent[x]
+        return x
+
+    def union(a, b):
+        ra, rb = find(a), find(b)
+        if ra != rb:
+            parent[ra] = rb
+
+    for a, b in pairs:
+        union(idxs[a], idxs[b])
+
+    groups = {}
+    for i in idxs:
+        root = find(i)
+        groups.setdefault(root, []).append(i)
+
+    return [g for g in groups.values() if len(g) > 1]
+
+
+# ---------------------------------------------------------------------------
+# 3. Force seam groups to share identical weight vectors
+# ---------------------------------------------------------------------------
+
+def enforce_seam_constraints(points, weights, seam_groups):
+    """
+    points: (N, 2) rest-pose points, modified in place (and returned) so
+            every point in a seam group is snapped to the same rest
+            position — the average of the group.
+    weights: (N, J), modified in place (and returned) so every point in a
+             seam group gets the SAME weight row.
+
+    Both fixes are required. Matching weights alone is not enough: if the
+    rest-pose coordinates still differ by even a fraction of a pixel, a
+    nonlinear per-joint transform (rotation) maps them to different
+    outputs even under identical weights. You need points AND weights to
+    agree at a seam, or the "fix" only shrinks the gap instead of
+    eliminating it.
+    """
+    points = points.copy()
+    weights = weights.copy()
+    for group in seam_groups:
+        avg_point = points[group].mean(axis=0)
+        points[group] = avg_point
+
+        avg_w = weights[group].mean(axis=0)
+        avg_w = avg_w / avg_w.sum()
+        weights[group] = avg_w
+    return points, weights
+
+
+# ---------------------------------------------------------------------------
+# 4. Apply per-joint transforms via the (now seam-safe) weights
+# ---------------------------------------------------------------------------
+
+def apply_lbs(points, weights, joint_transforms):
+    """
+    points: (N, 2) rest-pose points.
+    weights: (N, J) from enforce_seam_constraints.
+    joint_transforms: list of J functions, each mapping a point (2,) to
+                       its transformed position (2,) under that joint's
+                       rotation/scale/whatever. E.g.:
+
+                       def make_transform(center, angle_deg, scale=1.0):
+                           theta = np.radians(angle_deg)
+                           R = np.array([[np.cos(theta), -np.sin(theta)],
+                                         [np.sin(theta),  np.cos(theta)]])
+                           def f(p):
+                               return center + scale * R @ (p - center)
+                           return f
+
+    Returns:
+        deformed points, (N, 2).
+    """
+    points = np.asarray(points, dtype=float)
+    N, J = weights.shape
+    out = np.zeros_like(points)
+
+    for j in range(J):
+        transformed_j = np.array([joint_transforms[j](p) for p in points])
+        out += weights[:, j:j + 1] * transformed_j
+
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Example usage / sanity check
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    # Toy example: two strokes meeting at a joint. In real SVG data these
+    # "shared" endpoints are almost never bit-identical — they're drawn as
+    # two separate strokes with independently-rounded coordinates, e.g.
+    # torso ends near (2.0, 0.0) and the leg stroke starts near (2.004, -0.003).
+    # That tiny mismatch is enough for a smooth weight kernel to assign
+    # slightly different weights to each — and once joints rotate by
+    # different amounts, "slightly different weights" becomes a visible gap.
+    stroke_a = np.array([[0, 0], [1, 0], [2.0, 0.0]], dtype=float)      # torso-ish
+    stroke_b = np.array([[2.004, -0.003], [2, -1], [2, -2]], dtype=float)  # leg-ish
+
+    all_points = np.vstack([stroke_a, stroke_b])
+    # indices: 0,1,2 = stroke_a ; 3,4,5 = stroke_b ; point 2 and 3 are the "same" joint
+
+    joints = np.array([[0.5, 0], [2, -1]])  # torso joint, leg joint
+
+    # seam candidates: the shared endpoint appears twice (index 2 and 3),
+    # tol set generously since real sketch data has this kind of slop
+    endpoints = [(2, all_points[2]), (3, all_points[3])]
+    seams = find_seam_groups(endpoints, tol=0.5)
+    print("seam groups:", seams)
+
+    W = compute_skinning_weights(all_points, joints, power=2.0)
+    points_fixed, W_fixed = enforce_seam_constraints(all_points, W, seams)
+
+    print("naive weights at seam:   ", W[2], W[3], " <- not identical")
+    print("fixed weights at seam:   ", W_fixed[2], W_fixed[3], " <- forced identical")
+    print("naive rest points at seam:", all_points[2], all_points[3], " <- not identical")
+    print("fixed rest points at seam:", points_fixed[2], points_fixed[3], " <- snapped identical")
+
+    def make_transform(center, angle_deg, scale=1.0):
+        theta = np.radians(angle_deg)
+        R = np.array([[np.cos(theta), -np.sin(theta)],
+                      [np.sin(theta), np.cos(theta)]])
+        def f(p):
+            return center + scale * (R @ (p - center))
+        return f
+
+    transforms = [
+        make_transform(joints[0], angle_deg=10, scale=1.0),
+        make_transform(joints[1], angle_deg=-30, scale=1.2),  # different rotation AND scale
+    ]
+
+    deformed_naive = apply_lbs(all_points, W, transforms)
+    deformed_fixed = apply_lbs(points_fixed, W_fixed, transforms)
+
+    gap_naive = np.linalg.norm(deformed_naive[2] - deformed_naive[3])
+    gap_fixed = np.linalg.norm(deformed_fixed[2] - deformed_fixed[3])
+
+    print(f"seam gap WITHOUT hard constraint: {gap_naive:.6f}")
+    print(f"seam gap WITH hard constraint:    {gap_fixed:.6f}")

Downloads/pipe_3.py

@@ -0,0 +1,1465 @@
+"""
+mosketch_pipeline.py — the full pipeline as one script with subcommands.
+
+Pipeline:
+    1. Identify objects        -> from the semantic file (no Qwen)
+    2. Classify ARAP vs. not   -> `classify` subcommand (one Qwen call, all objects)
+    3. Narrate + deform        -> `narrate` + `deform` subcommands, ONLY for
+                                   objects marked ARAP in step 2
+    4. Render                  -> `render` subcommand; every object gets real
+                                   trajectory translation; ARAP objects
+                                   additionally get deformation on top
+
+Run steps individually for debugging, or use `full` to run everything for
+one sketch in one process — this loads the Qwen model ONCE and reuses it
+across classify/narrate/deform, instead of loading it 3 separate times.
+
+Examples:
+    # step by step
+    python mosketch_pipeline.py classify --model M --caption-file C --sketch-name S --semantic SEM --out deformation.json
+    python mosketch_pipeline.py narrate --model M --caption-file C --sketch-name S --objects dog --out narratives.json
+    python mosketch_pipeline.py deform --model M --svg S.svg --semantic SEM --traj T --narratives narratives.json --deformation deformation.json --out-dir .
+    python mosketch_pipeline.py render --svg S.svg --semantic SEM --traj T --handles-dir .
+
+    # everything at once, one model load
+    python mosketch_pipeline.py full --model M --caption-file C --sketch-name S --svg S.svg --semantic SEM --traj T --out-dir .
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+
+import numpy as np
+
+from lib import (
+    load_strokes_from_svg, load_semantic_assignments, filter_strokes, flatten_strokes,
+    load_object, deduplicate_points, build_mesh, nearest_mesh_vertex,
+    auto_select_handles_deduped, object_bbox_size, arap_deform,
+    load_trajectories, bbox_deltas, get_caption, build_stroke_geometry_text,
+)
+
+N_KEYFRAMES = 5
+MAX_RETRIES = 5
+PLAUSIBILITY_THRESHOLD = 4
+FAITHFULNESS_THRESHOLD = 4  # both must pass to stop — faithfulness previously only
+                            # affected feedback text, never actually gated success
+QUALITY_THRESHOLD = 4       # same upgrade applied to the new quality criterion —
+                            # scored but not gating would repeat the same mistake
+
+
+def faithfulness_passed(score):
+    """
+    faithfulness_score can be a number 1-5, the string "N/A" (no caption
+    was given to compare against, so there's nothing to fail), or missing
+    entirely (treated as NOT passed — can't confirm it's good, so err
+    toward regenerating the narrative rather than assuming it's fine).
+    """
+    if score is None:
+        return False
+    if isinstance(score, str):
+        return score.strip().upper() == "N/A"
+    if isinstance(score, (int, float)):
+        return score >= FAITHFULNESS_THRESHOLD
+    return False
+
+
+def unload_model(model):
+    """Frees GPU memory before loading a different model. Necessary because
+    the narrate/deform steps use a text Qwen model and the judge step uses
+    a separate vision-language model (Qwen3-VL) — on hardware with limited
+    VRAM (this project's RTX A4000, 16GB, already documented as a tight
+    fit for a single model), loading both at once risks the same OOM issue
+    that blocked Wan2.2 integration earlier. Load/unload sequentially
+    instead of assuming both fit simultaneously.
+
+    CONFIRMED BUG (found on real hardware, invisible to all mocked testing
+    since no real GPU was available to catch it): `del model` here only
+    clears THIS function's own local reference — it does nothing to the
+    caller's variable, which stays alive and keeps the whole model
+    resident in VRAM. torch.cuda.empty_cache() then has nothing to
+    actually free, because the refcount never reaches zero. Fixed by
+    returning None — callers MUST reassign their variable to this return
+    value (e.g. `model = unload_model(model)`), or the bug reappears."""
+    import gc
+    del model
+    gc.collect()
+    try:
+        import torch
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+    except ImportError:
+        pass
+    return None
+
+# Dog3's real, human-reviewed narratives — used BOTH as the few-shot example
+# in `narrate` and as the fallback default if --narratives is omitted in
+# `deform`. One constant, one source of truth (previously duplicated across
+# two separate files under two different names with identical content).
+DOG3_CAPTION = ("The person throws a frisbee through the air, and the dog sits poised, "
+                "ready to sprint forward and catch it with its mouth in a swift motion.")
+DOG3_NARRATIVES = {
+    "dog": [
+        "the dog is sitting alert, watching the frisbee as it is thrown",
+        "the dog is beginning to rise, weight shifting forward, head reaching toward the frisbee",
+        "the dog is mid-leap, body extended, reaching far forward and up toward the frisbee",
+        "the dog is at the peak of its jump, reaching as far as possible toward the frisbee",
+        "the dog is landing after catching the frisbee, body compacting back down",
+    ],
+    "frisbee": [
+        "the frisbee has just left the thrower's hand, angled slightly upward",
+        "the frisbee is gliding through the air, tilting slightly as it arcs",
+        "the frisbee is near the peak of its arc, angled toward the dog",
+        "the frisbee is descending toward the dog, tilting down slightly",
+        "the frisbee is at the dog's mouth, being caught",
+    ],
+}
+
+SVG_PATH_DEFAULT = "/mnt/user-data/uploads/dog3.svg"
+SEMANTIC_PATH_DEFAULT = "dog3_semantic.txt"
+DEFAULT_COLOR = "#444444"
+DEFAULT_LINEWIDTH = 1.1
+OBJECT_COLORS = {"dog": "black", "person": "#3F4C57", "frisbee": "#B0463C"}
+OBJECT_LINEWIDTH = {"dog": 1.1, "person": 1.1, "frisbee": 1.4}
+
+
+# =============================================================================
+# shared: Qwen call + response parsing
+# =============================================================================
+
+def query_qwen(model, tokenizer, prompt, device, max_new_tokens=500, temperature=0.1):
+    import torch
+    messages = [{"role": "user", "content": prompt}]
+    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer([text], return_tensors="pt").to(device)
+    input_token_count = inputs["input_ids"].shape[1]
+    with torch.no_grad():
+        output_ids = model.generate(**inputs, max_new_tokens=max_new_tokens,
+                                     temperature=temperature, do_sample=True)
+    generated = output_ids[0][inputs["input_ids"].shape[1]:]
+    output_token_count = generated.shape[0]
+    response_text = tokenizer.decode(generated, skip_special_tokens=True)
+    return response_text, input_token_count, output_token_count
+
+
+def load_qwen_model(model_path):
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    import torch
+    print(f"loading model from {model_path} ...")
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=torch.float16, device_map="auto")
+    device = next(model.parameters()).device
+    print("model loaded.")
+    return model, tokenizer, device
+
+
+def parse_json_response(response_text):
+    match = re.search(r"\{.*\}", response_text, re.DOTALL)
+    if not match:
+        raise ValueError("No JSON object found in response:\n" + response_text)
+    return json.loads(match.group(0))
+
+
+# =============================================================================
+# STEP 2: classify — ARAP vs TRAJ_ONLY, one call, all objects
+# =============================================================================
+
+def build_deformation_prompt(caption, object_names):
+    objects_str = ", ".join(f'"{o}"' for o in object_names)
+    lines = "\n".join(
+        f'  "{o}": "ARAP" or "TRAJ_ONLY"' + ("," if i < len(object_names) - 1 else "")
+        for i, o in enumerate(object_names)
+    )
+    return f"""Scene: "{caption}"
+
+Objects in this scene: {objects_str}
+
+For each object, decide whether representing it correctly needs NON-RIGID DEFORMATION (its body/shape changes — e.g. limbs moving, a neck reaching, a body crouching or leaning) or whether simple RIGID TRANSLATION (the object moves/rotates as a whole, unchanged in shape, or doesn't move at all) is enough.
+
+Answer "ARAP" if the object's shape or body configuration changes at any point in the action, even if its overall position doesn't change. Answer "TRAJ_ONLY" if the object is rigid (a vehicle, tool, projectile, furniture, background element) or is simply carried by its own movement without changing shape.
+
+Respond with ONLY a JSON object, no other text, in this exact format:
+{{
+{lines}
+}}
+"""
+
+
+def validate_deformation(parsed, object_names):
+    problems = []
+    for obj in object_names:
+        if obj not in parsed:
+            problems.append(f"'{obj}' missing from response")
+            continue
+        val = str(parsed[obj]).strip().upper()
+        if val not in ("ARAP", "TRAJ_ONLY"):
+            problems.append(f"'{obj}' has invalid value {parsed[obj]!r}, expected ARAP or TRAJ_ONLY")
+    return problems
+
+
+def run_classify(model, tokenizer, device, caption, semantic_path, out_path):
+    assignments = load_semantic_assignments(semantic_path)
+    object_names = list(assignments.keys())
+    print(f"objects found in {semantic_path}: {object_names}")
+
+    prompt = build_deformation_prompt(caption, object_names)
+    print("\n--- CLASSIFY PROMPT ---")
+    print(prompt)
+
+    response, in_tok, out_tok = query_qwen(model, tokenizer, prompt, device,
+                                            max_new_tokens=250, temperature=0.1)
+    print(f"\ntokens: {in_tok} in / {out_tok} out")
+    print("--- RAW RESPONSE ---")
+    print(response)
+
+    parsed = parse_json_response(response)
+    problems = validate_deformation(parsed, object_names)
+    print("\n--- PARSED ---")
+    print(json.dumps(parsed, indent=2))
+    if problems:
+        print("--- VALIDATION PROBLEMS ---")
+        for p in problems:
+            print(f"  - {p}")
+
+    arap_objs = [o for o in object_names if str(parsed.get(o, "")).strip().upper() == "ARAP"]
+    traj_only_objs = [o for o in object_names if o not in arap_objs]
+    print(f"\nARAP: {arap_objs}")
+    print(f"TRAJ_ONLY: {traj_only_objs}")
+
+    with open(out_path, "w") as f:
+        json.dump(parsed, f, indent=2)
+    print(f"wrote {out_path}")
+    return parsed, arap_objs
+
+
+def build_objects_info(svg_path, semantic_path, arap_objects):
+    """
+    Standalone version of the mesh/joint setup previously embedded inside
+    run_deform — factored out so the unified narrate+deform+judge retry
+    loop can build this ONCE before the loop (mesh/joints never change
+    between attempts) instead of recomputing it every attempt.
+    """
+    objects_info = {}
+    for obj_name in arap_objects:
+        points, slices = load_object(obj_name, svg_path, semantic_path)
+        bbox_size = object_bbox_size(points)
+        unique_points, p2u = deduplicate_points(points, tol=0.35)
+        tri, edges = build_mesh(unique_points)
+        strokes = filter_strokes(load_strokes_from_svg(svg_path),
+                                  load_semantic_assignments(semantic_path)[obj_name])
+        joints, anchor_idx, handle_idxs, joint_mesh_indices = auto_select_handles_deduped(
+            strokes, unique_points, k=4)
+
+        if len(handle_idxs) == 0:
+            print(f"WARNING: '{obj_name}' has no independent handles after dedup, skipping")
+            continue
+
+        print(f"'{obj_name}': {len(joints)} joints, anchor={anchor_idx}, handles={handle_idxs}, "
+              f"mesh_indices={joint_mesh_indices}, bbox_size={bbox_size:.1f}")
+
+        objects_info[obj_name] = {
+            "joints": joints, "anchor_idx": anchor_idx, "handle_idxs": handle_idxs,
+            "joint_mesh_indices": joint_mesh_indices, "bbox_size": bbox_size, "strokes": strokes,
+            "points": points, "slices": slices, "unique_points": unique_points,
+            "p2u": p2u, "edges": edges,
+        }
+    return objects_info
+
+
+def build_deformed_stroke_geometry_text(object_info, kf_targets, n_points=2):
+    """
+    Reconstructs what a SPECIFIC keyframe's ACTUAL DEFORMED shape looks
+    like, as compact text — runs the SAME ARAP solve used for real
+    rendering, so a stroke's coordinates here are that keyframe's true
+    rendered position, not its rest-pose position. This is what makes
+    the judge's target_coords anchoring correct PER KEYFRAME instead of
+    only correct when a keyframe happens to match rest — e.g. a "mouth"
+    stroke's rest coordinate is wrong context if the head itself has
+    moved by kf3, this reconstructs where that stroke actually is at kf3.
+
+    kf_targets: {joint_i_str: [x, y]} for ONE keyframe, in the same
+    "joint_i" key format apply_deform_clip_and_write saves (i.e. one
+    entry of deform_outputs[obj_name][kf_key]).
+
+    COST, not glossed over: re-runs arap_deform (10 iterations) once per
+    object per keyframe purely to build this text — measured ~2,866
+    tokens for a single 64-stroke object across all 5 keyframes, and that
+    multiplies per object in a multi-object scene. This is real compute
+    and real prompt-length cost on top of everything else already in the
+    judge prompt (images, rest geometry, joint legend, targets, bbox).
+    """
+    import re as _re
+    unique_points = object_info["unique_points"]
+    edges = object_info["edges"]
+    p2u = object_info["p2u"]
+    slices = object_info["slices"]
+    anchor_idx = object_info["anchor_idx"]
+    joints = object_info["joints"]
+    joint_mesh_indices = object_info["joint_mesh_indices"]
+
+    handle_mesh_indices, handle_targets = [], []
+    for key, target in kf_targets.items():
+        m = _re.match(r"joint_(\d+)", key)
+        if not m:
+            continue
+        joint_i = int(m.group(1))
+        if joint_i >= len(joint_mesh_indices):
+            continue
+        handle_mesh_indices.append(joint_mesh_indices[joint_i])
+        handle_targets.append(target)
+    # anchor is always held at rest, same convention as rendering
+    handle_mesh_indices.append(joint_mesh_indices[anchor_idx])
+    handle_targets.append(joints[anchor_idx].tolist())
+
+    if not handle_mesh_indices:
+        return None
+
+    deformed_unique = arap_deform(unique_points, edges, handle_mesh_indices,
+                                   np.array(handle_targets), iterations=10)
+    deformed_points = deformed_unique[p2u]
+
+    lines = []
+    for i, (start, end) in enumerate(slices):
+        stroke_pts = deformed_points[start:end]
+        idxs = np.linspace(0, len(stroke_pts) - 1, n_points).astype(int)
+        pts = stroke_pts[idxs]
+        pts_str = " -> ".join(f"({x:.0f},{y:.0f})" for x, y in pts)
+        lines.append(f"  stroke_{i}: {pts_str}")
+    return "\n".join(lines)
+
+
+def build_all_keyframes_deformed_geometry_text(objects_info, deform_outputs, n_keyframes=N_KEYFRAMES):
+    """
+    For EVERY object and EVERY keyframe of the CURRENT attempt, reconstruct
+    the actual deformed stroke geometry as text — this is the anchor source
+    for the judge's target_coords grounding: the judge is instructed to
+    find a visually-identified stroke's coordinate HERE, per keyframe, not
+    in the rest-pose geometry (which is only correct when that keyframe
+    happens to match rest).
+    """
+    sections = []
+    for obj_name, info in objects_info.items():
+        obj_targets = (deform_outputs or {}).get(obj_name)
+        if not obj_targets:
+            continue
+        kf_parts = []
+        for kf in range(n_keyframes):
+            kf_key = f"kf{kf}"
+            if kf_key not in obj_targets:
+                continue
+            shape_text = build_deformed_stroke_geometry_text(info, obj_targets[kf_key], n_points=2)
+            if shape_text:
+                kf_parts.append(f"  -- {kf_key} --\n{shape_text}")
+        if kf_parts:
+            sections.append(f'Object "{obj_name}":\n' + "\n".join(kf_parts))
+    return "\n\n".join(sections)
+
+
+def render_rest_pose_multi(object_names, svg_path, semantic_path, out_path):
+    """
+    Renders multiple objects' ORIGINAL strokes together, at their real
+    positions in the source SVG (no deformation, no trajectory translation)
+    — this is the "what does the sketch actually look like" image every
+    attempt is grounded in, so Qwen can see what's actually drawable
+    (e.g. whether the dog's back legs even exist as strokes) instead of
+    only reasoning from the caption's text description.
+    """
+    import matplotlib.pyplot as plt
+    fig, ax = plt.subplots(figsize=(6, 6))
+    for name in object_names:
+        points, slices = load_object(name, svg_path, semantic_path)
+        for start, end in slices:
+            seg = points[start:end]
+            ax.plot(seg[:, 0], seg[:, 1], color="black", linewidth=1.2)
+    ax.invert_yaxis()
+    ax.set_aspect("equal")
+    ax.set_title("rest pose")
+    fig.savefig(out_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    return out_path
+
+
+def format_joint_feedback_for_object(object_name, joint_feedback):
+    """
+    Filters the judge's structured joint_feedback list down to entries for
+    THIS object and formats them as explicit, actionable lines. When the
+    judge grounded its suggestion in an actual traced coordinate,
+    delta_px (computed by vlm_judge.compute_joint_feedback_deltas via
+    subtraction, NOT model math) is shown as an exact number the
+    generator can apply directly — e.g.
+      "joint_1 at kf3: hand not near mouth -> move by (dx=+12.0, dy=-8.0)
+       px (target anchored to: mouth stroke in face object)"
+    If the judge couldn't ground a target (target_coords was null, or the
+    joint/keyframe didn't match anything in deform_outputs), delta_px is
+    None and the line falls back to the prose issue only — explicitly
+    labeled as ungrounded rather than silently presenting a guess as if
+    it were a computed number.
+    Returns "" if there's no feedback for this object (nothing to add).
+    """
+    if not joint_feedback:
+        return ""
+    relevant = [f for f in joint_feedback if f.get("object") == object_name]
+    if not relevant:
+        return ""
+    lines = []
+    for f in relevant:
+        kf = f.get("keyframe")
+        kf_str = f"kf{kf}" if kf is not None else "unspecified keyframe"
+        issue = f.get("issue", "")
+        delta = f.get("delta_px")
+        if delta is not None:
+            anchor = f.get("anchored_to", "unspecified")
+            lines.append(
+                f"    - joint_{f.get('joint')} at {kf_str}: {issue} "
+                f"-> move by (dx={delta['dx']:+.1f}, dy={delta['dy']:+.1f}) px "
+                f"(target anchored to: {anchor})"
+            )
+        else:
+            lines.append(
+                f"    - joint_{f.get('joint')} at {kf_str}: {issue} "
+                f"-> [UNGROUNDED — no traceable/disambiguated coordinate was given; use your own judgment]"
+            )
+    return "\n".join(lines)
+
+
+def build_combined_object_section(object_name, joints, anchor_idx, handle_idxs, bbox_size,
+                                   previous_narrative=None, feedback=None, n_keyframes=N_KEYFRAMES,
+                                   freeze_narrative=False, strokes=None, joint_feedback=None,
+                                   baseline_targets=None):
+    """
+    freeze_narrative: if True, previous_narrative is used as a FIXED target
+    pose description (the object's narrative already passed faithfulness —
+    only the numeric deformation needs to improve, not the story). If
+    False (default), the narrative is regenerated fresh, informed by the
+    attached image(s) and feedback, same as before.
+
+    strokes: if given, the object's actual stroke points are included as
+    TEXT (not just the rendered image) — added specifically because
+    multimodal LLMs can under-attend to image content relative to text;
+    this gives the same geometric information in a text-native form the
+    model is more likely to actually use. Kept deliberately sparse (2
+    points per stroke, start+end only) since a complex object can have
+    60+ strokes — measured on real dog3 data: 2 points/stroke costs
+    ~570 tokens for a 64-stroke object vs ~2650 for the full 12
+    points/stroke used internally for the ARAP mesh.
+
+    joint_feedback: the FULL joint_feedback list from the judge's verdict
+    (all objects) — filtered down to this object's entries and formatted
+    as precise per-joint lines. Falls back to nothing (not an error) if
+    the judge didn't return joint_feedback (e.g. coordinate context wasn't
+    given to build_judge_prompt) — the object still gets the old flat
+    `feedback` string via previous_block/feedback_line below.
+
+    baseline_targets: {kf_key: {joint_i_str: [x,y]}} — this object's EXACT
+    numeric targets from the PREVIOUS attempt, given on EVERY retry (not
+    just after a pass) so the generator refines real numbers instead of
+    reconstructing them from images/prose each time — the "guess
+    coordinates from a picture" problem numeric joint_feedback exists to
+    avoid elsewhere. Joints with a GROUNDED joint_feedback correction are
+    excluded here (that correction takes precedence) — this only shows
+    joints without a specific correction, as a "keep unless you have
+    reason to change" anchor, not a fixed target — unlike `pose_lines`
+    used when freeze_narrative=True, which locks the story, not the
+    coordinates.
+    """
+    cap = round(bbox_size * 0.25, 1)
+    joint_feedback_text = format_joint_feedback_for_object(object_name, joint_feedback)
+    joint_feedback_block = (
+        f"\n  Specific per-joint corrections from the judge (apply these precisely, this is not general "
+        f"guidance):\n{joint_feedback_text}\n"
+    ) if joint_feedback_text else ""
+    baseline_block = ""
+    if baseline_targets:
+        # joints the judge gave a GROUNDED correction for (real delta_px, not ungrounded prose) are
+        # excluded from the raw baseline dump below — joint_feedback_block above is the authoritative
+        # instruction for those specific joints, and repeating the stale pre-correction number here
+        # would be redundant at best and contradictory at worst (two different numbers for the same
+        # joint, no clear precedence). Baseline only shows joints WITHOUT a grounded correction, i.e.
+        # "keep these as they were unless you have your own reason to change them."
+        corrected_joints = {
+            f.get("joint") for f in (joint_feedback or [])
+            if f.get("object") == object_name and f.get("delta_px") is not None
+        }
+        kf_parts = []
+        for kf, kf_vals in baseline_targets.items():
+            shown = {j: v for j, v in kf_vals.items()
+                     if int(j.replace("joint_", "")) not in corrected_joints}
+            if shown:
+                kf_parts.append(f"{kf}: {{{', '.join(f'{j}={v}' for j, v in shown.items())}}}")
+        if kf_parts:
+            baseline_block = (
+                f"\n  These are the EXACT numeric targets from the PREVIOUS attempt for joints the judge did "
+                f"NOT give a specific correction for above — a real, working starting point, not a guess: "
+                f"{', '.join(kf_parts)}\n"
+                f"  Keep these numbers unless you have a genuine reason to change them — do not discard them "
+                f"and reinvent from scratch. For any joint listed in the corrections above instead, follow "
+                f"that correction, not these numbers (that joint is intentionally omitted here).\n"
+            )
+    joint_lines = "\n".join(
+        f'    - joint_{i}: rest position (x={joints[i][0]:.1f}, y={joints[i][1]:.1f})'
+        + ("  <-- ANCHOR, must stay at or near this position in EVERY keyframe" if i == anchor_idx else "")
+        for i in range(len(joints))
+    )
+    handle_list_str = ', joint_'.join(str(i) for i in handle_idxs)
+
+    geometry_block = ""
+    if strokes:
+        geometry_text = build_stroke_geometry_text(strokes, n_points=2)
+        geometry_block = (
+            f"\n  This object's ACTUAL drawn strokes (start -> end point of each stroke, same coordinate "
+            f"space as the joints above) — use this to know exactly what is and isn't actually drawn, don't "
+            f"invent motion for parts that have no strokes here:\n{geometry_text}\n"
+        )
+
+    if freeze_narrative and previous_narrative:
+        pose_lines = "\n".join(f"    kf{i}: {desc}" for i, desc in enumerate(previous_narrative))
+        feedback_line = f'\n  This pose story already matches the intended action — it is FIXED, do not change it. ' \
+                         f'Only the numeric target positions need to improve.' \
+                         + (f' Previous attempt was judged: "{feedback}"' if feedback else "") + \
+                         "\n  The attached images show exactly what the previous attempt's target positions " \
+                         "actually looked like when rendered — use them to see specifically what needs to change numerically."
+        return f"""Object: "{object_name}"
+  Joints:
+{joint_lines}
+{geometry_block}
+  Target pose across all {n_keyframes} keyframes (FIXED, already correct — do not rewrite):
+{pose_lines}
+{feedback_line}
+{joint_feedback_block}
+{baseline_block}
+  For non-anchor joints (joint_{handle_list_str}), do not move more than {cap} pixels from REST in any keyframe. IMPORTANT: these {n_keyframes} keyframes are SPARSE anchor points spanning the ENTIRE action, NOT consecutive video frames — a large, dramatic difference between consecutive keyframes is NORMAL and EXPECTED, not an error; the actual in-between motion will be generated separately later by a different model. Positions should progress in a DIRECTIONALLY COHERENT way (don't make real progress toward the action and then have a LATER keyframe randomly revert backward without the narrative describing a reason to — e.g. only "landing"/"settling" should move back toward rest). Small, timid, barely-different positions between keyframes are themselves a mistake, not a safe choice."""
+
+    previous_block = ""
+    if previous_narrative or feedback:
+        parts = []
+        if previous_narrative:
+            parts.append(f"Your previous narrative attempt was:\n{json.dumps(previous_narrative, indent=2)}")
+        if feedback:
+            parts.append(f'That attempt was judged and received this critique: "{feedback}"')
+        parts.append("The attached images show exactly what that previous attempt actually looked like when "
+                      "rendered. Look at them, understand what specifically was wrong, and revise BOTH the "
+                      "narrative and the target positions to fix it — don't just reword the narrative "
+                      "superficially while leaving the same underlying problem.")
+        previous_block = "\n  " + "\n  ".join(parts) + "\n"
+
+    return f"""Object: "{object_name}"
+  Joints:
+{joint_lines}
+{geometry_block}
+{previous_block}
+{joint_feedback_block}
+{baseline_block}
+  For non-anchor joints (joint_{handle_list_str}), do not move more than {cap} pixels from REST in any keyframe. IMPORTANT: these {n_keyframes} keyframes are SPARSE anchor points spanning the ENTIRE action, NOT consecutive video frames — a large, dramatic difference between consecutive keyframes is NORMAL and EXPECTED, not an error; the actual in-between motion will be generated separately later by a different model. Positions should progress in a DIRECTIONALLY COHERENT way (don't make real progress toward the action and then have a LATER keyframe randomly revert backward without the narrative describing a reason to — e.g. only "landing"/"settling" should move back toward rest). Small, timid, barely-different positions between keyframes are themselves a mistake, not a safe choice."""
+
+
+DOG3_COMBINED_FEWSHOT_EXAMPLE = {
+    "dog": {
+        "narrative": [
+            "the dog is sitting alert, watching the frisbee as it is thrown",
+            "the dog is beginning to rise, weight shifting forward, head reaching toward the frisbee",
+            "the dog is mid-leap, body extended, reaching far forward and up toward the frisbee",
+            "the dog is at the peak of its jump, reaching as far as possible toward the frisbee",
+            "the dog is landing after catching the frisbee, body compacting back down",
+        ],
+        # real dog3 joint rest positions: joint_1=(178.28,136.85) head, joint_2=(228.78,194.94)
+        # tail, joint_3=(189.29,151.35) neck — every value below verified to stay within a
+        # 27px cap of rest. Notice the progression BUILDS UP through kf0->kf3 (increasing
+        # displacement, matching "rising -> leaping -> peak reach") and only SETTLES BACK at
+        # kf4 ("landing") — this is the exact monotonic-then-settle shape that was missing
+        # when a real run produced a kf2 spike with kf3/kf4 reverting toward rest with no
+        # narrative reason to.
+        "targets": {
+            "kf0": {"joint_1": [178.3, 136.8], "joint_2": [228.8, 194.9], "joint_3": [189.3, 151.3]},
+            "kf1": {"joint_1": [168.0, 127.0], "joint_2": [232.0, 191.0], "joint_3": [184.0, 144.0]},
+            "kf2": {"joint_1": [160.0, 120.0], "joint_2": [237.0, 186.0], "joint_3": [177.0, 137.0]},
+            "kf3": {"joint_1": [159.0, 119.0], "joint_2": [240.0, 183.0], "joint_3": [174.0, 134.0]},
+            "kf4": {"joint_1": [168.0, 128.0], "joint_2": [231.0, 192.0], "joint_3": [185.0, 146.0]},
+        },
+    }
+}
+
+
+def build_combined_narrate_deform_prompt(objects_info, caption, previous_narratives=None, feedback=None,
+                                          n_keyframes=N_KEYFRAMES, is_retry=False, few_shot=True,
+                                          freeze_narrative=False, joint_feedback=None, baseline_targets=None):
+    sections, example_parts = [], []
+    for name, info in objects_info.items():
+        prev_narrative_for_obj = (previous_narratives or {}).get(name)
+        obj_baseline_targets = (baseline_targets or {}).get(name)
+        sections.append(build_combined_object_section(
+            name, info["joints"], info["anchor_idx"], info["handle_idxs"], info["bbox_size"],
+            previous_narrative=prev_narrative_for_obj, feedback=feedback, n_keyframes=n_keyframes,
+            freeze_narrative=freeze_narrative, strokes=info.get("strokes"), joint_feedback=joint_feedback,
+            baseline_targets=obj_baseline_targets,
+        ))
+        kf_examples = ",\n".join(
+            "        \"kf%d\": {%s}" % (kf, ", ".join(f'"joint_{i}": [x, y]' for i in info["handle_idxs"]))
+            for kf in range(n_keyframes)
+        )
+        if freeze_narrative:
+            example_parts.append(
+                f'  "{name}": {{\n'
+                f'    "targets": {{\n{kf_examples}\n    }}\n'
+                f'  }}'
+            )
+        else:
+            example_parts.append(
+                f'  "{name}": {{\n'
+                f'    "narrative": [<{n_keyframes} short pose description strings, one per keyframe>],\n'
+                f'    "targets": {{\n{kf_examples}\n    }}\n'
+                f'  }}'
+            )
+
+    all_sections = "\n\n".join(sections)
+    example_json = "{\n" + ",\n".join(example_parts) + "\n}"
+
+    image_context = ""
+    if is_retry:
+        image_context = ("The FIRST image attached is the object's original rest pose (undeformed). "
+                          "The remaining images are the actual rendered result of your PREVIOUS attempt, "
+                          "one per keyframe, in order.")
+    else:
+        image_context = ("The attached image shows the object's original rest pose (undeformed) — use this "
+                          "to understand what strokes actually exist and are available to move; do not "
+                          "invent motion for body parts that aren't actually drawn.")
+
+    fewshot_block = ""
+    if few_shot:
+        fewshot_json = json.dumps(DOG3_COMBINED_FEWSHOT_EXAMPLE, indent=2)
+        fewshot_block = f"""Example — for the scene "{DOG3_CAPTION}", a good answer looks like:
+{fewshot_json}
+
+Notice: each narrative keyframe reads as a distinct, substantially different stage of the action — not a near-duplicate of its neighbor, and not a small incremental change from it. The joint targets BUILD UP smoothly (kf0 -> kf1 -> kf2 -> kf3 each moving further than the last) and only settle back toward rest at the FINAL keyframe, matching the narrative's "landing" moment — no keyframe overshoots and then has a later keyframe revert back toward rest without a narrative reason to. Match this style and this kind of numeric consistency for the new scene below.
+
+"""
+
+    if freeze_narrative:
+        output_instruction = (
+            'For EACH object above, the narrative/pose story is already fixed (shown above) — '
+            'produce ONLY:\n'
+            '  "targets": target (x, y) positions for its non-anchor joints, at every keyframe, '
+            'consistent with the fixed pose story above.'
+        )
+    else:
+        output_instruction = (
+            "For EACH object above, produce BOTH:\n"
+            '  1. "narrative": a plain-English pose description for each keyframe. REMEMBER: these are '
+            "SPARSE keyframes spanning the WHOLE action, not consecutive video frames — each description "
+            "should be a meaningfully, substantially different stage of the action from its neighbors, not "
+            "a small incremental change. Write these like 5 distinct captions for 5 different moments spread "
+            "across an entire action, not like 5 near-duplicate snapshots a split-second apart. Under 20 "
+            "words each.\n"
+            '  2. "targets": target (x, y) positions for its non-anchor joints, at every keyframe, '
+            "consistent with your own narrative."
+        )
+
+    return f"""{fewshot_block}You are directing a {n_keyframes}-keyframe animated sequence for a hand-drawn sketch, viewed from the side. Coordinate system: x increases rightward, y increases DOWNWARD.
+
+IMPORTANT: these {n_keyframes} keyframes are SPARSE anchor points sampled across the ENTIRE action from start to finish — NOT consecutive video frames. Think of them like 5 widely-spaced snapshots of a whole motion, not neighboring frames a fraction of a second apart. Large, dramatic pose changes between consecutive keyframes are normal and expected; a separate model will generate the actual in-between motion frames later. Do not treat these like near-continuous animation frames.
+
+Scene: "{caption}"
+
+{image_context}
+
+{all_sections}
+
+{output_instruction}
+
+Consider objects together (e.g. a dog reaching toward a frisbee should be spatially consistent with the frisbee's own position) and consider each object's OWN sequence together — these {n_keyframes} keyframes are SPARSE anchor points spanning the WHOLE action, not consecutive video frames, so large differences between consecutive keyframes are expected and correct, not something to avoid. The many actual in-between motion frames will be generated separately later. Only avoid a keyframe making real progress and then a LATER keyframe randomly reverting backward without the narrative describing why.
+
+Respond with ONLY one JSON object, no other text, in this exact format:
+{example_json}
+"""
+
+
+def run_combined_narrate_deform(model, processor, images, prompt, temperature=0.6):
+    """Same multi-image calling pattern as vlm_judge.run_judge — reused
+    here since both are Qwen3-VL calls with a list of images + one prompt.
+
+    temperature default raised from 0.1 to 0.6 — CONFIRMED on real hardware
+    (eat2, 3 attempts) that at 0.1 the model reproduced its joint targets
+    as an EXACT copy of the rest-position legend values (not just "close
+    to rest" — bit-identical to the decimal) on attempt 1, before any
+    feedback existed to explain it. Near-zero temperature strongly favors
+    the single highest-probability continuation, and copying a number
+    already visible in-context (the rest-position legend, formatted in
+    the same [x, y] style as the requested targets) is a low-risk, easy
+    completion under numeric uncertainty. This is a hypothesis about
+    mechanism, not confirmed root cause — raising temperature is the
+    cheapest test of it before trying a bigger/different model.
+    """
+    import torch
+    content = [{"type": "image", "image": img} for img in images]
+    content.append({"type": "text", "text": prompt})
+    messages = [{"role": "user", "content": content}]
+
+    text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = processor(text=[text], images=images, return_tensors="pt").to(model.device)
+
+    with torch.no_grad():
+        output_ids = model.generate(**inputs, max_new_tokens=500 * N_KEYFRAMES,
+                                     temperature=temperature, do_sample=True)
+
+    generated = output_ids[:, inputs["input_ids"].shape[1]:]
+    response = processor.batch_decode(generated, skip_special_tokens=True)[0]
+    return response
+
+
+def apply_deform_clip_and_write(parsed, objects_info, out_dir, sketch_name, n_keyframes=N_KEYFRAMES,
+                                 frozen_narratives=None):
+    """
+    Shared post-processing for the combined call's "targets" section:
+    same hard-clip logic as the old run_deform, applied here instead.
+    Returns (narratives_dict, deform_outputs_dict, cap_utilization_dict).
+
+    frozen_narratives: {obj_name: [...]} — used as a fallback when the
+    response doesn't include a "narrative" key for an object, which
+    happens when freeze_narrative=True was used in the prompt (the model
+    was never asked to produce one, so its absence is expected, not an
+    error — carry the frozen one forward instead of losing it).
+
+    cap_utilization: {obj_name: mean_fraction_of_cap_used} — CONFIRMED on
+    real hardware (horsecar5's person) that Qwen can propose displacement
+    well within the movement cap without ever being told it did so — the
+    handle selection and clipping were both working correctly, but the
+    actual output was too timid to be visible (e.g. a leg moving only 18%
+    of its allowed range). The hard clip only ever catches OVER the cap;
+    nothing previously caught UNDER-using it. This surfaces that as an
+    explicit number so it can be fed back to Qwen directly.
+    """
+    narratives_out = {}
+    deform_outputs = {}
+    utilization_by_obj = {}  # {obj_name: [fraction, fraction, ...]} across all joints/keyframes
+
+    for obj_name, info in objects_info.items():
+        if obj_name not in parsed:
+            print(f"  WARNING: '{obj_name}' missing from response entirely, skipping")
+            continue
+        obj_result = parsed[obj_name]
+        utilization_by_obj[obj_name] = []
+
+        if "narrative" in obj_result:
+            narratives_out[obj_name] = obj_result["narrative"]
+        elif frozen_narratives and obj_name in frozen_narratives:
+            narratives_out[obj_name] = frozen_narratives[obj_name]
+        else:
+            print(f"  WARNING: '{obj_name}' has no narrative in response and no frozen narrative "
+                  f"to fall back to — narratives.json will be missing this object")
+
+        deform_outputs[obj_name] = {}
+        targets = obj_result.get("targets", {})
+        for kf in range(n_keyframes):
+            kf_key = f"kf{kf}"
+            if kf_key not in targets:
+                print(f"  WARNING: '{obj_name}' missing {kf_key} targets, skipping this frame")
+                continue
+            kf_result = targets[kf_key]
+            out = {}
+            joint_targets_this_kf = {}
+            for name, target in kf_result.items():
+                m = re.match(r"joint_(\d+)", name)
+                if not m:
+                    print(f"  WARNING: unexpected key '{name}' for '{obj_name}' {kf_key}, skipping")
+                    continue
+                joint_i = int(m.group(1))
+                if joint_i >= len(info["joint_mesh_indices"]):
+                    print(f"  WARNING: '{obj_name}' joint_{joint_i} out of range, skipping")
+                    continue
+                # Qwen occasionally returns a bare scalar (e.g. 195.4) instead of an [x, y] pair for
+                # a joint target. np.array(scalar, dtype=float) does NOT error — it silently makes a
+                # 0-d array, which then broadcasts against `rest` (2-d) into a plausible-looking 2-d
+                # `disp` with no error anywhere in THIS function. The malformed value then gets
+                # written to disk as-is and only crashes 3 steps later in run_render, when it tries
+                # to stack this scalar next to properly-shaped [x,y] entries — as an inhomogeneous
+                # array error that gives no indication which object/joint/keyframe was actually bad.
+                # CONFIRMED on real hardware (eagle4, football7/'person') that this happens on real
+                # Qwen output, not just as a theoretical edge case.
+                target_list = target if isinstance(target, (list, tuple)) else [target]
+                if len(target_list) != 2:
+                    print(f"  WARNING: '{obj_name}' {kf_key} joint_{joint_i} target = {target!r}, expected "
+                          f"an [x, y] pair (got {len(target_list)} value(s)) — skipping this joint for this "
+                          f"keyframe rather than writing a malformed value that would crash rendering later")
+                    continue
+                mesh_idx = info["joint_mesh_indices"][joint_i]
+
+                rest = np.array(info["joints"][joint_i])
+                cap = round(info["bbox_size"] * 0.25, 1)
+                target_arr = np.array(target_list, dtype=float)
+                disp = target_arr - rest
+                dist = np.linalg.norm(disp)
+                utilization_by_obj[obj_name].append(min(dist / cap, 1.0) if cap > 0 else 0.0)
+                if dist > cap:
+                    clipped = rest + disp / dist * cap
+                    print(f"  CLIPPED '{obj_name}' {kf_key} joint_{joint_i}: requested {dist:.1f}px "
+                          f"(cap {cap}px) -> clipped to {cap}px, direction preserved")
+                    target = clipped.tolist()
+                else:
+                    target = target_arr.tolist()
+
+                out[str(mesh_idx)] = target
+                joint_targets_this_kf[f"joint_{joint_i}"] = target
+            anchor_mesh_idx = info["joint_mesh_indices"][info["anchor_idx"]]
+            out[str(anchor_mesh_idx)] = info["joints"][info["anchor_idx"]].tolist()
+            deform_outputs[obj_name][kf_key] = joint_targets_this_kf
+
+            out_path = os.path.join(out_dir, f"qwen_{sketch_name}_{obj_name}_kf{kf}.json")
+            with open(out_path, "w") as f:
+                json.dump(out, f, indent=2)
+            print(f"  wrote {out_path}")
+
+    cap_utilization = {}
+    for obj_name, fractions in utilization_by_obj.items():
+        if fractions:
+            mean_frac = sum(fractions) / len(fractions)
+            cap_utilization[obj_name] = mean_frac
+            print(f"  '{obj_name}': mean cap utilization = {mean_frac*100:.0f}% "
+                  f"(across {len(fractions)} joint-keyframe pairs)")
+
+    return narratives_out, deform_outputs, cap_utilization
+# =============================================================================
+# STEP 4: render — compose the full scene (no Qwen call at all)
+# =============================================================================
+
+def run_render(handles_dir, svg_path, semantic_path, traj_path,
+                out_path=None, frames_dir=None):
+    """
+    out_path: if given, ALSO saves the combined strip image (all 5 keyframes
+              side by side) here, outside frames_dir. Optional — pass None
+              to keep output confined to frames_dir only.
+    frames_dir: if given, saves each keyframe as its own individual PNG
+                (kf0.png ... kf4.png) plus the combined strip, named after
+                the sketch itself ({sketch_name}.png), all inside this one
+                folder.
+    """
+    import matplotlib.pyplot as plt
+
+    sketch_name = os.path.splitext(os.path.basename(svg_path))[0]
+    real_trajectories = load_trajectories(traj_path)
+    object_names = list(real_trajectories.keys())
+
+    object_data = {}
+    for name in object_names:
+        points, slices = load_object(name, svg_path, semantic_path)
+        dx_vals, dy_vals = bbox_deltas(real_trajectories[name])
+        unique_points, p2u = deduplicate_points(points, tol=0.35)
+        tri, edges = build_mesh(unique_points)
+        object_data[name] = {
+            "points": points, "slices": slices, "dx": dx_vals, "dy": dy_vals,
+            "unique_points": unique_points, "p2u": p2u, "edges": edges,
+        }
+
+    if frames_dir:
+        os.makedirs(frames_dir, exist_ok=True)
+
+    xmin, xmax, ymin, ymax = 0, 260, 60, 230
+
+    # compute each keyframe's drawing data once, reused for both the combined
+    # strip and the individual per-keyframe images
+    keyframe_lines = []  # list of {name: [(seg_x, seg_y), ...]} per keyframe
+    for kf in range(N_KEYFRAMES):
+        lines_this_kf = {}
+        for name in object_names:
+            od = object_data[name]
+            handles_path = os.path.join(handles_dir, f"qwen_{sketch_name}_{name}_kf{kf}.json")
+
+            if os.path.exists(handles_path):
+                with open(handles_path) as f:
+                    spec = json.load(f)
+                handle_indices = [int(k) for k in spec.keys()]
+                handle_targets = np.array([spec[k] for k in spec.keys()])
+                n_verts = len(od["unique_points"])
+                bad = [i for i in handle_indices if i >= n_verts]
+                if bad:
+                    print(f"  ERROR: {handles_path} has out-of-bounds indices {bad} for '{name}' "
+                          f"({n_verts} mesh vertices) — likely from a DIFFERENT sketch's mesh. "
+                          f"Falling back to translation-only.")
+                    deformed_points = od["points"]
+                    mode = "translation-only (handles file failed validation)"
+                else:
+                    deformed_unique = arap_deform(od["unique_points"], od["edges"],
+                                                   handle_indices, handle_targets, iterations=10)
+                    deformed_points = deformed_unique[od["p2u"]]
+                    mode = "ARAP"
+            else:
+                deformed_points = od["points"]
+                mode = "translation-only (no handles file found)"
+
+            moved = deformed_points + np.array([od["dx"][kf], od["dy"][kf]])
+            lines_this_kf[name] = [moved[start:end] for start, end in od["slices"]]
+
+            print(f"kf{kf} '{name}': {mode}, points_after_move_range="
+                  f"x[{moved[:,0].min():.1f},{moved[:,0].max():.1f}] "
+                  f"y[{moved[:,1].min():.1f},{moved[:,1].max():.1f}]")
+
+        keyframe_lines.append(lines_this_kf)
+
+        if frames_dir:
+            fig_i, ax_i = plt.subplots(figsize=(6, 5.5))
+            for name, segs in lines_this_kf.items():
+                for seg in segs:
+                    ax_i.plot(seg[:, 0], seg[:, 1],
+                              color=OBJECT_COLORS.get(name, DEFAULT_COLOR),
+                              linewidth=OBJECT_LINEWIDTH.get(name, DEFAULT_LINEWIDTH))
+            ax_i.set_xlim(xmin, xmax)
+            ax_i.set_ylim(ymax, ymin)
+            ax_i.set_aspect("equal")
+            ax_i.set_title(f"{sketch_name} — kf{kf}", fontsize=12, fontweight="bold")
+            frame_path = os.path.join(frames_dir, f"kf{kf}.png")
+            fig_i.savefig(frame_path, dpi=140, bbox_inches="tight")
+            plt.close(fig_i)
+            print(f"  wrote {frame_path}")
+
+    # combined strip, same as before
+    fig, axes = plt.subplots(1, N_KEYFRAMES, figsize=(24, 5))
+    for kf in range(N_KEYFRAMES):
+        ax = axes[kf]
+        for name, segs in keyframe_lines[kf].items():
+            for seg in segs:
+                ax.plot(seg[:, 0], seg[:, 1],
+                        color=OBJECT_COLORS.get(name, DEFAULT_COLOR),
+                        linewidth=OBJECT_LINEWIDTH.get(name, DEFAULT_LINEWIDTH))
+        ax.set_xlim(xmin, xmax)
+        ax.set_ylim(ymax, ymin)
+        ax.set_aspect("equal")
+        ax.set_title(f"kf{kf}", fontsize=13, fontweight="bold")
+
+    plt.tight_layout()
+
+    if out_path:
+        plt.savefig(out_path, dpi=140, bbox_inches="tight")
+        print(f"wrote {out_path}")
+
+    if frames_dir:
+        combined_frame_path = os.path.join(frames_dir, f"{sketch_name}.png")
+        plt.savefig(combined_frame_path, dpi=140, bbox_inches="tight")
+        print(f"wrote {combined_frame_path}")
+
+    if not out_path and not frames_dir:
+        print("WARNING: neither out_path nor frames_dir given, combined strip image not saved anywhere")
+
+    plt.close(fig)
+
+
+# =============================================================================
+# CLI — single input: a sketch name or an SVG path. Everything else is
+# derived automatically from the directory conventions used throughout
+# this dataset. Override flags exist for the rare case a path doesn't
+# match convention, but nothing is required beyond the sketch itself.
+# =============================================================================
+
+# Confirmed real paths from this dataset, used as defaults so nothing else
+# needs to be typed per run. If your layout differs, override with the
+# corresponding --*-dir / --*-file flag below.
+SVG_DIR_DEFAULT = "/user/HS400/rk01499/my_scratch/sketch/data/raw/60sketches/svg"
+PROCESSED_DIR_DEFAULT = "/user/HS400/rk01499/my_scratch/sketch/data/processed"
+CAPTION_FILE_DEFAULT = "/user/HS400/rk01499/my_scratch/sketch/data/raw/60sketches/caption.txt"
+MODEL_PATH_DEFAULT = "/user/HS400/rk01499/my_scratch/models/qwen2.5-7b/"
+
+
+def resolve_sketch_paths(sketch, svg_dir, processed_dir, caption_file):
+    """
+    sketch: either a bare sketch name ("dog9") or a path to its SVG
+            ("/path/to/dog9.svg") — either way, everything else (semantic,
+            traj, caption) is derived from the same naming convention used
+            across this dataset: {name}.svg, {name}/{name}_semantic.txt,
+            {name}/{name}_traj.txt, and a lookup in one shared caption.txt.
+    """
+    name = os.path.splitext(os.path.basename(sketch))[0]
+    svg_path = sketch if sketch.endswith(".svg") else os.path.join(svg_dir, f"{name}.svg")
+    semantic_path = os.path.join(processed_dir, name, f"{name}_semantic.txt")
+    traj_path = os.path.join(processed_dir, name, f"{name}_traj.txt")
+
+    missing = [p for p in [svg_path, semantic_path, traj_path, caption_file] if not os.path.exists(p)]
+    if missing:
+        raise SystemExit(
+            f"Could not find these expected files for sketch '{name}':\n  " +
+            "\n  ".join(missing) +
+            "\n\nIf your directory layout differs from the default, pass --svg-dir / "
+            "--processed-dir / --caption-file explicitly."
+        )
+
+    caption = get_caption(caption_file, name)
+    return name, svg_path, semantic_path, traj_path, caption
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        description="Run the full sketch deformation pipeline for one image. "
+                     "The only required input is the sketch — everything else "
+                     "(semantic assignments, trajectory, caption) is looked up "
+                     "automatically from the standard dataset layout.")
+    ap.add_argument("sketch", type=str,
+                     help="sketch name (e.g. 'dog9') or path to its .svg file")
+    ap.add_argument("--model", type=str, default=MODEL_PATH_DEFAULT)
+    ap.add_argument("--svg-dir", type=str, default=SVG_DIR_DEFAULT)
+    ap.add_argument("--processed-dir", type=str, default=PROCESSED_DIR_DEFAULT)
+    ap.add_argument("--caption-file", type=str, default=CAPTION_FILE_DEFAULT)
+    ap.add_argument("--out-dir", type=str, default=".")
+    ap.add_argument("--no-fewshot", action="store_true",
+                     help="disable the dog3 few-shot example in narrate (for A/B comparison)")
+    ap.add_argument("--narrate-temperature", type=float, default=0.6,
+                     help="sampling temperature for the narrate+deform call (default 0.6, raised from the "
+                          "original 0.1 — CONFIRMED that 0.1 caused the model to copy rest-position values "
+                          "verbatim as targets on attempt 1; use this flag to sweep other values)")
+    ap.add_argument("--deform-only", action="store_true",
+                     help="run classify + ONE narrate+deform attempt + render, then STOP — no judge, "
+                          "no retries. Prints cap utilization directly and saves the render, so you can "
+                          "inspect raw generation quality without the judge's assessment as a confound.")
+    args = ap.parse_args()
+
+    name, svg_path, semantic_path, traj_path, caption = resolve_sketch_paths(
+        args.sketch, args.svg_dir, args.processed_dir, args.caption_file)
+    print(f"sketch: {name}")
+    print(f"  svg:      {svg_path}")
+    print(f"  semantic: {semantic_path}")
+    print(f"  traj:     {traj_path}")
+    print(f"  caption:  {caption!r}")
+
+    os.makedirs(args.out_dir, exist_ok=True)
+    json_dir = os.path.join(args.out_dir, "json", name)
+    os.makedirs(json_dir, exist_ok=True)
+    print(f"  json output dir: {json_dir}")
+
+    print("\n########## STEP 1: CLASSIFY ##########")
+    classify_model, classify_tokenizer, classify_device = load_qwen_model(args.model)
+    deformation, arap_objects = run_classify(
+        classify_model, classify_tokenizer, classify_device, caption, semantic_path,
+        os.path.join(json_dir, f"{name}_deformation.json"))
+    classify_model = unload_model(classify_model)
+
+    if arap_objects:
+        import vlm_judge
+
+        temp_dir = os.path.join(args.out_dir, "P_1", name)
+        objects_info = build_objects_info(svg_path, semantic_path, arap_objects)
+        if not objects_info:
+            print("No objects with valid handles found after mesh setup. Nothing to do.")
+            objects_info = None
+
+        # rest joint positions were previously computed once and kept ONLY in memory for the rest
+        # of main()'s lifetime — no file ever recorded them, so a question like "is joint_2's target
+        # actually different from its rest position, or just restating rest" was unanswerable after
+        # a run finished. Saved once per sketch (not per attempt, since rest pose doesn't change
+        # attempt to attempt) so it's always available for exactly this kind of check.
+        if objects_info:
+            rest_joints_dump = {
+                obj_name: {
+                    f"joint_{i}": {"x": float(j[0]), "y": float(j[1]),
+                                   "is_anchor": i == info["anchor_idx"]}
+                    for i, j in enumerate(info["joints"])
+                }
+                for obj_name, info in objects_info.items()
+            }
+            with open(os.path.join(json_dir, f"{name}_rest_joints.json"), "w") as f:
+                json.dump(rest_joints_dump, f, indent=2)
+
+        rest_pose_image_path = os.path.join(json_dir, f"{name}_rest_pose.png")
+        render_rest_pose_multi(arap_objects, svg_path, semantic_path, rest_pose_image_path)
+
+        # preprocessed bbox trajectory data — fixed ground truth, given to the
+        # judge as spatial context for EVERY object (ARAP and TRAJ_ONLY alike),
+        # not something the judge critiques or the generator controls
+        real_trajectories = load_trajectories(traj_path)
+        all_object_names = list(real_trajectories.keys())
+
+        import dino_similarity
+        dino_model, dino_processor = dino_similarity.load_dino_model()
+
+        import clip_score
+        clip_model, clip_processor = clip_score.load_clip_model()
+
+        feedback = None
+        previous_narratives = None      # {obj_name: [5 descriptions]} from the last attempt
+        previous_temp_dir = None      # where the last attempt's rendered kf0..kf4 images live
+        freeze_narrative = False        # only frozen once faithfulness has already passed once
+        consecutive_stagnant = 0        # early-stop if DINOv2 confirms no real change 2 attempts in a row
+        joint_feedback = None           # judge's structured per-joint corrections from the last attempt
+        final_verdict = None
+        winning_attempt = None
+        all_attempts_summary = []
+        # NUMERIC CONTINUITY: every attempt after the first is given the PREVIOUS attempt's actual
+        # numeric targets (baseline_targets) to refine, not just images/prose to reconstruct numbers
+        # from scratch. This applies to EVERY retry, not just a special round after a pass.
+        baseline_targets = None
+        # CONFIRMATION ROUND: when an attempt first passes all three thresholds, don't stop
+        # immediately — run exactly ONE more attempt (which, same as any retry now, gets the
+        # passing attempt's real baseline_targets to refine) to see if it can be beaten, then keep
+        # whichever actually scores higher. The passing attempt is NEVER at risk of being replaced
+        # by something worse — if the confirmation attempt doesn't beat it, the original passing
+        # attempt is kept exactly as if this mechanism didn't exist. Fires ONCE per sketch.
+        first_pass_attempt = None       # attempt number of the FIRST attempt that passed all thresholds
+        first_pass_scores = None        # that attempt's (faithfulness_score, plausibility_score)
+        confirmation_used = False       # True once the one extra confirmation attempt has been consumed
+
+        for attempt in range(1, MAX_RETRIES + 2):  # +2, not +1: room for exactly one confirmation
+                                                     # attempt beyond MAX_RETRIES if the pass happens
+                                                     # on the very last regular attempt
+            if not objects_info:
+                break
+            if attempt > MAX_RETRIES and (first_pass_attempt is None or confirmation_used):
+                # only allowed to exceed MAX_RETRIES for the ONE confirmation attempt — never for an
+                # ordinary failed-retry continuation
+                break
+            label = f"{attempt}/{MAX_RETRIES}" if attempt <= MAX_RETRIES else f"{attempt} (CONFIRMATION, beyond normal {MAX_RETRIES})"
+            print(f"\n########## ATTEMPT {label} ##########")
+
+            attempt_json_dir = os.path.join(json_dir, "attempts", f"attempt_{attempt}")
+            attempt_temp_dir = os.path.join(temp_dir, "attempts", f"attempt_{attempt}")
+            os.makedirs(attempt_json_dir, exist_ok=True)
+
+            # image list: always the rest pose; from attempt 2+, ALSO the
+            # previous attempt's actual rendered keyframes, so Qwen sees
+            # exactly what its last attempt looked like, not just a text
+            # description of it
+            from PIL import Image
+            images = [Image.open(rest_pose_image_path).convert("RGB")]
+            is_retry = attempt > 1
+            if is_retry:
+                images.extend(vlm_judge.load_keyframe_images(previous_temp_dir))
+
+            prompt = build_combined_narrate_deform_prompt(
+                objects_info, caption, previous_narratives=previous_narratives,
+                feedback=feedback, is_retry=is_retry, few_shot=not args.no_fewshot,
+                freeze_narrative=freeze_narrative, joint_feedback=joint_feedback,
+                baseline_targets=baseline_targets)
+            # save the FULL generator prompt too, symmetric with the judge prompt below — otherwise
+            # there's no way to confirm feedback/joint_feedback actually appeared in what Qwen was
+            # shown, only to infer it from whether behavior changed afterward.
+            with open(os.path.join(attempt_json_dir, f"{name}_narrate_deform_prompt.txt"), "w") as f:
+                f.write(prompt)
+
+            print(f"\n---------- STEP 2+3: NARRATE+DEFORM (attempt {attempt}, "
+                  f"{len(images)} image{'s' if len(images) != 1 else ''}"
+                  f"{', narrative FROZEN' if freeze_narrative else ''}) ----------")
+            vlm_model, vlm_processor = vlm_judge.load_vlm("Qwen/Qwen2.5-VL-3B-Instruct")
+            response = run_combined_narrate_deform(vlm_model, vlm_processor, images, prompt,
+                                                    temperature=args.narrate_temperature)
+            # save the RAW pre-parse response unconditionally, before anything downstream can fail
+            # or silently collapse it — previously this text existed only transiently in memory and
+            # was discarded the moment parsing succeeded, so a case like identical coordinates across
+            # every keyframe couldn't be traced back to "did Qwen write that itself" vs "did something
+            # downstream produce it" after the fact. Written to the SAME attempt_json_dir the parsed
+            # outputs already live in, so raw and parsed are side by side for direct comparison.
+            with open(os.path.join(attempt_json_dir, f"{name}_narrate_deform_raw_response.txt"), "w") as f:
+                f.write(response)
+            try:
+                parsed = parse_json_response(response)
+            except (ValueError, json.JSONDecodeError) as e:
+                print(f"FAILED TO PARSE: {e}\nraw: {response}")
+                vlm_model = unload_model(vlm_model)
+                feedback = "the previous attempt's output could not be parsed; produce valid JSON in the exact requested format"
+                all_attempts_summary.append({"attempt": attempt, "plausibility_score": None, "note": "narrate+deform parse failed"})
+                continue
+
+            narratives_this_attempt, deform_outputs_this_attempt, cap_utilization_this_attempt = apply_deform_clip_and_write(
+                parsed, objects_info, attempt_json_dir, name,
+                frozen_narratives=previous_narratives if freeze_narrative else None)
+            with open(os.path.join(attempt_json_dir, f"{name}_narratives.json"), "w") as f:
+                json.dump(narratives_this_attempt, f, indent=2)
+
+            # print each ARAP object's ACTUAL joint targets per keyframe — this is the real
+            # signal for "did deformation happen", unlike points_after_move_range in the render
+            # log below, which is the whole object's bbox and can stay constant even when a
+            # small joint (e.g. a hand) moves substantially, since the head/torso/limb extremes
+            # usually dominate the bbox regardless of hand position.
+            print(f"\n---------- attempt {attempt}: actual joint targets per keyframe ----------")
+            for obj_name, obj_targets in deform_outputs_this_attempt.items():
+                print(f"  '{obj_name}':")
+                for kf in range(N_KEYFRAMES):
+                    kf_key = f"kf{kf}"
+                    if kf_key in obj_targets:
+                        print(f"    {kf_key}: {obj_targets[kf_key]}")
+
+            print(f"\n---------- STEP 4: RENDER (attempt {attempt}, no Qwen) ----------")
+            run_render(attempt_json_dir, svg_path, semantic_path, traj_path, frames_dir=attempt_temp_dir)
+
+            if args.deform_only:
+                print(f"\n########## --deform-only: STOPPING after attempt 1, no judge ##########")
+                print(f"cap_utilization (raw, unfiltered by any threshold):")
+                for obj, frac in (cap_utilization_this_attempt or {}).items():
+                    print(f"  {obj}: {frac*100:.1f}% of allowed movement used")
+                print(f"\nInspect the actual render directly at: {attempt_temp_dir}")
+                print(f"(kf0.png ... kf4.png, plus the combined strip)")
+                sys.exit(0)
+
+            stagnation_result = None
+            if previous_temp_dir:
+                print(f"\n---------- STAGNATION CHECK (attempt {attempt} vs attempt {attempt - 1}) ----------")
+                prev_dino_images = vlm_judge.load_keyframe_images(previous_temp_dir)
+                curr_dino_images = vlm_judge.load_keyframe_images(attempt_temp_dir)
+                stagnation_result = dino_similarity.stagnation_score(
+                    dino_model, dino_processor, prev_dino_images, curr_dino_images)
+                stagnant = dino_similarity.is_stagnant(stagnation_result)
+                print(f"mean attempt-to-attempt similarity: {stagnation_result['mean_similarity']:.4f} "
+                      f"({'STAGNANT' if stagnant else 'changed'})")
+                consecutive_stagnant = consecutive_stagnant + 1 if stagnant else 0
+
+            print(f"\n---------- TEMPORAL CONSISTENCY (attempt {attempt}, diagnostic only) ----------")
+            temporal_images = vlm_judge.load_keyframe_images(attempt_temp_dir)
+            temporal_result = dino_similarity.temporal_consistency(dino_model, dino_processor, temporal_images)
+
+            clip_result = None
+            if caption:
+                print(f"\n---------- CLIP SCORE (attempt {attempt}) ----------")
+                clip_images = vlm_judge.load_keyframe_images(attempt_temp_dir)
+                clip_result = clip_score.compute_sequence_clip_scores(clip_model, clip_processor, clip_images, caption)
+
+            print(f"\n---------- STEP 5: JUDGE (attempt {attempt}, images + joint/bbox coordinates) ----------")
+            # reuse the SAME already-loaded VLM for judging — no reload
+            # needed, since narrate+deform and judge are both Qwen3-VL calls now.
+            # Judge sees: rest pose + this attempt's 5 rendered keyframes
+            # (images), PLUS rest-pose stroke text + joint legend + this
+            # attempt's joint targets + every object's fixed bbox trajectory
+            # + PER-KEYFRAME DEFORMED stroke geometry (text) — the last one
+            # is what target_coords grounding actually anchors against: a
+            # visually-identified region's TRUE coordinate at that specific
+            # keyframe, not its rest-pose coordinate (which is only correct
+            # when a keyframe happens to match rest).
+            judge_images = [Image.open(rest_pose_image_path).convert("RGB")]
+            judge_images.extend(vlm_judge.load_keyframe_images(attempt_temp_dir))
+
+            deformed_geometry_text = build_all_keyframes_deformed_geometry_text(
+                objects_info, deform_outputs_this_attempt)
+            # save this — it's otherwise invisible after the fact. Needed to verify e.g. whether a
+            # judge's target_coords anchor was itself built from stale/frozen coordinates (a real
+            # failure mode: if deform_outputs_this_attempt is frozen across keyframes, this text
+            # will be too, and a judge "fix" anchored to it would just point back at the same stuck
+            # position rather than actually correcting anything).
+            with open(os.path.join(attempt_json_dir, f"{name}_deformed_geometry_text.txt"), "w") as f:
+                f.write(deformed_geometry_text)
+
+            judge_prompt = vlm_judge.build_judge_prompt(
+                name, caption=caption, dino_stagnation=stagnation_result,
+                dino_temporal=temporal_result, clip_scores=clip_result,
+                objects_info=objects_info, deform_outputs=deform_outputs_this_attempt,
+                real_trajectories=real_trajectories, all_object_names=all_object_names,
+                deformed_geometry_text=deformed_geometry_text, narratives=narratives_this_attempt)
+            # save the FULL prompt too, not just the response — otherwise there's no way to see
+            # exactly what the judge was shown (only what it said back), which makes it impossible
+            # to distinguish "the judge reasoned badly" from "the judge was given bad/stale input".
+            with open(os.path.join(attempt_json_dir, f"{name}_judge_prompt.txt"), "w") as f:
+                f.write(judge_prompt)
+            judge_response = vlm_judge.run_judge(vlm_model, vlm_processor, judge_images, judge_prompt)
+            vlm_model = unload_model(vlm_model)
+            # same rationale as the narrate+deform raw response above — save unconditionally, before
+            # parsing, so the judge's literal output is inspectable after the fact even when parsing
+            # succeeds (previously only visible on parse failure, via print, not saved to disk).
+            with open(os.path.join(attempt_json_dir, f"{name}_judge_raw_response.txt"), "w") as f:
+                f.write(judge_response)
+
+            try:
+                verdict = vlm_judge.parse_judge_response(judge_response)
+            except (ValueError, json.JSONDecodeError) as e:
+                print(f"JUDGE FAILED TO PARSE: {e}\nraw: {judge_response}")
+                print("Treating as a failed attempt, retrying without specific feedback.")
+                feedback = "the previous attempt's evaluation could not be parsed; try a clearer, more varied pose progression"
+                previous_narratives = narratives_this_attempt
+                previous_temp_dir = attempt_temp_dir
+                freeze_narrative = False  # unknown state — safest to regenerate rather than assume faithfulness held
+                joint_feedback = None  # verdict didn't parse, so any joint_feedback in it is unusable/unknown — don't carry stale feedback forward
+                all_attempts_summary.append({"attempt": attempt, "plausibility_score": None, "note": "judge parse failed"})
+                continue
+
+            problems = vlm_judge.validate_judge_response(verdict, valid_arap_objects=set(objects_info.keys()))
+            print("\n--- JUDGE VERDICT ---")
+            print(json.dumps(verdict, indent=2))
+            if problems:
+                for p in problems:
+                    print(f"  VALIDATION PROBLEM: {p}")
+
+            with open(os.path.join(attempt_json_dir, f"{name}_judge_verdict.json"), "w") as f:
+                json.dump(verdict, f, indent=2)
+
+            final_verdict = verdict
+            winning_attempt = attempt
+            score = verdict.get("plausibility_score")
+            faith_score = verdict.get("faithfulness_score")
+            quality_score = verdict.get("quality_score")
+            all_attempts_summary.append({"attempt": attempt, "plausibility_score": score,
+                                          "plausibility_notes": verdict.get("plausibility_notes"),
+                                          "faithfulness_score": faith_score,
+                                          "faithfulness_notes": verdict.get("faithfulness_notes"),
+                                          "quality_score": quality_score,
+                                          "quality_notes": verdict.get("quality_notes"),
+                                          "dino_stagnant": dino_similarity.is_stagnant(stagnation_result) if stagnation_result else None})
+
+            plausibility_ok = isinstance(score, (int, float)) and score >= PLAUSIBILITY_THRESHOLD
+            faithfulness_ok = faithfulness_passed(faith_score)
+            quality_ok = isinstance(quality_score, (int, float)) and quality_score >= QUALITY_THRESHOLD
+            print(f"\nplausibility_score = {score} (threshold = {PLAUSIBILITY_THRESHOLD}, "
+                  f"{'PASS' if plausibility_ok else 'FAIL'})")
+            print(f"faithfulness_score = {faith_score} (threshold = {FAITHFULNESS_THRESHOLD}, "
+                  f"{'PASS' if faithfulness_ok else 'FAIL'})")
+            print(f"quality_score = {quality_score} (threshold = {QUALITY_THRESHOLD}, "
+                  f"{'PASS' if quality_ok else 'FAIL'})")
+
+            if plausibility_ok and faithfulness_ok and quality_ok:
+                if first_pass_attempt is None:
+                    # FIRST time passing — don't stop yet. Remember this as the safe fallback, run
+                    # exactly one more attempt to see if it can be beaten, THEN decide.
+                    first_pass_attempt = attempt
+                    first_pass_scores = (faith_score, score)
+                    print(f"Attempt {attempt} passed all thresholds — running ONE confirmation attempt "
+                          f"before finalizing, to see if it can be improved on. If the confirmation "
+                          f"attempt is not better, attempt {attempt} is kept exactly as-is. (It also "
+                          f"gets this attempt's real numeric targets as its baseline, same as any "
+                          f"normal retry now would.)")
+                    previous_narratives = narratives_this_attempt
+                    previous_temp_dir = attempt_temp_dir
+                    baseline_targets = deform_outputs_this_attempt
+                    joint_feedback = vlm_judge.compute_joint_feedback_deltas(
+                        verdict.get("joint_feedback"), deform_outputs_this_attempt)
+                    # feedback stays neutral encouragement, not a correction — this attempt already
+                    # passed, there's nothing specifically "wrong" to fix, just seeing if variation
+                    # produces something even better
+                    feedback = ("This attempt already passed all quality thresholds. This is an "
+                                "OPTIONAL confirmation attempt: try to match or improve on it, but do "
+                                "not discard what is already working.")
+                    freeze_narrative = False
+                    continue  # do NOT break — proceed to the confirmation attempt
+                else:
+                    # this IS the confirmation attempt (first_pass_attempt was already set)
+                    confirmation_used = True
+                    confirmation_scores = (faith_score, score)
+                    if confirmation_scores > first_pass_scores:
+                        print(f"Confirmation attempt {attempt} scored better "
+                              f"(faithfulness={faith_score}, plausibility={score}) than the original "
+                              f"passing attempt {first_pass_attempt} "
+                              f"(faithfulness={first_pass_scores[0]}, plausibility={first_pass_scores[1]}) "
+                              f"— using attempt {attempt} instead.")
+                        winning_attempt = attempt
+                    else:
+                        print(f"Confirmation attempt {attempt} did NOT score better than the original "
+                              f"passing attempt {first_pass_attempt} — keeping attempt {first_pass_attempt} "
+                              f"as originally found, discarding the confirmation attempt.")
+                        winning_attempt = first_pass_attempt
+                    break
+
+            if first_pass_attempt is not None and not confirmation_used:
+                # confirmation attempt FAILED thresholds outright (didn't beat the pass AND didn't
+                # even clear the bar itself) — keep the original passing attempt, don't treat this
+                # as a real failure requiring further retries
+                confirmation_used = True
+                print(f"Confirmation attempt {attempt} did not pass thresholds — keeping the original "
+                      f"passing attempt {first_pass_attempt} as the final result.")
+                winning_attempt = first_pass_attempt
+                break
+
+            if consecutive_stagnant >= 2:
+                print(f"\nDINOv2 confirmed NO real change across {consecutive_stagnant} consecutive attempts "
+                      f"(attempt {attempt} vs {attempt-1}, and {attempt-1} vs {attempt-2}) — further retries "
+                      f"are very unlikely to help. Stopping early and keeping this attempt's result rather "
+                      f"than burning through the remaining {MAX_RETRIES - attempt} attempts.")
+                break
+
+            previous_narratives = narratives_this_attempt
+            previous_temp_dir = attempt_temp_dir
+            # NUMERIC CONTINUITY (universal, every retry): carry this attempt's actual numeric
+            # targets forward as the NEXT attempt's starting point to refine, not just images/prose
+            # to reconstruct numbers from scratch. This is the core of the "attempt N+1 works on
+            # attempt N's real output" redesign — replaces relying purely on visual/textual
+            # reconstruction, which this session repeatedly found unreliable (copy-from-rest,
+            # scalar-collapse, frozen joints).
+            baseline_targets = deform_outputs_this_attempt
+            # carry the judge's structured per-joint corrections into the NEXT
+            # attempt's prompt — empty list is valid (judge found nothing
+            # specific to fix), missing key means coordinate context wasn't
+            # given to build_judge_prompt at all; either way, default to None
+            # so format_joint_feedback_for_object just adds nothing.
+            # compute_joint_feedback_deltas turns the judge's target_coords
+            # into an exact pixel delta by SUBTRACTION against this attempt's
+            # actual joint positions — arithmetic, not model math. Entries
+            # where the judge couldn't ground a target (target_coords null)
+            # are left as delta_px=None and fall back to prose-only feedback.
+            joint_feedback = vlm_judge.compute_joint_feedback_deltas(
+                verdict.get("joint_feedback"), deform_outputs_this_attempt)
+            # freeze the narrative on the NEXT attempt only if faithfulness
+            # already passed THIS attempt — no reason to keep regenerating
+            # a story that's already correct, only the numbers need work
+            freeze_narrative = faithfulness_ok
+
+            if attempt == MAX_RETRIES:
+                print("Below threshold on the final attempt — no retry left, skipping feedback construction.")
+            else:
+                # feedback is now ONE unified sentence describing what's wrong and what needs to
+                # change, instead of pasting plausibility_notes/faithfulness_notes/quality_notes
+                # together as three separately-labeled clauses. The three _notes fields (and the
+                # three scores/thresholds) are UNCHANGED and still drive stopping/freeze logic —
+                # this only changes what prose text gets sent back to the generator as feedback.
+                # overall_verdict is the judge's own synthesized summary (already part of the
+                # schema, previously unused for feedback) — using that instead of splicing notes
+                # avoids asking the model to write three separate critiques when one coherent one
+                # is what the generator actually needs to act on.
+                feedback = verdict.get(
+                    "overall_verdict",
+                    verdict.get("plausibility_notes", "the pose progression needs to look more plausible"))
+
+                # DINOv2 objective override: if the images barely changed from the
+                # previous attempt, say so explicitly and forcefully — this is the
+                # exact failure mode confirmed on real hardware (cannon1 ran all
+                # MAX_RETRIES with no real change), where the judge's own text
+                # critique was never specific enough for Qwen to act on. An
+                # objective embedding-distance number doesn't have that problem.
+                if stagnation_result and dino_similarity.is_stagnant(stagnation_result):
+                    feedback = (f"CRITICAL: your last attempt was measured as nearly IDENTICAL to the one "
+                                f"before it (DINOv2 similarity {stagnation_result['mean_similarity']:.3f}) — "
+                                f"you are NOT making real changes. You MUST produce substantially different "
+                                f"target positions this time, not a superficial rewording. Original feedback: {feedback}")
+
+                print(f"Below threshold — retrying with feedback: {feedback!r} "
+                      f"(narrative will be {'FROZEN' if freeze_narrative else 'regenerated'})")
+                # the line above only ever showed the flat plausibility/faithfulness/quality string —
+                # joint_feedback is a SEPARATE variable also being carried into the next prompt (see
+                # build_combined_narrate_deform_prompt's joint_feedback= argument), and was never
+                # visible in this log even when it had real content. Printing it explicitly here so
+                # it's possible to verify from the log whether per-joint correction is actually
+                # happening on a given attempt, instead of having to infer it from final results.
+                if joint_feedback:
+                    grounded = [f for f in joint_feedback if f.get("delta_px") is not None]
+                    ungrounded = [f for f in joint_feedback if f.get("delta_px") is None]
+                    print(f"  joint_feedback being sent to next attempt: {len(grounded)} grounded "
+                          f"(with computed delta_px), {len(ungrounded)} ungrounded")
+                    for f in joint_feedback:
+                        tag = "GROUNDED" if f.get("delta_px") is not None else "UNGROUNDED"
+                        print(f"    [{tag}] {f.get('object')}.joint_{f.get('joint')} @ kf{f.get('keyframe')}: "
+                              f"{f.get('issue')} (delta_px={f.get('delta_px')})")
+                else:
+                    print("  joint_feedback being sent to next attempt: none (empty or not returned by judge)")
+
+        else:
+            print(f"\nReached MAX_RETRIES ({MAX_RETRIES}) without meeting both thresholds. "
+                  f"Using the last attempt's result.")
+
+        # print a compact table so the score progression across attempts is
+        # visible in one place, not just scattered through the full log
+        print("\n########## ATTEMPT SUMMARY ##########")
+        for a in all_attempts_summary:
+            print(f"  attempt {a['attempt']}: plausibility={a.get('plausibility_score')} "
+                  f"faithfulness={a.get('faithfulness_score')} quality={a.get('quality_score')} "
+                  f"dino_stagnant={a.get('dino_stagnant')} "
+                  f"— {a.get('plausibility_notes') or a.get('note', '')}")
+
+        if winning_attempt:
+            import shutil
+            winning_json = os.path.join(json_dir, "attempts", f"attempt_{winning_attempt}")
+            winning_temp = os.path.join(temp_dir, "attempts", f"attempt_{winning_attempt}")
+            for f in os.listdir(winning_json):
+                shutil.copy2(os.path.join(winning_json, f), os.path.join(json_dir, f))
+            for f in os.listdir(winning_temp):
+                src = os.path.join(winning_temp, f)
+                if os.path.isfile(src):
+                    shutil.copy2(src, os.path.join(temp_dir, f))
+            print(f"\ncopied winning attempt ({winning_attempt}) to the top-level "
+                  f"json/{name}/ and P_1/{name}/ locations")
+            print(f"all {len(all_attempts_summary)} attempts preserved under "
+                  f"json/{name}/attempts/ and P_1/{name}/attempts/ for comparison")
+    else:
+        print("\nNo ARAP objects — skipping narrate/deform/judge entirely.")
+        temp_dir = os.path.join(args.out_dir, "P_1", name)
+        print("\n########## RENDER (no Qwen) ##########")
+        run_render(json_dir, svg_path, semantic_path, traj_path, frames_dir=temp_dir)
+
+
+if __name__ == "__main__":
+    main()

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jingyu Liu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.