diff --git a/2022 ML/10 Attack/Attacks-in-NLP-Draft.pdf b/2022 ML/10 Attack/Attacks-in-NLP-Draft.pdf
new file mode 100644
index 0000000..16b39c8
Binary files /dev/null and b/2022 ML/10 Attack/Attacks-in-NLP-Draft.pdf differ
diff --git a/2022 ML/10 Attack/ML2022_hw10.ipynb b/2022 ML/10 Attack/ML2022_hw10.ipynb
new file mode 100644
index 0000000..586314c
--- /dev/null
+++ b/2022 ML/10 Attack/ML2022_hw10.ipynb	
@@ -0,0 +1,987 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Q-n2e0BkhEKS"
+      },
+      "source": [
+        "# **Homework 10 - Adversarial Attack**\n",
+        "\n",
+        "Slides: https://reurl.cc/7DDxnD\n",
+        "\n",
+        "Contact: ntu-ml-2022spring-ta@googlegroups.com\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "9RX7iRXrhMA_"
+      },
+      "source": [
+        "## Enviroment & Download\n",
+        "\n",
+        "We make use of [pytorchcv](https://pypi.org/project/pytorchcv/) to obtain CIFAR-10 pretrained model, so we need to set up the enviroment first. We also need to download the data (200 images) which we want to attack."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "d4Lw7urignqP",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "338b4e04-9d1d-47c4-d8e5-81eb45705c5c"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: pytorchcv in /usr/local/lib/python3.7/dist-packages (0.0.67)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from pytorchcv) (1.21.6)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from pytorchcv) (2.23.0)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->pytorchcv) (2021.10.8)\n",
+            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->pytorchcv) (1.24.3)\n",
+            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->pytorchcv) (2.10)\n",
+            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->pytorchcv) (3.0.4)\n",
+            "Requirement already satisfied: imgaug in /usr/local/lib/python3.7/dist-packages (0.2.9)\n",
+            "Requirement already satisfied: Shapely in /usr/local/lib/python3.7/dist-packages (from imgaug) (1.8.1.post1)\n",
+            "Requirement already satisfied: scikit-image>=0.11.0 in /usr/local/lib/python3.7/dist-packages (from imgaug) (0.18.3)\n",
+            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from imgaug) (1.4.1)\n",
+            "Requirement already satisfied: imageio in /usr/local/lib/python3.7/dist-packages (from imgaug) (2.4.1)\n",
+            "Requirement already satisfied: opencv-python in /usr/local/lib/python3.7/dist-packages (from imgaug) (4.1.2.30)\n",
+            "Requirement already satisfied: numpy>=1.15.0 in /usr/local/lib/python3.7/dist-packages (from imgaug) (1.21.6)\n",
+            "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from imgaug) (1.15.0)\n",
+            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from imgaug) (3.2.2)\n",
+            "Requirement already satisfied: Pillow in /usr/local/lib/python3.7/dist-packages (from imgaug) (7.1.2)\n",
+            "Requirement already satisfied: networkx>=2.0 in /usr/local/lib/python3.7/dist-packages (from scikit-image>=0.11.0->imgaug) (2.6.3)\n",
+            "Requirement already satisfied: tifffile>=2019.7.26 in /usr/local/lib/python3.7/dist-packages (from scikit-image>=0.11.0->imgaug) (2021.11.2)\n",
+            "Requirement already satisfied: PyWavelets>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from scikit-image>=0.11.0->imgaug) (1.3.0)\n",
+            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->imgaug) (0.11.0)\n",
+            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->imgaug) (2.8.2)\n",
+            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->imgaug) (3.0.8)\n",
+            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->imgaug) (1.4.2)\n",
+            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib->imgaug) (4.2.0)\n",
+            "--2022-05-05 10:04:02--  https://github.com/DanielLin94144/ML-attack-dataset/files/8167812/data.zip\n",
+            "Resolving github.com (github.com)... 140.82.112.3\n",
+            "Connecting to github.com (github.com)|140.82.112.3|:443... connected.\n",
+            "HTTP request sent, awaiting response... 302 Found\n",
+            "Location: https://objects.githubusercontent.com/github-production-repository-file-5c1aeb/465178219/8167812?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20220505%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20220505T100402Z&X-Amz-Expires=300&X-Amz-Signature=adae54285b1981edafb88d62ad8c4adaaee27ac427e2068e011b6b968b5eedbb&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=465178219&response-content-disposition=attachment%3Bfilename%3Ddata.zip&response-content-type=application%2Fzip [following]\n",
+            "--2022-05-05 10:04:02--  https://objects.githubusercontent.com/github-production-repository-file-5c1aeb/465178219/8167812?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20220505%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20220505T100402Z&X-Amz-Expires=300&X-Amz-Signature=adae54285b1981edafb88d62ad8c4adaaee27ac427e2068e011b6b968b5eedbb&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=465178219&response-content-disposition=attachment%3Bfilename%3Ddata.zip&response-content-type=application%2Fzip\n",
+            "Resolving objects.githubusercontent.com (objects.githubusercontent.com)... 185.199.108.133, 185.199.110.133, 185.199.109.133, ...\n",
+            "Connecting to objects.githubusercontent.com (objects.githubusercontent.com)|185.199.108.133|:443... connected.\n",
+            "HTTP request sent, awaiting response... 200 OK\n",
+            "Length: 489509 (478K) [application/zip]\n",
+            "Saving to: ‘data.zip’\n",
+            "\n",
+            "data.zip            100%[===================>] 478.04K  --.-KB/s    in 0.09s   \n",
+            "\n",
+            "2022-05-05 10:04:02 (4.94 MB/s) - ‘data.zip’ saved [489509/489509]\n",
+            "\n",
+            "Archive:  ./data.zip\n",
+            "replace data/deer/deer13.png? [y]es, [n]o, [A]ll, [N]one, [r]ename: A\n",
+            " extracting: data/deer/deer13.png    \n",
+            " extracting: data/deer/deer6.png     \n",
+            " extracting: data/deer/deer11.png    \n",
+            " extracting: data/deer/deer2.png     \n",
+            " extracting: data/deer/deer10.png    \n",
+            " extracting: data/deer/deer16.png    \n",
+            " extracting: data/deer/deer9.png     \n",
+            " extracting: data/deer/deer20.png    \n",
+            " extracting: data/deer/deer15.png    \n",
+            " extracting: data/deer/deer19.png    \n",
+            " extracting: data/deer/deer5.png     \n",
+            " extracting: data/deer/deer14.png    \n",
+            " extracting: data/deer/deer4.png     \n",
+            " extracting: data/deer/deer8.png     \n",
+            " extracting: data/deer/deer12.png    \n",
+            " extracting: data/deer/deer1.png     \n",
+            " extracting: data/deer/deer7.png     \n",
+            " extracting: data/deer/deer17.png    \n",
+            " extracting: data/deer/deer18.png    \n",
+            " extracting: data/deer/deer3.png     \n",
+            " extracting: data/horse/horse9.png   \n",
+            " extracting: data/horse/horse1.png   \n",
+            " extracting: data/horse/horse16.png  \n",
+            " extracting: data/horse/horse15.png  \n",
+            " extracting: data/horse/horse19.png  \n",
+            " extracting: data/horse/horse14.png  \n",
+            " extracting: data/horse/horse10.png  \n",
+            " extracting: data/horse/horse7.png   \n",
+            " extracting: data/horse/horse2.png   \n",
+            " extracting: data/horse/horse6.png   \n",
+            " extracting: data/horse/horse20.png  \n",
+            " extracting: data/horse/horse5.png   \n",
+            " extracting: data/horse/horse18.png  \n",
+            " extracting: data/horse/horse12.png  \n",
+            " extracting: data/horse/horse13.png  \n",
+            " extracting: data/horse/horse17.png  \n",
+            " extracting: data/horse/horse4.png   \n",
+            " extracting: data/horse/horse11.png  \n",
+            " extracting: data/horse/horse8.png   \n",
+            " extracting: data/horse/horse3.png   \n",
+            " extracting: data/ship/ship10.png    \n",
+            " extracting: data/ship/ship14.png    \n",
+            " extracting: data/ship/ship9.png     \n",
+            " extracting: data/ship/ship20.png    \n",
+            " extracting: data/ship/ship5.png     \n",
+            " extracting: data/ship/ship8.png     \n",
+            " extracting: data/ship/ship19.png    \n",
+            " extracting: data/ship/ship16.png    \n",
+            " extracting: data/ship/ship13.png    \n",
+            " extracting: data/ship/ship6.png     \n",
+            " extracting: data/ship/ship17.png    \n",
+            " extracting: data/ship/ship1.png     \n",
+            " extracting: data/ship/ship12.png    \n",
+            " extracting: data/ship/ship2.png     \n",
+            " extracting: data/ship/ship3.png     \n",
+            " extracting: data/ship/ship15.png    \n",
+            " extracting: data/ship/ship4.png     \n",
+            " extracting: data/ship/ship7.png     \n",
+            " extracting: data/ship/ship11.png    \n",
+            " extracting: data/ship/ship18.png    \n",
+            " extracting: data/frog/frog10.png    \n",
+            " extracting: data/frog/frog4.png     \n",
+            " extracting: data/frog/frog5.png     \n",
+            " extracting: data/frog/frog20.png    \n",
+            " extracting: data/frog/frog15.png    \n",
+            " extracting: data/frog/frog3.png     \n",
+            " extracting: data/frog/frog1.png     \n",
+            " extracting: data/frog/frog14.png    \n",
+            " extracting: data/frog/frog2.png     \n",
+            " extracting: data/frog/frog19.png    \n",
+            " extracting: data/frog/frog7.png     \n",
+            " extracting: data/frog/frog11.png    \n",
+            " extracting: data/frog/frog17.png    \n",
+            " extracting: data/frog/frog18.png    \n",
+            " extracting: data/frog/frog12.png    \n",
+            " extracting: data/frog/frog16.png    \n",
+            " extracting: data/frog/frog8.png     \n",
+            " extracting: data/frog/frog13.png    \n",
+            " extracting: data/frog/frog6.png     \n",
+            " extracting: data/frog/frog9.png     \n",
+            " extracting: data/airplane/airplane3.png  \n",
+            " extracting: data/airplane/airplane4.png  \n",
+            " extracting: data/airplane/airplane2.png  \n",
+            " extracting: data/airplane/airplane9.png  \n",
+            " extracting: data/airplane/airplane20.png  \n",
+            " extracting: data/airplane/airplane18.png  \n",
+            " extracting: data/airplane/airplane19.png  \n",
+            " extracting: data/airplane/airplane10.png  \n",
+            " extracting: data/airplane/airplane6.png  \n",
+            " extracting: data/airplane/airplane13.png  \n",
+            " extracting: data/airplane/airplane16.png  \n",
+            " extracting: data/airplane/airplane14.png  \n",
+            " extracting: data/airplane/airplane11.png  \n",
+            " extracting: data/airplane/airplane1.png  \n",
+            " extracting: data/airplane/airplane17.png  \n",
+            " extracting: data/airplane/airplane7.png  \n",
+            " extracting: data/airplane/airplane15.png  \n",
+            " extracting: data/airplane/airplane5.png  \n",
+            " extracting: data/airplane/airplane8.png  \n",
+            " extracting: data/airplane/airplane12.png  \n",
+            " extracting: data/bird/bird9.png     \n",
+            " extracting: data/bird/bird12.png    \n",
+            " extracting: data/bird/bird10.png    \n",
+            " extracting: data/bird/bird11.png    \n",
+            " extracting: data/bird/bird5.png     \n",
+            " extracting: data/bird/bird8.png     \n",
+            " extracting: data/bird/bird4.png     \n",
+            " extracting: data/bird/bird3.png     \n",
+            " extracting: data/bird/bird7.png     \n",
+            " extracting: data/bird/bird18.png    \n",
+            " extracting: data/bird/bird14.png    \n",
+            " extracting: data/bird/bird13.png    \n",
+            " extracting: data/bird/bird2.png     \n",
+            " extracting: data/bird/bird15.png    \n",
+            " extracting: data/bird/bird17.png    \n",
+            " extracting: data/bird/bird19.png    \n",
+            " extracting: data/bird/bird16.png    \n",
+            " extracting: data/bird/bird6.png     \n",
+            " extracting: data/bird/bird20.png    \n",
+            " extracting: data/bird/bird1.png     \n",
+            " extracting: data/cat/cat6.png       \n",
+            " extracting: data/cat/cat1.png       \n",
+            " extracting: data/cat/cat7.png       \n",
+            " extracting: data/cat/cat19.png      \n",
+            " extracting: data/cat/cat5.png       \n",
+            " extracting: data/cat/cat9.png       \n",
+            " extracting: data/cat/cat17.png      \n",
+            " extracting: data/cat/cat2.png       \n",
+            " extracting: data/cat/cat16.png      \n",
+            " extracting: data/cat/cat10.png      \n",
+            " extracting: data/cat/cat4.png       \n",
+            " extracting: data/cat/cat18.png      \n",
+            " extracting: data/cat/cat13.png      \n",
+            " extracting: data/cat/cat11.png      \n",
+            " extracting: data/cat/cat20.png      \n",
+            " extracting: data/cat/cat15.png      \n",
+            " extracting: data/cat/cat8.png       \n",
+            " extracting: data/cat/cat14.png      \n",
+            " extracting: data/cat/cat3.png       \n",
+            " extracting: data/cat/cat12.png      \n",
+            " extracting: data/automobile/automobile17.png  \n",
+            " extracting: data/automobile/automobile11.png  \n",
+            " extracting: data/automobile/automobile5.png  \n",
+            " extracting: data/automobile/automobile10.png  \n",
+            " extracting: data/automobile/automobile20.png  \n",
+            " extracting: data/automobile/automobile2.png  \n",
+            " extracting: data/automobile/automobile6.png  \n",
+            " extracting: data/automobile/automobile1.png  \n",
+            " extracting: data/automobile/automobile19.png  \n",
+            " extracting: data/automobile/automobile7.png  \n",
+            " extracting: data/automobile/automobile16.png  \n",
+            " extracting: data/automobile/automobile3.png  \n",
+            " extracting: data/automobile/automobile14.png  \n",
+            " extracting: data/automobile/automobile12.png  \n",
+            " extracting: data/automobile/automobile9.png  \n",
+            " extracting: data/automobile/automobile4.png  \n",
+            " extracting: data/automobile/automobile8.png  \n",
+            " extracting: data/automobile/automobile13.png  \n",
+            " extracting: data/automobile/automobile18.png  \n",
+            " extracting: data/automobile/automobile15.png  \n",
+            " extracting: data/dog/dog9.png       \n",
+            " extracting: data/dog/dog2.png       \n",
+            " extracting: data/dog/dog15.png      \n",
+            " extracting: data/dog/dog8.png       \n",
+            " extracting: data/dog/dog3.png       \n",
+            " extracting: data/dog/dog19.png      \n",
+            " extracting: data/dog/dog12.png      \n",
+            " extracting: data/dog/dog7.png       \n",
+            " extracting: data/dog/dog17.png      \n",
+            " extracting: data/dog/dog11.png      \n",
+            " extracting: data/dog/dog16.png      \n",
+            " extracting: data/dog/dog20.png      \n",
+            " extracting: data/dog/dog4.png       \n",
+            " extracting: data/dog/dog5.png       \n",
+            " extracting: data/dog/dog14.png      \n",
+            " extracting: data/dog/dog18.png      \n",
+            " extracting: data/dog/dog10.png      \n",
+            " extracting: data/dog/dog1.png       \n",
+            " extracting: data/dog/dog13.png      \n",
+            " extracting: data/dog/dog6.png       \n",
+            " extracting: data/truck/truck1.png   \n",
+            " extracting: data/truck/truck18.png  \n",
+            " extracting: data/truck/truck9.png   \n",
+            " extracting: data/truck/truck4.png   \n",
+            " extracting: data/truck/truck14.png  \n",
+            " extracting: data/truck/truck8.png   \n",
+            " extracting: data/truck/truck12.png  \n",
+            " extracting: data/truck/truck15.png  \n",
+            " extracting: data/truck/truck2.png   \n",
+            " extracting: data/truck/truck5.png   \n",
+            " extracting: data/truck/truck3.png   \n",
+            " extracting: data/truck/truck10.png  \n",
+            " extracting: data/truck/truck17.png  \n",
+            " extracting: data/truck/truck20.png  \n",
+            " extracting: data/truck/truck19.png  \n",
+            " extracting: data/truck/truck13.png  \n",
+            " extracting: data/truck/truck7.png   \n",
+            " extracting: data/truck/truck6.png   \n",
+            "  inflating: data/truck/truck16.png  \n",
+            " extracting: data/truck/truck11.png  \n"
+          ]
+        }
+      ],
+      "source": [
+        "# set up environment\n",
+        "!pip install pytorchcv\n",
+        "!pip install imgaug\n",
+        "\n",
+        "# download\n",
+        "!wget https://github.com/DanielLin94144/ML-attack-dataset/files/8167812/data.zip\n",
+        "\n",
+        "# unzip\n",
+        "!unzip ./data.zip\n",
+        "!rm ./data.zip"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "\n",
+        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+        "batch_size = 8"
+      ],
+      "metadata": {
+        "id": "5inbFx_alYjw"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "hkQQf0l1hbBs"
+      },
+      "source": [
+        "## Global Settings \n",
+        "#### **[NOTE]**: Don't change the settings here, or your generated image might not meet the constraint.\n",
+        "* $\\epsilon$ is fixed to be 8. But on **Data section**, we will first apply transforms on raw pixel value (0-255 scale) **by ToTensor (to 0-1 scale)** and then **Normalize (subtract mean divide std)**. $\\epsilon$ should be set to $\\frac{8}{255 * std}$ during attack.\n",
+        "\n",
+        "* Explaination (optional)\n",
+        "    * Denote the first pixel of original image as $p$, and the first pixel of adversarial image as $a$.\n",
+        "    * The $\\epsilon$ constraints tell us $\\left| p-a \\right| <= 8$.\n",
+        "    * ToTensor() can be seen as a function where $T(x) = x/255$.\n",
+        "    * Normalize() can be seen as a function where $N(x) = (x-mean)/std$ where $mean$ and $std$ are constants.\n",
+        "    * After applying ToTensor() and Normalize() on $p$ and $a$, the constraint becomes $\\left| N(T(p))-N(T(a)) \\right| = \\left| \\frac{\\frac{p}{255}-mean}{std}-\\frac{\\frac{a}{255}-mean}{std} \\right| = \\frac{1}{255 * std} \\left| p-a \\right| <= \\frac{8}{255 * std}.$\n",
+        "    * So, we should set $\\epsilon$ to be $\\frac{8}{255 * std}$ after ToTensor() and Normalize()."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ACghc_tsg2vE"
+      },
+      "outputs": [],
+      "source": [
+        "# the mean and std are the calculated statistics from cifar_10 dataset\n",
+        "cifar_10_mean = (0.491, 0.482, 0.447) # mean for the three channels of cifar_10 images\n",
+        "cifar_10_std = (0.202, 0.199, 0.201) # std for the three channels of cifar_10 images\n",
+        "\n",
+        "# convert mean and std to 3-dimensional tensors for future operations\n",
+        "mean = torch.tensor(cifar_10_mean).to(device).view(3, 1, 1)\n",
+        "std = torch.tensor(cifar_10_std).to(device).view(3, 1, 1)\n",
+        "\n",
+        "epsilon = 8/255/std"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "root = './data' # directory for storing benign images\n",
+        "# benign images: images which do not contain adversarial perturbations\n",
+        "# adversarial images: images which include adversarial perturbations"
+      ],
+      "metadata": {
+        "id": "uO8f0NmtlM63"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lhBJBAlKherZ"
+      },
+      "source": [
+        "## Data\n",
+        "\n",
+        "Construct dataset and dataloader from root directory. Note that we store the filename of each image for future usage."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "VXpRAHz0hkDt",
+        "outputId": "7821e9f3-aa8b-4eed-ce82-fbece547da74"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "number of images = 200\n"
+          ]
+        }
+      ],
+      "source": [
+        "import os\n",
+        "import glob\n",
+        "import shutil\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "from torchvision.transforms import transforms\n",
+        "from torch.utils.data import Dataset, DataLoader\n",
+        "\n",
+        "transform = transforms.Compose([\n",
+        "    transforms.ToTensor(),\n",
+        "    transforms.Normalize(cifar_10_mean, cifar_10_std)\n",
+        "])\n",
+        "\n",
+        "class AdvDataset(Dataset):\n",
+        "    def __init__(self, data_dir, transform):\n",
+        "        self.images = []\n",
+        "        self.labels = []\n",
+        "        self.names = []\n",
+        "        '''\n",
+        "        data_dir\n",
+        "        ├── class_dir\n",
+        "        │   ├── class1.png\n",
+        "        │   ├── ...\n",
+        "        │   ├── class20.png\n",
+        "        '''\n",
+        "        for i, class_dir in enumerate(sorted(glob.glob(f'{data_dir}/*'))):\n",
+        "            images = sorted(glob.glob(f'{class_dir}/*'))\n",
+        "            self.images += images\n",
+        "            self.labels += ([i] * len(images))\n",
+        "            self.names += [os.path.relpath(imgs, data_dir) for imgs in images]\n",
+        "        self.transform = transform\n",
+        "    def __getitem__(self, idx):\n",
+        "        image = self.transform(Image.open(self.images[idx]))\n",
+        "        label = self.labels[idx]\n",
+        "        return image, label\n",
+        "    def __getname__(self):\n",
+        "        return self.names\n",
+        "    def __len__(self):\n",
+        "        return len(self.images)\n",
+        "\n",
+        "adv_set = AdvDataset(root, transform=transform)\n",
+        "adv_names = adv_set.__getname__()\n",
+        "adv_loader = DataLoader(adv_set, batch_size=batch_size, shuffle=False)\n",
+        "\n",
+        "print(f'number of images = {adv_set.__len__()}')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "LnszlTsYrTQZ"
+      },
+      "source": [
+        "## Utils -- Benign Images Evaluation"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "5c_zZLzkrceE"
+      },
+      "outputs": [],
+      "source": [
+        "# to evaluate the performance of model on benign images\n",
+        "def epoch_benign(model, loader, loss_fn):\n",
+        "    model.eval()\n",
+        "    train_acc, train_loss = 0.0, 0.0\n",
+        "    for x, y in loader:\n",
+        "        x, y = x.to(device), y.to(device)\n",
+        "        yp = model(x)\n",
+        "        loss = loss_fn(yp, y)\n",
+        "        train_acc += (yp.argmax(dim=1) == y).sum().item()\n",
+        "        train_loss += loss.item() * x.shape[0]\n",
+        "    return train_acc / len(loader.dataset), train_loss / len(loader.dataset)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_YJxK7YehqQy"
+      },
+      "source": [
+        "## Utils -- Attack Algorithm"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "F_1wKfKyhrQW"
+      },
+      "outputs": [],
+      "source": [
+        "# perform fgsm attack\n",
+        "def fgsm(model, x, y, loss_fn, epsilon=epsilon):\n",
+        "    x_adv = x.detach().clone() # initialize x_adv as original benign image x\n",
+        "    x_adv.requires_grad = True # need to obtain gradient of x_adv, thus set required grad\n",
+        "    loss = loss_fn(model(x_adv), y) # calculate loss\n",
+        "    loss.backward() # calculate gradient\n",
+        "    # fgsm: use gradient ascent on x_adv to maximize loss\n",
+        "    grad = x_adv.grad.detach()\n",
+        "    x_adv = x_adv + epsilon * grad.sign()\n",
+        "    return x_adv\n",
+        "\n",
+        "# alpha and num_iter can be decided by yourself\n",
+        "alpha = 0.8/255/std\n",
+        "def ifgsm(model, x, y, loss_fn, epsilon=epsilon, alpha=alpha, num_iter=20):\n",
+        "    x_adv = x\n",
+        "    # write a loop of num_iter to represent the iterative times\n",
+        "    for i in range(num_iter):\n",
+        "        # x_adv = fgsm(model, x_adv, y, loss_fn, alpha) # call fgsm with (epsilon = alpha) to obtain new x_adv\n",
+        "        x_adv = x_adv.detach().clone()\n",
+        "        x_adv.requires_grad = True # need to obtain gradient of x_adv, thus set required grad\n",
+        "        loss = loss_fn(model(x_adv), y) # calculate loss\n",
+        "        loss.backward() # calculate gradient\n",
+        "        # fgsm: use gradient ascent on x_adv to maximize loss\n",
+        "        grad = x_adv.grad.detach()\n",
+        "        x_adv = x_adv + alpha * grad.sign()\n",
+        "\n",
+        "        x_adv = torch.max(torch.min(x_adv, x+epsilon), x-epsilon) # clip new x_adv back to [x-epsilon, x+epsilon]\n",
+        "    return x_adv\n",
+        "\n",
+        "def mifgsm(model, x, y, loss_fn, epsilon=epsilon, alpha=alpha, num_iter=20, decay=1.0):\n",
+        "    x_adv = x\n",
+        "    # initialze momentum tensor\n",
+        "    momentum = torch.zeros_like(x).detach().to(device)\n",
+        "    # write a loop of num_iter to represent the iterative times\n",
+        "    for i in range(num_iter):\n",
+        "        x_adv = x_adv.detach().clone()\n",
+        "        x_adv.requires_grad = True # need to obtain gradient of x_adv, thus set required grad\n",
+        "        loss = loss_fn(model(x_adv), y) # calculate loss\n",
+        "        loss.backward() # calculate gradient\n",
+        "        # TODO: Momentum calculation\n",
+        "        # grad = .....\n",
+        "        x_adv = x_adv + alpha * grad.sign()\n",
+        "        x_adv = torch.max(torch.min(x_adv, x+epsilon), x-epsilon) # clip new x_adv back to [x-epsilon, x+epsilon]\n",
+        "    return x_adv"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fYCEQwmcrmH6"
+      },
+      "source": [
+        "## Utils -- Attack\n",
+        "* Recall\n",
+        "  * ToTensor() can be seen as a function where $T(x) = x/255$.\n",
+        "  * Normalize() can be seen as a function where $N(x) = (x-mean)/std$ where $mean$ and $std$ are constants.\n",
+        "\n",
+        "* Inverse function\n",
+        "  * Inverse Normalize() can be seen as a function where $N^{-1}(x) = x*std+mean$ where $mean$ and $std$ are constants.\n",
+        "  * Inverse ToTensor() can be seen as a function where $T^{-1}(x) = x*255$.\n",
+        "\n",
+        "* Special Noted\n",
+        "  * ToTensor() will also convert the image from shape (height, width, channel) to shape (channel, height, width), so we also need to transpose the shape back to original shape.\n",
+        "  * Since our dataloader samples a batch of data, what we need here is to transpose **(batch_size, channel, height, width)** back to **(batch_size, height, width, channel)** using np.transpose."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "w5X_9x-7ro_w"
+      },
+      "outputs": [],
+      "source": [
+        "# perform adversarial attack and generate adversarial examples\n",
+        "def gen_adv_examples(model, loader, attack, loss_fn):\n",
+        "    model.eval()\n",
+        "    adv_names = []\n",
+        "    train_acc, train_loss = 0.0, 0.0\n",
+        "    for i, (x, y) in enumerate(loader):\n",
+        "        x, y = x.to(device), y.to(device)\n",
+        "        x_adv = attack(model, x, y, loss_fn) # obtain adversarial examples\n",
+        "        yp = model(x_adv)\n",
+        "        loss = loss_fn(yp, y)\n",
+        "        train_acc += (yp.argmax(dim=1) == y).sum().item()\n",
+        "        train_loss += loss.item() * x.shape[0]\n",
+        "        # store adversarial examples\n",
+        "        adv_ex = ((x_adv) * std + mean).clamp(0, 1) # to 0-1 scale\n",
+        "        adv_ex = (adv_ex * 255).clamp(0, 255) # 0-255 scale\n",
+        "        adv_ex = adv_ex.detach().cpu().data.numpy().round() # round to remove decimal part\n",
+        "        adv_ex = adv_ex.transpose((0, 2, 3, 1)) # transpose (bs, C, H, W) back to (bs, H, W, C)\n",
+        "        adv_examples = adv_ex if i == 0 else np.r_[adv_examples, adv_ex]\n",
+        "    return adv_examples, train_acc / len(loader.dataset), train_loss / len(loader.dataset)\n",
+        "\n",
+        "# create directory which stores adversarial examples\n",
+        "def create_dir(data_dir, adv_dir, adv_examples, adv_names):\n",
+        "    if os.path.exists(adv_dir) is not True:\n",
+        "        _ = shutil.copytree(data_dir, adv_dir)\n",
+        "    for example, name in zip(adv_examples, adv_names):\n",
+        "        im = Image.fromarray(example.astype(np.uint8)) # image pixel value should be unsigned int\n",
+        "        im.save(os.path.join(adv_dir, name))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "r_pMkmPytX3k"
+      },
+      "source": [
+        "## Model / Loss Function\n",
+        "\n",
+        "Model list is available [here](https://github.com/osmr/imgclsmob/blob/master/pytorch/pytorchcv/model_provider.py). Please select models which has _cifar10 suffix. Some of the models cannot be accessed/loaded. You can safely skip them since TA's model will not use those kinds of models."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "jwto8xbPtYzQ",
+        "outputId": "757c344a-be19-4192-ae2b-9ebdcd0b5e33"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading /root/.torch/models/resnet110_cifar10-0369-4d6ca1fc.pth.zip from https://github.com/osmr/imgclsmob/releases/download/v0.0.163/resnet110_cifar10-0369-4d6ca1fc.pth.zip...\n",
+            "benign_acc = 0.95000, benign_loss = 0.22678\n"
+          ]
+        }
+      ],
+      "source": [
+        "from pytorchcv.model_provider import get_model as ptcv_get_model\n",
+        "\n",
+        "model = ptcv_get_model('resnet110_cifar10', pretrained=True).to(device)\n",
+        "loss_fn = nn.CrossEntropyLoss()\n",
+        "\n",
+        "benign_acc, benign_loss = epoch_benign(model, adv_loader, loss_fn)\n",
+        "print(f'benign_acc = {benign_acc:.5f}, benign_loss = {benign_loss:.5f}')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "uslb7GPchtMI"
+      },
+      "source": [
+        "## FGSM"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "wQwPTVUIhuTS",
+        "outputId": "0cc23ace-b799-4025-9883-af7d04c545b1"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "fgsm_acc = 0.59000, fgsm_loss = 2.49272\n"
+          ]
+        }
+      ],
+      "source": [
+        "adv_examples, fgsm_acc, fgsm_loss = gen_adv_examples(model, adv_loader, fgsm, loss_fn)\n",
+        "print(f'fgsm_acc = {fgsm_acc:.5f}, fgsm_loss = {fgsm_loss:.5f}')\n",
+        "\n",
+        "create_dir(root, 'fgsm', adv_examples, adv_names)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "WXw6p0A6shZm"
+      },
+      "source": [
+        "## I-FGSM"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "fUEsT06Iskt2",
+        "outputId": "351a506f-2762-48c9-cad8-9ad54d231a38"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "ifgsm_acc = 0.01000, ifgsm_loss = 17.37436\n"
+          ]
+        }
+      ],
+      "source": [
+        "adv_examples, ifgsm_acc, ifgsm_loss = gen_adv_examples(model, adv_loader, ifgsm, loss_fn)\n",
+        "print(f'ifgsm_acc = {ifgsm_acc:.5f}, ifgsm_loss = {ifgsm_loss:.5f}')\n",
+        "\n",
+        "create_dir(root, 'ifgsm', adv_examples, adv_names)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "DQ-nYkkYexEE"
+      },
+      "source": [
+        "## Compress the images\n",
+        "* Submit the .tgz file to [JudgeBoi](https://ml.ee.ntu.edu.tw/hw10/)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "background_save": true
+        },
+        "id": "ItRo_S0M264N"
+      },
+      "outputs": [],
+      "source": [
+        "%cd fgsm\n",
+        "!tar zcvf ../fgsm.tgz *\n",
+        "%cd ..\n",
+        "\n",
+        "%cd ifgsm\n",
+        "!tar zcvf ../ifgsm.tgz *\n",
+        "%cd .."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Example of Ensemble Attack\n",
+        "* Ensemble multiple models as your proxy model to increase the black-box transferability ([paper](https://arxiv.org/abs/1611.02770))"
+      ],
+      "metadata": {
+        "id": "WLZLbebigCA2"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class ensembleNet(nn.Module):\n",
+        "    def __init__(self, model_names):\n",
+        "        super().__init__()\n",
+        "        self.models = nn.ModuleList([ptcv_get_model(name, pretrained=True) for name in model_names])\n",
+        "        self.softmax = nn.Softmax(dim=1)\n",
+        "    def forward(self, x):\n",
+        "        for i, m in enumerate(self.models):\n",
+        "        # TODO: sum up logits from multiple models  \n",
+        "        # return ensemble_logits"
+      ],
+      "metadata": {
+        "id": "gJcKiQNUgnPQ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "* Construct your ensemble model"
+      ],
+      "metadata": {
+        "id": "yjfJwJKeeaR2"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "model_names = [\n",
+        "    'nin_cifar10',\n",
+        "    'resnet20_cifar10',\n",
+        "    'preresnet20_cifar10'\n",
+        "]\n",
+        "ensemble_model = ensembleNet(model_names).to(device)\n",
+        "ensemble_model.eval()"
+      ],
+      "metadata": {
+        "id": "stYFytogeIzI"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0FM_S886kFd8"
+      },
+      "source": [
+        "## Visualization"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 735
+        },
+        "id": "2FCuE2njkH1O",
+        "outputId": "01c91960-eeec-4d0e-db2a-69e302c426c6"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 720x1440 with 20 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ],
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "classes = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
+        "\n",
+        "plt.figure(figsize=(10, 20))\n",
+        "cnt = 0\n",
+        "for i, cls_name in enumerate(classes):\n",
+        "    path = f'{cls_name}/{cls_name}1.png'\n",
+        "    # benign image\n",
+        "    cnt += 1\n",
+        "    plt.subplot(len(classes), 4, cnt)\n",
+        "    im = Image.open(f'./data/{path}')\n",
+        "    logit = model(transform(im).unsqueeze(0).to(device))[0]\n",
+        "    predict = logit.argmax(-1).item()\n",
+        "    prob = logit.softmax(-1)[predict].item()\n",
+        "    plt.title(f'benign: {cls_name}1.png\\n{classes[predict]}: {prob:.2%}')\n",
+        "    plt.axis('off')\n",
+        "    plt.imshow(np.array(im))\n",
+        "    # adversarial image\n",
+        "    cnt += 1\n",
+        "    plt.subplot(len(classes), 4, cnt)\n",
+        "    im = Image.open(f'./fgsm/{path}')\n",
+        "    logit = model(transform(im).unsqueeze(0).to(device))[0]\n",
+        "    predict = logit.argmax(-1).item()\n",
+        "    prob = logit.softmax(-1)[predict].item()\n",
+        "    plt.title(f'adversarial: {cls_name}1.png\\n{classes[predict]}: {prob:.2%}')\n",
+        "    plt.axis('off')\n",
+        "    plt.imshow(np.array(im))\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Report Question\n",
+        "* Make sure you follow below setup: the source model is \"resnet110_cifar10\", applying the vanilla fgsm attack on `dog2.png`. You can find the perturbed image in `fgsm/dog2.png`."
+      ],
+      "metadata": {
+        "id": "FUmKa02Vmp29"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "8NW8ntCKY3VY",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 577
+        },
+        "outputId": "66db22c7-a1f8-4430-898d-8f33aa5e22a4"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ],
+      "source": [
+        "# original image\n",
+        "path = f'dog/dog2.png'\n",
+        "im = Image.open(f'./data/{path}')\n",
+        "logit = model(transform(im).unsqueeze(0).to(device))[0]\n",
+        "predict = logit.argmax(-1).item()\n",
+        "prob = logit.softmax(-1)[predict].item()\n",
+        "plt.title(f'benign: dog2.png\\n{classes[predict]}: {prob:.2%}')\n",
+        "plt.axis('off')\n",
+        "plt.imshow(np.array(im))\n",
+        "plt.tight_layout()\n",
+        "plt.show()\n",
+        "\n",
+        "# adversarial image \n",
+        "im = Image.open(f'./fgsm/{path}')\n",
+        "logit = model(transform(im).unsqueeze(0).to(device))[0]\n",
+        "predict = logit.argmax(-1).item()\n",
+        "prob = logit.softmax(-1)[predict].item()\n",
+        "plt.title(f'adversarial: dog2.png\\n{classes[predict]}: {prob:.2%}')\n",
+        "plt.axis('off')\n",
+        "plt.imshow(np.array(im))\n",
+        "plt.tight_layout()\n",
+        "plt.show()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Passive Defense - JPEG compression\n",
+        "JPEG compression by imgaug package, compression rate set to 70\n",
+        "\n",
+        "Reference: https://imgaug.readthedocs.io/en/latest/source/api_augmenters_arithmetic.html#imgaug.augmenters.arithmetic.JpegCompression"
+      ],
+      "metadata": {
+        "id": "2AQkofrTnePa"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import imgaug.augmenters as iaa\n",
+        "\n",
+        "# pre-process image\n",
+        "x = transforms.ToTensor()(im)*255\n",
+        "x = x.permute(1, 2, 0).numpy()\n",
+        "compressed_x = x.astype(np.uint8)\n",
+        "\n",
+        "# TODO: use \"imgaug\" package to perform JPEG compression (compression rate = 70)\n",
+        "# compressed_x = ...\n",
+        "\n",
+        "logit = model(transform(compressed_x).unsqueeze(0).to(device))[0]\n",
+        "predict = logit.argmax(-1).item()\n",
+        "prob = logit.softmax(-1)[predict].item()\n",
+        "plt.title(f'JPEG adversarial: dog2.png\\n{classes[predict]}: {prob:.2%}')\n",
+        "plt.axis('off')\n",
+        "\n",
+        "\n",
+        "plt.imshow(compressed_x)\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "id": "sKuQaPp2mz7C"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "collapsed_sections": [],
+      "name": "ML2022_hw10.ipynb",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/2022 ML/10 Attack/Machine Learning HW10 Adversarial Attack.pdf b/2022 ML/10 Attack/Machine Learning HW10 Adversarial Attack.pdf
new file mode 100644
index 0000000..33310e7
Binary files /dev/null and b/2022 ML/10 Attack/Machine Learning HW10 Adversarial Attack.pdf differ
diff --git a/README.md b/README.md
index f4a77ea..1340bbe 100644
--- a/README.md
+++ b/README.md
@@ -45,6 +45,7 @@ ppt/pdf支持直链下载。
 |2022/04/16|更新HW7|
 |2022/04/23|更新HW8|
 |2022/04/30|更新Lecture 9 & Lecture10，HW9|
+|2022/05/06|更新HW10|
 
 ****
 	
@@ -77,7 +78,7 @@ ppt/pdf支持直链下载。
 |Lecture 7|[自监督学习（一）芝麻街与进击的巨人](https://www.bilibili.com/video/BV1Wv411h7kN?p=71)<br/>[自监督学习（二）BERT简介](https://www.bilibili.com/video/BV1Wv411h7kN?p=72)<br/>[自监督学习（三）BERT的奇闻轶事](https://www.bilibili.com/video/BV1Wv411h7kN?p=73)<br/>[自监督学习（四）GPT的野望](https://www.bilibili.com/video/BV1Wv411h7kN?p=74)|Video:<br/>[如何有效的使用自督导式模型](https://www.bilibili.com/video/BV1Wv411h7kN?p=75)<br/>[语音与影像上的神奇自督导式学习模型](https://www.bilibili.com/video/BV1Wv411h7kN?p=76)<br/><br/>PDF:<br/>[Recent Advance of Self-supervied learning for NLP](https://speech.ee.ntu.edu.tw/~hylee/ml/ml2022-course-data/PLM.pdf)<br/>[SSL for Speech and Image](https://speech.ee.ntu.edu.tw/~hylee/ml/ml2022-course-data/SSL_speech_image%20(v9).pdf)|[BERT (part 1)](https://www.bilibili.com/video/BV1Wv411h7kN?p=77)<br/>[BERT (part 2)](https://www.bilibili.com/video/BV1Wv411h7kN?p=78)<br/>[GPT-3](https://www.bilibili.com/video/BV1Wv411h7kN?p=80)|[Video](https://www.bilibili.com/video/BV1Wv411h7kN?p=82)<br/>[Slide](https://speech.ee.ntu.edu.tw/~hylee/ml/ml2022-course-data/hw7_slides.pdf)<br/>[Code](https://colab.research.google.com/drive/1QloQ42zYwX_ETAs2GIkeh8qFj0UjHXfH?usp=sharing)<br/>[Submission](https://www.kaggle.com/c/ml2022spring-hw7)|
 |Lecture 8|[自编码器 (Auto-encoder) (上) – 基本概念](https://www.bilibili.com/video/BV1Wv411h7kN?p=83)<br/>[自编码器 (Auto-encoder) (下) – 领结变声器与更多应用](https://www.bilibili.com/video/BV1Wv411h7kN?p=84)<br/>[Anomaly Detection (1_7)](https://www.bilibili.com/video/BV1Wv411h7kN?p=85)<br/>[Anomaly Detection (2_7)](https://www.bilibili.com/video/BV1Wv411h7kN?p=86)<br/>[Anomaly Detection (3_7)](https://www.bilibili.com/video/BV1Wv411h7kN?p=87)<br/>[Anomaly Detection (4_7)](https://www.bilibili.com/video/BV1Wv411h7kN?p=88)<br/>[Anomaly Detection (5_7)](https://www.bilibili.com/video/BV1Wv411h7kN?p=89)<br/>[Anomaly Detection (6_7)](https://www.bilibili.com/video/BV1Wv411h7kN?p=90)<br/>[Anomaly Detection (7_7)](https://www.bilibili.com/video/BV1Wv411h7kN?p=91)|Video:<br/>[None]<br/><br/>PDF:<br/>[None]<br/>|[PCA](https://www.bilibili.com/video/BV1Wv411h7kN?p=92)<br/>[t-SNE](https://www.bilibili.com/video/BV1Wv411h7kN?p=93)|[Video](https://www.bilibili.com/video/BV1Wv411h7kN?p=95)<br/>[Slide](https://speech.ee.ntu.edu.tw/~hylee/ml/ml2022-course-data/Machine%20Learning%20Homework%208%20Anomaly%20Detection.pdf)<br/>[Code](https://colab.research.google.com/drive/16J23Uqkclro8zvp5Y1EXFtEWOvMA9YXC#scrollTo=JoW1UrrxgI_U)<br/>[Submission](https://www.kaggle.com/competitions/ml2022spring-hw8/)|
 |Lecture 9|[机器学习的可解释性 (上) – 为什么神经网络可以正确分辨宝可梦和数码宝贝](https://www.bilibili.com/video/BV1Wv411h7kN?p=96)<br/>[机器学习的可解释性  (下) –机器心中的猫长什么样子](https://www.bilibili.com/video/BV1Wv411h7kN?p=77)|Video:<br/>[自然语言处理上的对抗式攻击 Part1](https://www.bilibili.com/video/BV1Wv411h7kN?p=98)<br/><br/>PDF:<br/>[Adversarial Attack for NLP](https://speech.ee.ntu.edu.tw/~hylee/ml/ml2022-course-data/Attacks-in-NLP-Draft.pdf)<br/>|[None]|[Video](https://www.bilibili.com/video/BV1Wv411h7kN?p=100)<br/>[Slide](https://speech.ee.ntu.edu.tw/~hylee/ml/ml2022-course-data/Machine%20Learning%20HW9.pdf)<br/>[Code](https://colab.research.google.com/drive/1DvQX9apokZHZNfZeG7brJS6XbsGpPFYU?usp=sharing)|
-|Lecture 10|[来自人类的恶意攻击 (Adversarial Attack) (上) – 基本概念](https://www.bilibili.com/video/BV1Wv411h7kN?p=101)<br/>[2021 - 来自人类的恶意攻击 (Adversarial Attack) (下) – 类神经网络能否躲过人类深不见底的恶意](https://www.bilibili.com/video/BV1Wv411h7kN?p=102)|Video:<br/>[自然语言处理上的对抗式攻击 Part2](https://www.bilibili.com/video/BV1Wv411h7kN?p=103)<br/><br/>PDF:<br/>[Adversarial Attack for NLP](https://speech.ee.ntu.edu.tw/~hylee/ml/ml2022-course-data/Attacks-in-NLP-Draft.pdf)|[More about Adversarial Attack (1_2)](https://www.bilibili.com/video/BV1Wv411h7kN?p=104)<br/>[More about Adversarial Attack (2_2)](https://www.bilibili.com/video/BV1Wv411h7kN?p=105)|[Video]<br/>[Slide]<br/>[Code]<br/>[Submission]|
+|Lecture 10|[来自人类的恶意攻击 (Adversarial Attack) (上) – 基本概念](https://www.bilibili.com/video/BV1Wv411h7kN?p=101)<br/>[2021 - 来自人类的恶意攻击 (Adversarial Attack) (下) – 类神经网络能否躲过人类深不见底的恶意](https://www.bilibili.com/video/BV1Wv411h7kN?p=102)|Video:<br/>[自然语言处理上的对抗式攻击 Part2](https://www.bilibili.com/video/BV1Wv411h7kN?p=103)<br/><br/>PDF:<br/>[Adversarial Attack for NLP](https://speech.ee.ntu.edu.tw/~hylee/ml/ml2022-course-data/Attacks-in-NLP-Draft.pdf)|[More about Adversarial Attack (1_2)](https://www.bilibili.com/video/BV1Wv411h7kN?p=104)<br/>[More about Adversarial Attack (2_2)](https://www.bilibili.com/video/BV1Wv411h7kN?p=105)|[Video](https://www.bilibili.com/video/BV1Wv411h7kN?p=109)<br/>[Slide](https://speech.ee.ntu.edu.tw/~hylee/ml/ml2022-course-data/Machine%20Learning%20HW10%20Adversarial%20Attack.pdf)<br/>[Code](https://colab.research.google.com/drive/1BcYS4bAInDCTo4Ilsc6w4o_SEoFTuHSO?usp=sharing)<br/>[Submission](https://ml.ee.ntu.edu.tw/hw10/)|
 
 ****
 [![BILIBILI](https://raw.githubusercontent.com/Fafa-DL/readme-data/main/gzh.jpg)](https://space.bilibili.com/46880349)
\ No newline at end of file