Upload folder using huggingface_hub

03A_deep_learning_project.ipynb

@@ -0,0 +1,586 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_8ZwOksxZ0-q"
+      },
+      "source": [
+        "# Project: Deep Learning - Calculations"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_R3K9DR2Z0-r"
+      },
+      "source": [
+        "**Instructions for Students:**\n",
+        "\n",
+        "Please carefully follow these steps to complete and submit your project:\n",
+        "\n",
+        "1. **Make a copy of the Project**: Please make a copy of this project either to your own Google Drive or download locally. Work on the copy of the project. The master project is **Read-Only**, meaning you can edit, but it will not be saved when you close the master project. To avoid total loss of your work, remember to make a copy.\n",
+        "\n",
+        "2. **Completing the Project**: You are required to work on and complete all tasks in the provided project. Be disciplined and ensure that you thoroughly engage with each task.\n",
+        "   \n",
+        "3. **Creating a Google Drive Folder**: Each of you must create a new folder on your Google Drive. This will be the repository for all your completed project files, aiding you in keeping your work organized and accessible.\n",
+        "   \n",
+        "4. **Uploading Completed Project**: Upon completion of your project, make sure to upload all necessary files, involving codes, reports, and related documents into the created Google Drive folder. Save this link in the 'Student Identity' section and also provide it as the last parameter in the `submit` function that has been provided.\n",
+        "   \n",
+        "5. **Sharing Folder Link**: You're required to share the link to your project Google Drive folder. This is crucial for the submission and evaluation of your project.\n",
+        "   \n",
+        "6. **Setting Permission to Public**: Please make sure your Google Drive folder is set to public. This allows your instructor to access your solutions and assess your work correctly.\n",
+        "\n",
+        "Adhering to these procedures will facilitate a smooth project evaluation process for you and the reviewers."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "XeK2fKDrZ0-s"
+      },
+      "source": [
+        "## Project Description\n",
+        "\n",
+        "The Deep Learning Projects are divided into two parts, the first is the Calculations worth 30% in this notebook and the second one is Pytorch Project worth 70%.\n",
+        "\n",
+        "The two projects will help you gain experience to learn about Deep Learning in detail.\n",
+        "\n",
+        "Happy coding!"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Lgd8szRCZ0-t"
+      },
+      "source": [
+        "## Grading Criteria\n",
+        "\n",
+        "There are 4 primary tasks in this project, all have the same weight. Each task will give you either 100 point if you are correct and 0 if you are wrong. The final score for the project will the the average of all 4 tasks.\n",
+        "\n",
+        "There is also an optional task (Task 5) that you can do to challenge your understanding.\n",
+        "\n",
+        "* Task 1: This task will assess your ability to do basic matrix multiplication which is an important part in machine and deep learning.\n",
+        "\n",
+        "* Task 2: This task will assess your ability to understand how a neural network work through weight and biases.\n",
+        "\n",
+        "* Task 3: The task will assess your ability to understand how a neural network layer works.\n",
+        "\n",
+        "* Task 4: This task will assess your ability to understand how backpropagation works in a neural network.\n",
+        "\n",
+        "* Task 5 (optional): This task will assess your ability to understand how to calculate cost and why it's important by using backpropagation in a neural network.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "W1dT1yHmZ0-t"
+      },
+      "source": [
+        "## Student Identity"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "-Vysq0mbZ0-t"
+      },
+      "outputs": [],
+      "source": [
+        "# @title #### Student Identity\n",
+        "student_id = \"\" # @param {type:\"string\"}\n",
+        "name = \"\" # @param {type:\"string\"}\n",
+        "drive_link = \"\"  # @param {type:\"string\"}"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "TuVolX9FZ0-u"
+      },
+      "source": [
+        "## Import package"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Pl3QEX2HZ0-u"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install fastbook\n",
+        "\n",
+        "!pip install rggrader\n",
+        "from rggrader import submit"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "4gtGSA8SZ0-v"
+      },
+      "source": [
+        "\n",
+        "## Task 1\n",
+        "\n",
+        "Given\n",
+        "\n",
+        "$$\n",
+        "X = \\begin{bmatrix}\n",
+        "a \\\\\n",
+        "b \\\\\n",
+        "c \\\\\n",
+        "d \\\\\n",
+        "e\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "and\n",
+        "\n",
+        "$$\n",
+        "M =\n",
+        "\\begin{bmatrix}\n",
+        "-2 & 3 & 3 & 3 & -4 \\\\\n",
+        "0 & -4 & -1 & 1 & 2 \\\\\n",
+        "1 & 5 & 4 & 2 & 0 \\\\\n",
+        "-2 & 5 & -5 & 3 & 1 \\\\\n",
+        "-3 & 2 & 4 & 3 & 4 \\\\\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "and\n",
+        "\n",
+        "$$\n",
+        "M \\cdot X =\n",
+        " =\n",
+        "\\begin{bmatrix}\n",
+        "-33 \\\\\n",
+        "9 \\\\\n",
+        "-34 \\\\\n",
+        "-38 \\\\\n",
+        " -40\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "What is the value of $a + b + c + d + e$?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "JCwFuKpEZ0-v"
+      },
+      "outputs": [],
+      "source": [
+        "# You may add any code here to derive your variables\n",
+        "# Please change this\n",
+        "a = 0\n",
+        "b = 0\n",
+        "c = 0\n",
+        "d = 0\n",
+        "e = 0\n",
+        "total = a + b + c + d + e\n",
+        "\n",
+        "print(f\"The total is {total}\")\n",
+        "\n",
+        "assignment_id = \"09-deep-learning-project\"\n",
+        "question_id = \"q1_linear_algebra\"\n",
+        "submit(student_id, name, assignment_id, str(total), question_id, drive_link)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "AnzwjHI5Z0-v"
+      },
+      "source": [
+        "## Task 2\n",
+        "\n",
+        "What is the output of the following Neural Network?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "5Dhvs1l-Z0-v",
+        "outputId": "8fec2c6f-eb16-4791-bcee-d3414a8b7fab"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/svg+xml": [
+              "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
+              "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
+              " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
+              "<!-- Generated by graphviz version 8.1.0 (20230707.0739)\n",
+              " -->\n",
+              "<!-- Title: G Pages: 1 -->\n",
+              "<svg width=\"452pt\" height=\"132pt\"\n",
+              " viewBox=\"0.00 0.00 451.92 132.40\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
+              "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 128.4)\">\n",
+              "<title>G</title>\n",
+              "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-128.4 447.92,-128.4 447.92,4 -4,4\"/>\n",
+              "<!-- z_1 -->\n",
+              "<g id=\"node1\" class=\"node\">\n",
+              "<title>z_1</title>\n",
+              "<polygon fill=\"none\" stroke=\"black\" points=\"209.5,-121.4 123.25,-121.4 119.25,-117.4 119.25,-71 205.5,-71 209.5,-75 209.5,-121.4\"/>\n",
+              "<polyline fill=\"none\" stroke=\"black\" points=\"205.5,-117.4 119.25,-117.4\"/>\n",
+              "<polyline fill=\"none\" stroke=\"black\" points=\"205.5,-117.4 205.5,-71\"/>\n",
+              "<polyline fill=\"none\" stroke=\"black\" points=\"205.5,-117.4 209.5,-121.4\"/>\n",
+              "<text text-anchor=\"middle\" x=\"164.38\" y=\"-91.15\" font-family=\"Times,serif\" font-size=\"14.00\">b = &#45;2, ReLU</text>\n",
+              "</g>\n",
+              "<!-- z_3 -->\n",
+              "<g id=\"node3\" class=\"node\">\n",
+              "<title>z_3</title>\n",
+              "<polygon fill=\"none\" stroke=\"black\" points=\"338,-87.4 256.25,-87.4 252.25,-83.4 252.25,-37 334,-37 338,-41 338,-87.4\"/>\n",
+              "<polyline fill=\"none\" stroke=\"black\" points=\"334,-83.4 252.25,-83.4\"/>\n",
+              "<polyline fill=\"none\" stroke=\"black\" points=\"334,-83.4 334,-37\"/>\n",
+              "<polyline fill=\"none\" stroke=\"black\" points=\"334,-83.4 338,-87.4\"/>\n",
+              "<text text-anchor=\"middle\" x=\"295.12\" y=\"-57.15\" font-family=\"Times,serif\" font-size=\"14.00\">b = 4, ReLU</text>\n",
+              "</g>\n",
+              "<!-- z_1&#45;&gt;z_3 -->\n",
+              "<g id=\"edge5\" class=\"edge\">\n",
+              "<title>z_1&#45;&gt;z_3</title>\n",
+              "<path fill=\"none\" stroke=\"black\" d=\"M209.68,-84.5C219.94,-81.79 230.95,-78.88 241.52,-76.09\"/>\n",
+              "<polygon fill=\"black\" stroke=\"black\" points=\"242.13,-79.29 250.91,-73.35 240.34,-72.52 242.13,-79.29\"/>\n",
+              "<text text-anchor=\"middle\" x=\"230.88\" y=\"-82.4\" font-family=\"Times,serif\" font-size=\"14.00\">2</text>\n",
+              "</g>\n",
+              "<!-- z_2 -->\n",
+              "<g id=\"node2\" class=\"node\">\n",
+              "<title>z_2</title>\n",
+              "<polygon fill=\"none\" stroke=\"black\" points=\"209.5,-53.4 123.25,-53.4 119.25,-49.4 119.25,-3 205.5,-3 209.5,-7 209.5,-53.4\"/>\n",
+              "<polyline fill=\"none\" stroke=\"black\" points=\"205.5,-49.4 119.25,-49.4\"/>\n",
+              "<polyline fill=\"none\" stroke=\"black\" points=\"205.5,-49.4 205.5,-3\"/>\n",
+              "<polyline fill=\"none\" stroke=\"black\" points=\"205.5,-49.4 209.5,-53.4\"/>\n",
+              "<text text-anchor=\"middle\" x=\"164.38\" y=\"-23.15\" font-family=\"Times,serif\" font-size=\"14.00\">b = &#45;6, ReLU</text>\n",
+              "</g>\n",
+              "<!-- z_2&#45;&gt;z_3 -->\n",
+              "<g id=\"edge6\" class=\"edge\">\n",
+              "<title>z_2&#45;&gt;z_3</title>\n",
+              "<path fill=\"none\" stroke=\"black\" d=\"M209.68,-39.9C219.94,-42.61 230.95,-45.52 241.52,-48.31\"/>\n",
+              "<polygon fill=\"black\" stroke=\"black\" points=\"240.34,-51.88 250.91,-51.05 242.13,-45.11 240.34,-51.88\"/>\n",
+              "<text text-anchor=\"middle\" x=\"230.88\" y=\"-49.4\" font-family=\"Times,serif\" font-size=\"14.00\">3</text>\n",
+              "</g>\n",
+              "<!-- output -->\n",
+              "<g id=\"node6\" class=\"node\">\n",
+              "<title>output</title>\n",
+              "<ellipse fill=\"none\" stroke=\"black\" cx=\"409.46\" cy=\"-62.2\" rx=\"34.46\" ry=\"18\"/>\n",
+              "<text text-anchor=\"middle\" x=\"409.46\" y=\"-57.15\" font-family=\"Times,serif\" font-size=\"14.00\">output</text>\n",
+              "</g>\n",
+              "<!-- z_3&#45;&gt;output -->\n",
+              "<g id=\"edge7\" class=\"edge\">\n",
+              "<title>z_3&#45;&gt;output</title>\n",
+              "<path fill=\"none\" stroke=\"black\" d=\"M338.27,-62.2C346.67,-62.2 355.52,-62.2 363.99,-62.2\"/>\n",
+              "<polygon fill=\"black\" stroke=\"black\" points=\"363.85,-65.7 373.85,-62.2 363.85,-58.7 363.85,-65.7\"/>\n",
+              "</g>\n",
+              "<!-- input_1 -->\n",
+              "<g id=\"node4\" class=\"node\">\n",
+              "<title>input_1</title>\n",
+              "<ellipse fill=\"none\" stroke=\"black\" cx=\"36\" cy=\"-99.2\" rx=\"36\" ry=\"25.2\"/>\n",
+              "<text text-anchor=\"middle\" x=\"36\" y=\"-94.15\" font-family=\"Times,serif\" font-size=\"14.00\">4</text>\n",
+              "</g>\n",
+              "<!-- input_1&#45;&gt;z_1 -->\n",
+              "<g id=\"edge1\" class=\"edge\">\n",
+              "<title>input_1&#45;&gt;z_1</title>\n",
+              "<path fill=\"none\" stroke=\"black\" d=\"M72.35,-99.96C78.24,-100.06 84.29,-100.15 90,-100.2 95,-100.25 96.25,-100.36 101.25,-100.2 103.49,-100.13 105.77,-100.04 108.07,-99.94\"/>\n",
+              "<polygon fill=\"black\" stroke=\"black\" points=\"108.12,-103.4 117.94,-99.41 107.78,-96.4 108.12,-103.4\"/>\n",
+              "<text text-anchor=\"middle\" x=\"95.62\" y=\"-103.4\" font-family=\"Times,serif\" font-size=\"14.00\">4</text>\n",
+              "</g>\n",
+              "<!-- input_1&#45;&gt;z_2 -->\n",
+              "<g id=\"edge3\" class=\"edge\">\n",
+              "<title>input_1&#45;&gt;z_2</title>\n",
+              "<path fill=\"none\" stroke=\"black\" d=\"M64.73,-83.62C77.85,-76.25 93.98,-67.19 109.37,-58.54\"/>\n",
+              "<polygon fill=\"black\" stroke=\"black\" points=\"110.82,-61.18 117.82,-53.23 107.39,-55.08 110.82,-61.18\"/>\n",
+              "<text text-anchor=\"middle\" x=\"95.62\" y=\"-70.4\" font-family=\"Times,serif\" font-size=\"14.00\">0</text>\n",
+              "</g>\n",
+              "<!-- input_2 -->\n",
+              "<g id=\"node5\" class=\"node\">\n",
+              "<title>input_2</title>\n",
+              "<ellipse fill=\"none\" stroke=\"black\" cx=\"36\" cy=\"-25.2\" rx=\"36\" ry=\"25.2\"/>\n",
+              "<text text-anchor=\"middle\" x=\"36\" y=\"-20.15\" font-family=\"Times,serif\" font-size=\"14.00\">&#45;3</text>\n",
+              "</g>\n",
+              "<!-- input_2&#45;&gt;z_1 -->\n",
+              "<g id=\"edge2\" class=\"edge\">\n",
+              "<title>input_2&#45;&gt;z_1</title>\n",
+              "<path fill=\"none\" stroke=\"black\" d=\"M71.04,-31.49C81.21,-34.28 92.09,-38.21 101.25,-43.7 111.09,-49.6 110.68,-54.57 119.25,-62.2 119.85,-62.73 120.45,-63.26 121.06,-63.79\"/>\n",
+              "<polygon fill=\"black\" stroke=\"black\" points=\"118.35,-66.93 128.25,-70.69 122.85,-61.57 118.35,-66.93\"/>\n",
+              "<text text-anchor=\"middle\" x=\"95.62\" y=\"-46.4\" font-family=\"Times,serif\" font-size=\"14.00\">2</text>\n",
+              "</g>\n",
+              "<!-- input_2&#45;&gt;z_2 -->\n",
+              "<g id=\"edge4\" class=\"edge\">\n",
+              "<title>input_2&#45;&gt;z_2</title>\n",
+              "<path fill=\"none\" stroke=\"black\" d=\"M66.37,-10.95C73.9,-7.96 82.11,-5.24 90,-3.7 95.93,-2.54 102.05,-2.55 108.09,-3.35\"/>\n",
+              "<polygon fill=\"black\" stroke=\"black\" points=\"107.36,-6.97 117.86,-5.55 108.76,-0.12 107.36,-6.97\"/>\n",
+              "<text text-anchor=\"middle\" x=\"95.62\" y=\"-6.4\" font-family=\"Times,serif\" font-size=\"14.00\">&#45;1</text>\n",
+              "</g>\n",
+              "</g>\n",
+              "</svg>\n"
+            ],
+            "text/plain": [
+              "<graphviz.sources.Source at 0x28f274710>"
+            ]
+          },
+          "execution_count": 22,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "from fastbook import *\n",
+        "\n",
+        "\n",
+        "# Draw neurons with multiple inputs and weights\n",
+        "gv('''\n",
+        "z_1[shape=box3d width=1 height=0.7 label=\"b = -2, ReLU\"];\n",
+        "z_2[shape=box3d width=1 height=0.7 label=\"b = -6, ReLU\"];\n",
+        "z_3[shape=box3d width=1 height=0.7 label=\"b = 4, ReLU\"];\n",
+        "input_1[width=1 height=0.7 label=\"4\"];\n",
+        "input_2[width=1 height=0.7 label=\"-3\"];\n",
+        "input_1 -> z_1 [label=\"4\"]\n",
+        "input_2 -> z_1 [label=\"2\"]\n",
+        "input_1 -> z_2 [label=\"0\"]\n",
+        "input_2 -> z_2 [label=\"-1\"]\n",
+        "\n",
+        "z_1 -> z_3 [label=\"2\"]\n",
+        "z_2 -> z_3 [label=\"3\"]\n",
+        "z_3 ->output\n",
+        "\n",
+        "\n",
+        "''')\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "jtzFBQeIZ0-w"
+      },
+      "outputs": [],
+      "source": [
+        "# You may add any code here to derive your variables\n",
+        "# Please change this\n",
+        "output = 0\n",
+        "\n",
+        "print(f\"The output is {output}\")\n",
+        "\n",
+        "assignment_id = \"09-deep-learning-project\"\n",
+        "question_id = \"q2_simple_neural_network\"\n",
+        "submit(student_id, name, assignment_id, str(output), question_id, drive_link)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nw5Rc4_QZ0-w"
+      },
+      "source": [
+        "## Task 3\n",
+        "\n",
+        "Given the following Neural Networks:\n",
+        "\n",
+        "First layer:\n",
+        "\n",
+        "$$\n",
+        "W = \\begin{bmatrix}\n",
+        "0.23 & 0.67 & 0.12 \\\\\n",
+        "-0.89 & -0.45 & 0.78 \\\\\n",
+        "0.34 & 0.56 & -0.90 \\\\\n",
+        "-0.12 & 0.34 & 0.56 \\\\\n",
+        "0.78 & -0.90 & 0.23 \\\\\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "$$\n",
+        "bias = \\begin{bmatrix}\n",
+        "0.23 \\\\\n",
+        "-0.89 \\\\\n",
+        "0.34 \\\\\n",
+        "0.12 \\\\\n",
+        "-0.78 \\\\\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "Second layer:\n",
+        "\n",
+        "$$\n",
+        "W = \\begin{bmatrix}\n",
+        "0.23 & 0.67 & 0.12 & 0.45 & 0.89 \\\\\n",
+        "0.12 & 0.34 & 0.56 & 0.78 & 0.90 \\\\\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "$$\n",
+        "bias = \\begin{bmatrix}\n",
+        "1.96 \\\\\n",
+        "-1.08 \\\\\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "Third layer:\n",
+        "$$\n",
+        "W = \\begin{bmatrix}\n",
+        "1.08 & -0.16\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "$$\n",
+        "bias = \\begin{bmatrix}\n",
+        "-2.8\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "All layers use the ReLU activation function.\n",
+        "\n",
+        "What is the output given the following inputs?\n",
+        "\n",
+        "$$\n",
+        "X = \\begin{bmatrix}\n",
+        "1 \\\\\n",
+        "2 \\\\\n",
+        "4 \\\\\n",
+        "\\end{bmatrix}\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "4d8Oibi1Z0-x"
+      },
+      "outputs": [],
+      "source": [
+        "# You may add any code here to derive your variables\n",
+        "\n",
+        "# Please change this\n",
+        "output = 0\n",
+        "\n",
+        "print(f\"The output is {output}\")\n",
+        "\n",
+        "assignment_id = \"09-deep-learning-project\"\n",
+        "question_id = \"q3_complex_neural_network\"\n",
+        "submit(student_id, name, assignment_id, str(output), question_id, drive_link)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Vn5o5XmfZ0-x"
+      },
+      "source": [
+        "## Task 4\n",
+        "\n",
+        "Given [the following sheet (sheet name = Project A)](https://docs.google.com/spreadsheets/d/15JWbRFB4k5CNcfD-2hduHHssXIc1SGhNVSpu_30wVAw/edit#gid=180755192)\n",
+        "\n",
+        "Make a backpropagation algorithm to train the network. You can refer to AND and NOT sheet. Use sigmoid activation function for all\n",
+        "\n",
+        "Hint: it needs 1 layer with 1 neuron\n",
+        "\n",
+        "What is the cost at 10th iteration (the iteration start from 1)?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "d2aSUbaaZ0-x"
+      },
+      "outputs": [],
+      "source": [
+        "# Please clone the Google Sheet and do your calculation there\n",
+        "\n",
+        "# Please change this\n",
+        "cost = 0\n",
+        "\n",
+        "# Don't forget to fill in the link to your Google Sheet\n",
+        "link_to_gsheet = \"\"\n",
+        "\n",
+        "print(f\"The cost is {cost}\")\n",
+        "\n",
+        "assignment_id = \"09-deep-learning-project\"\n",
+        "\n",
+        "question_id = \"q4_cost_function_cost\"\n",
+        "submit(student_id, name, assignment_id, str(cost), question_id)\n",
+        "\n",
+        "question_id = \"q4_cost_function_gsheet\"\n",
+        "submit(student_id, name, assignment_id, str(link_to_gsheet), question_id, drive_link)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Kh7uzjtDZ0-x"
+      },
+      "source": [
+        "## Task 5 (Bonus - Optional)\n",
+        "\n",
+        "_This task is optional, it will earn you a distinction, but will not give you additional points._\n",
+        "\n",
+        "Given [the following sheet (sheet name = Project B)](https://docs.google.com/spreadsheets/d/15JWbRFB4k5CNcfD-2hduHHssXIc1SGhNVSpu_30wVAw/edit#gid=1029811725)\n",
+        "\n",
+        "Make a backpropagation algorithm to train the network. You can refer to AND and NOT sheet. Use sigmoid activation function for all\n",
+        "\n",
+        "Hint: it needs 2 layer (1 hidden layer + 1 output layer). The hidden layer has 2 neurons\n",
+        "\n",
+        "What is the cost at 10th iteration (the iteration start from 1)?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "KJJOi3V1Z0-x"
+      },
+      "outputs": [],
+      "source": [
+        "# Please clone the Google Sheet and do your calculation there\n",
+        "\n",
+        "# Please change this\n",
+        "cost = 0\n",
+        "\n",
+        "# Don't forget to fill in the link to your Google Sheet\n",
+        "link_to_gsheet = \"\"\n",
+        "\n",
+        "print(f\"The cost is {cost}\")\n",
+        "\n",
+        "assignment_id = \"09-deep-learning-project\"\n",
+        "\n",
+        "question_id = \"q5_cost_function_cost\"\n",
+        "submit(student_id, name, assignment_id, str(cost), question_id)\n",
+        "\n",
+        "question_id = \"q5_cost_function_gsheet\"\n",
+        "submit(student_id, name, assignment_id, str(link_to_gsheet), question_id, drive_link)\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "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.11.3"
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

04_model_usage_project.ipynb

@@ -0,0 +1,824 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "VFa5VyVNPCJY"
+      },
+      "source": [
+        "# Project: Model Usage - Image Classification and Transfer Learning"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-9Z7RJrNvF8Q"
+      },
+      "source": [
+        "**Instructions for Students:**\n",
+        "\n",
+        "Please carefully follow these steps to complete and submit your project:\n",
+        "\n",
+        "1. **Make a copy of the Project**: Please make a copy of this project either to your own Google Drive or download locally. Work on the copy of the project. The master project is **Read-Only**, meaning you can edit, but it will not be saved when you close the master project. To avoid total loss of your work, remember to make a copy.\n",
+        "\n",
+        "2. **Completing the Project**: You are required to work on and complete all tasks in the provided project. Be disciplined and ensure that you thoroughly engage with each task.\n",
+        "   \n",
+        "3. **Creating a Google Drive Folder**: Each of you must create a new folder on your Google Drive. This will be the repository for all your completed project files, aiding you in keeping your work organized and accessible.\n",
+        "   \n",
+        "4. **Uploading Completed Project**: Upon completion of your project, make sure to upload all necessary files, involving codes, reports, and related documents into the created Google Drive folder. Save this link in the 'Student Identity' section and also provide it as the last parameter in the `submit` function that has been provided.\n",
+        "   \n",
+        "5. **Sharing Folder Link**: You're required to share the link to your project Google Drive folder. This is crucial for the submission and evaluation of your project.\n",
+        "   \n",
+        "6. **Setting Permission to Public**: Please make sure your Google Drive folder is set to public. This allows your instructor to access your solutions and assess your work correctly.\n",
+        "\n",
+        "Adhering to these procedures will facilitate a smooth project evaluation process for you and the reviewers."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0Qg7V4zoPCJi"
+      },
+      "source": [
+        "## Project Description:\n",
+        "\n",
+        "Welcome to your new project! You will have the opportunity to apply the knowledge and skills you've learned in class.\n",
+        "\n",
+        "The tasks are divided into two parts, the first part is to create an image classification project that predicts a person's age based on their photograph. You will be utilizing the power of machine learning pipelines to streamline your workflow and effectively manage the different stages of this project, from data preprocessing to model training and evaluation.\n",
+        "\n",
+        "In the second part is transfer learning where you'll use a [Vision Transformer (ViT)](https://huggingface.co/google/vit-base-patch16-224-in21k) model pre-trained on ImageNet-21k and fine-tune it on the [FastJobs/Visual_Emotional_Analysis](https://huggingface.co/datasets/FastJobs/Visual_Emotional_Analysis) dataset for emotion recognition, with the final step being the publication of your trained model to the Hugging Face Model Hub.\n",
+        "\n",
+        "Remember, the goal of this assignment is not just to build a model that makes accurate predictions, but also to understand the process of developing a machine-learning pipeline and the role each component plays in this process.\n",
+        "\n",
+        "We encourage you to be creative, explore different strategies, and most importantly, have fun while learning. We can't wait to see the innovative solutions you come up with! Best of luck!"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "6MDaD2U_vF8S"
+      },
+      "source": [
+        "## Grading Criteria\n",
+        "\n",
+        "There are 2 tasks in this project with 5 criterias for scoring, all except Criteria 4 have the same weight. Each criteria except Criteria 4 will give you either 100 point if you are correct and 0 if you are wrong. The final score for the project will the the average of all 5 criterias from both projects.\n",
+        "\n",
+        "* Task-1 Criteria 1: This task will assess your ability to understand how a model is likely to be used, in this use a model from Huggingface (HF) preferably using HF Pipeline, pass the input and get the correct answer form the model's output.\n",
+        "\n",
+        "* Task-1 Criteria 2: This task will assess your ability to use Gradio as a UI (User Interface) and interact with the model, in this case, the model used in Task-1 Criteria 1.\n",
+        "\n",
+        "* Task-2 Criteria 3: The task will assess your ability to perform transfer learning using a model from Huggingface and publish the new model to Huggingface platform.\n",
+        "\n",
+        "* Task-2 Criteria 4: This task will assess your ability to perform transfer learning and perform an evaluation. The accuracy submitted will be used in a Bell Curve Distribution where the average accuracy score will be mapped to a score of 70. This ensures fairness since the accuracy of all students who submit their accuracy score are taken into account and distributed evenly. For example, if the average students score is 56, those who submit their accuracy as 56 will get a score of 70; student with accuracy of 43 will get a score of 60; student with accuracy of 70 will get 80; naturally there is a gradation, meaning the accuracy between 43-56 will get a score between 60 to 70 and so on.\n",
+        "\n",
+        "* Task-2 Criteria 5: This task will assess your ability to use Gradio as a UI and interact with more than one models, in this case the model from Task-1 Criteria 1 and Task-2 Criteria 3.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ZysTKHbGioh8"
+      },
+      "source": [
+        "## Student Identity"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "i8BlcSWzioi3"
+      },
+      "outputs": [],
+      "source": [
+        "# @title #### Student Identity\n",
+        "student_id = \"\" # @param {type:\"string\"}\n",
+        "name = \"\" # @param {type:\"string\"}\n",
+        "drive_link = \"\"  # @param {type:\"string\"}"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "vJWjH2kGV49k"
+      },
+      "source": [
+        "## Installation and Import Package"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "8wWESOr0PCJk"
+      },
+      "outputs": [],
+      "source": [
+        "# Install necessary packages\n",
+        "!pip install rggrader\n",
+        "from rggrader import submit, submit_image\n",
+        "\n",
+        "# Put your code here:\n",
+        "\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "4_mbLFq9Vvcg"
+      },
+      "source": [
+        "## Task 1 Image Classification using Pipeline"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "YwFqrph-vF8W"
+      },
+      "source": [
+        "### Step 1: Image Classification using Hugging Face's Model\n",
+        "\n",
+        "In this first task, your task is to develop an image classification pipeline that takes **an image URL as input**, displays the image, and uses the Hugging Face's model to predict the age of the person in the image. You can get the model [here](https://huggingface.co/nateraw/vit-age-classifier).\n",
+        "\n",
+        "Here are the key steps that you might be able to follow:\n",
+        "\n",
+        "1. **Image URL Input:** Your program should accept an image URL as input. Make sure to handle potential issues with invalid URLs or inaccessible images.\n",
+        "2. **Image Display:** Display the image from the URL in your notebook. This will provide a visual confirmation that the correct image is being processed.\n",
+        "3. **Model Loading and Prediction:** Load the 'nateraw/vit-age-classifier' model from Hugging Face's model hub and pass the image URL to the model to obtain the prediction. The model should predict the age of the person in the image.\n",
+        "4. **Output Display:** Display the output from the model in a clear and understandable manner.\n",
+        "\n",
+        "#### Submission\n",
+        "\n",
+        "- What percentage is the person in this picture (https://images.unsplash.com/photo-1596392927852-2a18c336fb78?ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&auto=format&fit=crop&w=1280&q=80) is between age of \"3-9\"?\n",
+        "\n",
+        "Submit in the numeric format up to 5 digits behind the decimal point. For example in below output:\n",
+        "\n",
+        "```\n",
+        "{'0-2': '0.00152',\n",
+        " '3-9': '0.00105',\n",
+        " '10-19': '0.02567',\n",
+        " '20-29': '3.32545',\n",
+        " '30-39': '51.75200',\n",
+        " '40-49': '40.24234',\n",
+        " '50-59': '4.47803',\n",
+        " '60-69': '0.17092',\n",
+        " 'more than 70': '0.00304'}\n",
+        "```\n",
+        "\n",
+        "The answer would be `0.00105`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "H5LA1LcdPCJm"
+      },
+      "outputs": [],
+      "source": [
+        "# @title #### 01. Image Classification using Hugging Face's Model\n",
+        "\n",
+        "# Put your code here:\n",
+        "\n",
+        "\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "M2EBNKYYvF8Y"
+      },
+      "outputs": [],
+      "source": [
+        "# Submit Method\n",
+        "assignment_id = \"00_pipeline_and_gradio\"\n",
+        "question_id = \"01_image_classification_using_hugging_faces_model\"\n",
+        "answer = \"\" # Put your answer here\n",
+        "submit(student_id, name, assignment_id, answer, question_id, drive_link)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "B2wOiPqDiojo"
+      },
+      "source": [
+        "### Step 2: Image Classification using Hugging Face's Model and Gradio\n",
+        "\n",
+        "In this second task, you will create a user-friendly interface using Gradio for your image classification pipeline that you created in Task 1. The difference with task 1 is, that in this task, you use **image files as input**, process them through the Hugging Face model, and display predictions output. The output displayed is **only the results with the highest `score`**.\n",
+        "\n",
+        "Here are the key steps that you might be able to follow:\n",
+        "\n",
+        "1. **Image Input:** Create a function to accept an image file as input. The image should be in a format that can be processed by the model.\n",
+        "2. **Model Loading and Prediction:** Load the model from Hugging Face's model hub and pass the image to the model to obtain the prediction. The model predicts the age of the person in the image.\n",
+        "3. **Gradio Interface:** Use Gradio to create a user-friendly interface for your application. The interface should allow users to upload an image file, and it should display the model's output in a clear and understandable manner.\n",
+        "4. **Interface Launch:** Launch the Gradio interface. Make sure that the interface is accessible and easy to use.\n",
+        "\n",
+        "#### Submisssion\n",
+        "\n",
+        "![Upload colab](https://storage.googleapis.com/rg-ai-bootcamp/project-3-pipeline-and-gradio/upload-colab.png)\n",
+        "\n",
+        "You need to submit screenshot of your Gradio's app. In Google Colab you can just use the \"Folder\" sidebar and click the upload button. Make sure your screenshot match below requirements:\n",
+        "\n",
+        "- You should upload a person's image to that app\n",
+        "- The score should be included at the screenshot\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "fsMSIbrwTKuB"
+      },
+      "outputs": [],
+      "source": [
+        "# @title #### 02. Image Classification using Hugging Face's Model and Gradio\n",
+        "\n",
+        "# Put your code here:\n",
+        "\n",
+        "\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "SHFWYR7qvF8Z"
+      },
+      "source": [
+        "Example of Expected Output:\n",
+        "\n",
+        "![gradio-result](https://storage.googleapis.com/rg-ai-bootcamp/project-3-pipeline-and-gradio/gradio-result.png)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "vhJMv03IvF8Z"
+      },
+      "outputs": [],
+      "source": [
+        "# Submit Method\n",
+        "question_id = \"02_image_classification_using_hugging_faces_model_and_gradio\"\n",
+        "submit_image(student_id, question_id, './submission.jpg')\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "t8KSCR8OvF8Z"
+      },
+      "source": [
+        "> Note: If your submission for Task-2 did not run (After you run it never changes from \"*\" to a number), stop the Code block that's running the Gradio app, then the submission will run. To stop the Code block, you can click on the Code block and then click the stop button."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "SC8oMewavF8Z"
+      },
+      "source": [
+        "# Task 2: Transfer Learning for Emotion Recognition"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RYbbazOuvF8Z"
+      },
+      "source": [
+        "### Step 1: Environment Setup\n",
+        "\n",
+        "In this section, we start by installing the necessary packages and logging into Hugging Face's platform:\n",
+        "- `transformers`\n",
+        "- `datasets`\n",
+        "- `evaluate`\n",
+        "- `huggingface_hub`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "L8tVuUfnvF8a"
+      },
+      "outputs": [],
+      "source": [
+        "# Install necessary packages\n",
+        "\n",
+        "# Put your code here:\n",
+        "\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "pp8aOoWDvF8a"
+      },
+      "source": [
+        "After installing, use the Hugging Face's notebook login function to log into Hugging Face's platform. Execute the following commands in your cell:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "z98RbfLwvF8a"
+      },
+      "outputs": [],
+      "source": [
+        "# Log into Hugging Face's platform\n",
+        "\n",
+        "# Put your code here:\n",
+        "\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-4abRjUVvF8a"
+      },
+      "source": [
+        "### Step 2: Load the Dataset\n",
+        "\n",
+        "Load the \"FastJobs/Visual_Emotional_Analysis\" dataset and split it into training and test sets with a test size of 0.2.\n",
+        "\n",
+        "> **Note**: please assign to variable `emotion`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "zygwYIo3vF8a"
+      },
+      "outputs": [],
+      "source": [
+        "# Load the dataset and split it\n",
+        "\n",
+        "# Update your code here:\n",
+        "emotion = \"\"\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "F-LwIylpvF8b"
+      },
+      "source": [
+        "**Label Mapping**\n",
+        "\n",
+        "> **Note**: no need to change the code below! Just run it to map labels from the dataset."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "524AEqr1vF8b"
+      },
+      "outputs": [],
+      "source": [
+        "labels = emotion[\"train\"].features[\"label\"].names\n",
+        "label2id, id2label = dict(), dict()\n",
+        "for i, label in enumerate(labels):\n",
+        "    label2id[label] = str(i)\n",
+        "    id2label[str(i)] = label"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7ZUaw3twvF8b"
+      },
+      "source": [
+        "### Step 3: Explore and Visualize the Dataset\n",
+        "\n",
+        "In this step, you are required to visualize the first instance in the training dataset.\n",
+        "\n",
+        "> **Note**: no need to change the code below! Just run it to visualize the dataset based on index."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "# Define the function to convert label index to label name\n",
+        "id2label_view = {str(i): label for i, label in enumerate(labels)}\n",
+        "\n",
+        "# Use first training example\n",
+        "image = emotion['train'][0]['image'] # Explore image by index\n",
+        "label_id = str(emotion['train'][0]['label'])\n",
+        "label_name = id2label_view[label_id]\n",
+        "\n",
+        "# Display the image and its corresponding label\n",
+        "plt.imshow(image)\n",
+        "plt.title(f'Label: {label_name} (ID: {label_id})')\n",
+        "plt.axis('off')\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "id": "F1qKjbgcvWJj"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "MDm9XEzbvF8b"
+      },
+      "source": [
+        "### Step 4: Preprocess the Data\n",
+        "\n",
+        "You need to define the transformation function for image preprocessing and apply it to the dataset."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "vNa7A9A4vF8b"
+      },
+      "outputs": [],
+      "source": [
+        "from transformers import AutoImageProcessor\n",
+        "from torchvision.transforms import RandomResizedCrop, Compose, Normalize, ToTensor\n",
+        "\n",
+        "# Load the image processor, Define the transforms, Define the transformation function and Apply the transformation function\n",
+        "\n",
+        "# Put your code here:\n",
+        "\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "p1v9tSkvvF8c"
+      },
+      "source": [
+        "### Step 5: Model Setup\n",
+        "\n",
+        "In this step, define the model architecture with the pre-trained ViT model and load it."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "INJfQ16OvF8c"
+      },
+      "outputs": [],
+      "source": [
+        "from transformers import AutoModelForImageClassification\n",
+        "\n",
+        "# Define the model\n",
+        "\n",
+        "# Put your code here:\n",
+        "\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "9pppaVt5vF8c"
+      },
+      "source": [
+        "### Step 6: Training Setup\n",
+        "\n",
+        "Define the training arguments and instantiate the trainer."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "38g8OjfBvF8c"
+      },
+      "outputs": [],
+      "source": [
+        "import evaluate\n",
+        "\n",
+        "# Load accuracy metric\n",
+        "\n",
+        "# Put your code here:\n",
+        "\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "GccP5F4svF8c"
+      },
+      "outputs": [],
+      "source": [
+        "# Define compute metric function\n",
+        "\n",
+        "# Put your code here:\n",
+        "\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "sNC6OFLzvF8c"
+      },
+      "outputs": [],
+      "source": [
+        "from transformers import TrainingArguments, Trainer\n",
+        "\n",
+        "# Define training arguments\n",
+        "\n",
+        "# Update your code here:\n",
+        "training_args = TrainingArguments()\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ABFxOF9wvF8d"
+      },
+      "source": [
+        "To use Hugging Face `Trainer` you need to install the `accelerate` library version `0.20.1` or later. It is used for performance enhancement on PyTorch."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "NGeDe5JOvF8d"
+      },
+      "outputs": [],
+      "source": [
+        "%pip install accelerate -U"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "h95mzDGEvF8d"
+      },
+      "outputs": [],
+      "source": [
+        "from transformers import DefaultDataCollator\n",
+        "\n",
+        "# Instantiate the trainer\n",
+        "\n",
+        "# Update your code here:\n",
+        "data_collator = DefaultDataCollator()\n",
+        "trainer = Trainer()\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RUYlq1oMvF8j"
+      },
+      "source": [
+        "If there are problems when using the Trainer after installing `accelerate` you can restart the Kernel"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-G3c0F5ZvF8j"
+      },
+      "source": [
+        "### Step 7: Train and Evaluate the Model\n",
+        "\n",
+        "Now, you are ready to train the model and evaluate it on the test set."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2GvoiY4mvF8k"
+      },
+      "outputs": [],
+      "source": [
+        "# Train the model\n",
+        "\n",
+        "# Put your code here:\n",
+        "\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "uVPRQNIRvF8k"
+      },
+      "outputs": [],
+      "source": [
+        "# Evaluate the model\n",
+        "\n",
+        "# Update your code here:\n",
+        "eval_result = \"\"\n",
+        "# ---- End of your code ----\n",
+        "\n",
+        "# Save the formatted accuracy in a variable\n",
+        "accuracy_str = \"{:.4f}\".format(eval_result[\"eval_accuracy\"])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "OIv95upxvF8k"
+      },
+      "source": [
+        "### Step 8: Publishing the Trained Model\n",
+        "\n",
+        "Finally, make sure to push your trained model to the Hugging Face Model Hub.\n",
+        "\n",
+        "> **Note**: No need to change the code below! Just run to publish your model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "aZe2lXMNvF8k"
+      },
+      "outputs": [],
+      "source": [
+        "trainer.push_to_hub()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "3PRRzcPkvF8l"
+      },
+      "source": [
+        "Once you've trained your model and pushed it to the Hugging Face Model Hub, you'll have a link that points directly to your model's page. You can share this link with others, and they can use it to directly load your model for their own uses.\n",
+        "\n",
+        "The following link is an example of what a trained model's page looks like: https://huggingface.co/aditira/emotion_classification. This is not your model, but rather an example of what your final result might resemble.\n",
+        "\n",
+        "Remember, for this project you should push your output model to your own Hugging Face account. The link for your model will be different and should reflect your own username and model name."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "f72zoZKcvF8l"
+      },
+      "outputs": [],
+      "source": [
+        "# Submit Method\n",
+        "huggingface_model_link = \"\" # Put your model link\n",
+        "\n",
+        "assignment_id = \"00_transfer_learning\"\n",
+        "question_id = \"00_emotion_recognition_huggingface\"\n",
+        "submit(student_id, name, assignment_id, huggingface_model_link, question_id, drive_link)\n",
+        "\n",
+        "question_id = \"01_emotion_recognition_accuracy\"\n",
+        "submit(student_id, name, assignment_id, accuracy_str, question_id, drive_link)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "YNRc-bowvF8l"
+      },
+      "source": [
+        "### Step 9:  Build an Interactive Application with Gradio"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Dt61YtQYvF8l"
+      },
+      "source": [
+        "In this task, you will be building an interactive application using Gradio that will use your fine-tuned emotion recognition model along with another pretrained model ('`nateraw/vit-age-classifier`') to guess the emotion and age from an input image.\n",
+        "\n",
+        "Please make sure to:\n",
+        "- Install the necessary package (`gradio`) for creating the web-based interface.\n",
+        "- Load your fine-tuned model as well as the pretrained model '`nateraw/vit-age-classifier`'.\n",
+        "- Define a function that will take an image as input and return the predicted emotion and age.\n",
+        "- Utilize Gradio to create an Interface (UI) for your function, allowing users to upload images and see the predicted emotion and age."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "VtyLNza9vF8l"
+      },
+      "outputs": [],
+      "source": [
+        "# Install Gradio\n",
+        "!pip install gradio"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "tD9pRSs2vF8m"
+      },
+      "source": [
+        "#### Submisssion\n",
+        "\n",
+        "![Upload colab](https://storage.googleapis.com/rg-ai-bootcamp/project-3-pipeline-and-gradio/upload-colab.png)\n",
+        "\n",
+        "You need to submit screenshot of your Gradio's app. In Google Colab you can just use the \"Folder\" sidebar and click the upload button. Make sure your screenshot match below requirements:\n",
+        "\n",
+        "- Image name screenshot is `submission.jpg`\n",
+        "- You should upload a person's image to that app\n",
+        "- The score should be included at the screenshot"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "7nNft9g0vF8m"
+      },
+      "outputs": [],
+      "source": [
+        "# Put your code here:\n",
+        "\n",
+        "# ---- End of your code ----"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7xHv6RycvF8m"
+      },
+      "source": [
+        "Example of Expected Output:\n",
+        "\n",
+        "![gradio-result](https://storage.googleapis.com/rg-ai-bootcamp/project-4-transfer-learning/gradio_emotion_age_app.png)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ZhKCVEWjvF8m"
+      },
+      "outputs": [],
+      "source": [
+        "# Submit Method\n",
+        "question_id = \"01_interactive_application_with_gradio\"\n",
+        "submit_image(student_id, question_id, './submission.jpg')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "YYUSn0TgvF8m"
+      },
+      "source": [
+        "> Note: If your submission for Task-2 did not run (After you run it never changes from \"*\" to a number), stop the Code block that's running the Gradio app, then the submission will run. To stop the Code block, you can click on the Code block and then click the stop button."
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "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.11.3"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

README.md

@@ -1,12 +1,6 @@
 ---
-title: Age Classification
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.0.1
+title: Age_Classification
 app_file: app.py
-pinned: false
+sdk: gradio
+sdk_version: 4.44.1
 ---
-
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).

app.py

@@ -1,64 +1,576 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-
-if __name__ == "__main__":
-    demo.launch()
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Project: Model Usage - Image Classification and Transfer Learning
+
+# **Instructions for Students:**
+# 
+# Please carefully follow these steps to complete and submit your project:
+# 
+# 1. **Make a copy of the Project**: Please make a copy of this project either to your own Google Drive or download locally. Work on the copy of the project. The master project is **Read-Only**, meaning you can edit, but it will not be saved when you close the master project. To avoid total loss of your work, remember to make a copy.
+# 
+# 2. **Completing the Project**: You are required to work on and complete all tasks in the provided project. Be disciplined and ensure that you thoroughly engage with each task.
+#    
+# 3. **Creating a Google Drive Folder**: Each of you must create a new folder on your Google Drive. This will be the repository for all your completed project files, aiding you in keeping your work organized and accessible.
+#    
+# 4. **Uploading Completed Project**: Upon completion of your project, make sure to upload all necessary files, involving codes, reports, and related documents into the created Google Drive folder. Save this link in the 'Student Identity' section and also provide it as the last parameter in the `submit` function that has been provided.
+#    
+# 5. **Sharing Folder Link**: You're required to share the link to your project Google Drive folder. This is crucial for the submission and evaluation of your project.
+#    
+# 6. **Setting Permission to Public**: Please make sure your Google Drive folder is set to public. This allows your instructor to access your solutions and assess your work correctly.
+# 
+# Adhering to these procedures will facilitate a smooth project evaluation process for you and the reviewers.
+
+# ## Project Description:
+# 
+# Welcome to your new project! You will have the opportunity to apply the knowledge and skills you've learned in class.
+# 
+# The tasks are divided into two parts, the first part is to create an image classification project that predicts a person's age based on their photograph. You will be utilizing the power of machine learning pipelines to streamline your workflow and effectively manage the different stages of this project, from data preprocessing to model training and evaluation.
+# 
+# In the second part is transfer learning where you'll use a [Vision Transformer (ViT)](https://huggingface.co/google/vit-base-patch16-224-in21k) model pre-trained on ImageNet-21k and fine-tune it on the [FastJobs/Visual_Emotional_Analysis](https://huggingface.co/datasets/FastJobs/Visual_Emotional_Analysis) dataset for emotion recognition, with the final step being the publication of your trained model to the Hugging Face Model Hub.
+# 
+# Remember, the goal of this assignment is not just to build a model that makes accurate predictions, but also to understand the process of developing a machine-learning pipeline and the role each component plays in this process.
+# 
+# We encourage you to be creative, explore different strategies, and most importantly, have fun while learning. We can't wait to see the innovative solutions you come up with! Best of luck!
+
+# ## Grading Criteria
+# 
+# There are 2 tasks in this project with 5 criterias for scoring, all except Criteria 4 have the same weight. Each criteria except Criteria 4 will give you either 100 point if you are correct and 0 if you are wrong. The final score for the project will the the average of all 5 criterias from both projects.
+# 
+# * Task-1 Criteria 1: This task will assess your ability to understand how a model is likely to be used, in this use a model from Huggingface (HF) preferably using HF Pipeline, pass the input and get the correct answer form the model's output.
+# 
+# * Task-1 Criteria 2: This task will assess your ability to use Gradio as a UI (User Interface) and interact with the model, in this case, the model used in Task-1 Criteria 1.
+# 
+# * Task-2 Criteria 3: The task will assess your ability to perform transfer learning using a model from Huggingface and publish the new model to Huggingface platform.
+# 
+# * Task-2 Criteria 4: This task will assess your ability to perform transfer learning and perform an evaluation. The accuracy submitted will be used in a Bell Curve Distribution where the average accuracy score will be mapped to a score of 70. This ensures fairness since the accuracy of all students who submit their accuracy score are taken into account and distributed evenly. For example, if the average students score is 56, those who submit their accuracy as 56 will get a score of 70; student with accuracy of 43 will get a score of 60; student with accuracy of 70 will get 80; naturally there is a gradation, meaning the accuracy between 43-56 will get a score between 60 to 70 and so on.
+# 
+# * Task-2 Criteria 5: This task will assess your ability to use Gradio as a UI and interact with more than one models, in this case the model from Task-1 Criteria 1 and Task-2 Criteria 3.
+# 
+
+# ## Student Identity
+
+# ## Installation and Import Package
+
+# In[2]:
+
+
+# Install necessary packages
+#!pip install rggrader
+#from rggrader import submit, submit_image
+#!pip install transformers datasets evaluate huggingface_hub gradio rggrader accelerate -U
+# Put your code here:
+import torch
+import numpy as np
+from transformers import pipeline, AutoImageProcessor, AutoModelForImageClassification, TrainingArguments, Trainer, DefaultDataCollator
+from datasets import load_dataset
+from evaluate import load
+import gradio as gr
+from PIL import Image
+import requests
+from io import BytesIO
+import matplotlib.pyplot as plt
+from torchvision.transforms import RandomResizedCrop, Compose, Normalize, ToTensor
+from huggingface_hub import notebook_login
+# ---- End of your code ----
+
+
+# ## Task 1 Image Classification using Pipeline
+
+# ### Step 1: Image Classification using Hugging Face's Model
+# 
+# In this first task, your task is to develop an image classification pipeline that takes **an image URL as input**, displays the image, and uses the Hugging Face's model to predict the age of the person in the image. You can get the model [here](https://huggingface.co/nateraw/vit-age-classifier).
+# 
+# Here are the key steps that you might be able to follow:
+# 
+# 1. **Image URL Input:** Your program should accept an image URL as input. Make sure to handle potential issues with invalid URLs or inaccessible images.
+# 2. **Image Display:** Display the image from the URL in your notebook. This will provide a visual confirmation that the correct image is being processed.
+# 3. **Model Loading and Prediction:** Load the 'nateraw/vit-age-classifier' model from Hugging Face's model hub and pass the image URL to the model to obtain the prediction. The model should predict the age of the person in the image.
+# 4. **Output Display:** Display the output from the model in a clear and understandable manner.
+# 
+# #### Submission
+# 
+# - What percentage is the person in this picture (https://images.unsplash.com/photo-1596392927852-2a18c336fb78?ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&auto=format&fit=crop&w=1280&q=80) is between age of "3-9"?
+# 
+# Submit in the numeric format up to 5 digits behind the decimal point. For example in below output:
+# 
+# ```
+# {'0-2': '0.00152',
+#  '3-9': '0.00105',
+#  '10-19': '0.02567',
+#  '20-29': '3.32545',
+#  '30-39': '51.75200',
+#  '40-49': '40.24234',
+#  '50-59': '4.47803',
+#  '60-69': '0.17092',
+#  'more than 70': '0.00304'}
+# ```
+# 
+# The answer would be `0.00105`.
+
+# In[3]:
+
+
+# @title #### 01. Image Classification using Hugging Face's Model
+
+# Put your code here:
+def predict_age_from_url(image_url):
+    # Load the model pipeline
+    classifier = pipeline("image-classification", model="nateraw/vit-age-classifier")
+    
+    # Get the image from URL
+    response = requests.get(image_url)
+    image = Image.open(BytesIO(response.content))
+    
+    # Display the image
+    plt.imshow(image)
+    plt.axis('off')
+    plt.show()
+    
+    # Make prediction
+    predictions = classifier(image)
+    
+    # Convert to dictionary format
+    results = {pred['label']: f"{pred['score']:.5f}" for pred in predictions}
+    return results
+
+# Test the function with the given URL
+url = "https://images.unsplash.com/photo-1596392927852-2a18c336fb78?ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&auto=format&fit=crop&w=1280&q=80"
+results = predict_age_from_url(url)
+answer = results["3-9"]
+
+print(results)
+print(answer)
+
+# ---- End of your code ----
+
+
+# # Submit Method
+# assignment_id = "00_pipeline_and_gradio"
+# question_id = "01_image_classification_using_hugging_faces_model"
+# answer = "" # Put your answer here
+# submit(student_id, name, assignment_id, answer, question_id, drive_link)
+
+# ### Step 2: Image Classification using Hugging Face's Model and Gradio
+# 
+# In this second task, you will create a user-friendly interface using Gradio for your image classification pipeline that you created in Task 1. The difference with task 1 is, that in this task, you use **image files as input**, process them through the Hugging Face model, and display predictions output. The output displayed is **only the results with the highest `score`**.
+# 
+# Here are the key steps that you might be able to follow:
+# 
+# 1. **Image Input:** Create a function to accept an image file as input. The image should be in a format that can be processed by the model.
+# 2. **Model Loading and Prediction:** Load the model from Hugging Face's model hub and pass the image to the model to obtain the prediction. The model predicts the age of the person in the image.
+# 3. **Gradio Interface:** Use Gradio to create a user-friendly interface for your application. The interface should allow users to upload an image file, and it should display the model's output in a clear and understandable manner.
+# 4. **Interface Launch:** Launch the Gradio interface. Make sure that the interface is accessible and easy to use.
+# 
+# #### Submisssion
+# 
+# ![Upload colab](https://storage.googleapis.com/rg-ai-bootcamp/project-3-pipeline-and-gradio/upload-colab.png)
+# 
+# You need to submit screenshot of your Gradio's app. In Google Colab you can just use the "Folder" sidebar and click the upload button. Make sure your screenshot match below requirements:
+# 
+# - You should upload a person's image to that app
+# - The score should be included at the screenshot
+# 
+
+# In[4]:
+
+
+# @title #### 02. Image Classification using Hugging Face's Model and Gradio
+
+# Put your code here:
+
+def predict_age(image):
+    if isinstance(image, np.ndarray):  # If image is a NumPy array, convert it
+        image = Image.fromarray(image)
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    classifier = pipeline("image-classification", model="nateraw/vit-age-classifier")
+    predictions = classifier(image)
+    # Get the prediction with highest score
+    max_pred = max(predictions, key=lambda x: x['score'])
+    return {"score": round(max_pred["score"], 10), "label": max_pred["label"]}
+
+demo = gr.Interface(
+    fn=predict_age,
+    inputs=gr.Image(),
+    outputs="json",
+    title="Age Classification"
+)
+
+demo.launch(share=True)
+# ---- End of your code ----
+
+
+# Example of Expected Output:
+# 
+# ![gradio-result](https://storage.googleapis.com/rg-ai-bootcamp/project-3-pipeline-and-gradio/gradio-result.png)
+
+# # Submit Method
+# question_id = "02_image_classification_using_hugging_faces_model_and_gradio"
+# submit_image(student_id, question_id, './submission.jpg')
+# 
+
+# > Note: If your submission for Task-2 did not run (After you run it never changes from "*" to a number), stop the Code block that's running the Gradio app, then the submission will run. To stop the Code block, you can click on the Code block and then click the stop button.
+
+# # Task 2: Transfer Learning for Emotion Recognition
+
+# ### Step 1: Environment Setup
+# 
+# In this section, we start by installing the necessary packages and logging into Hugging Face's platform:
+# - `transformers`
+# - `datasets`
+# - `evaluate`
+# - `huggingface_hub`
+
+# In[5]:
+
+
+# Install necessary packages
+#!pip install datasets evaluate huggingface_hub accelerate -U
+# Put your code here:
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from transformers import TrainingArguments, Trainer, DefaultDataCollator
+from datasets import load_dataset
+from evaluate import load
+from huggingface_hub import notebook_login
+
+# ---- End of your code ----
+
+
+# After installing, use the Hugging Face's notebook login function to log into Hugging Face's platform. Execute the following commands in your cell:
+
+# In[6]:
+
+
+# Log into Hugging Face's platform
+
+# Put your code here:
+# Login to Hugging Face
+notebook_login()
+# ---- End of your code ----
+
+
+# ### Step 2: Load the Dataset
+# 
+# Load the "FastJobs/Visual_Emotional_Analysis" dataset and split it into training and test sets with a test size of 0.2.
+# 
+# > **Note**: please assign to variable `emotion`
+
+# In[7]:
+
+
+# Load the dataset and split it
+
+# Update your code here:
+emotion = load_dataset("FastJobs/Visual_Emotional_Analysis")
+emotion = emotion["train"].train_test_split(test_size=0.2)
+
+# Create label mappings
+labels = emotion["train"].features["label"].names
+label2id = {label: str(i) for i, label in enumerate(labels)}
+id2label = {str(i): label for i, label in enumerate(labels)}
+# ---- End of your code ----
+
+
+# **Label Mapping**
+# 
+# > **Note**: no need to change the code below! Just run it to map labels from the dataset.
+
+# In[8]:
+
+
+labels = emotion["train"].features["label"].names
+label2id, id2label = dict(), dict()
+for i, label in enumerate(labels):
+    label2id[label] = str(i)
+    id2label[str(i)] = label
+
+
+# ### Step 3: Explore and Visualize the Dataset
+# 
+# In this step, you are required to visualize the first instance in the training dataset.
+# 
+# > **Note**: no need to change the code below! Just run it to visualize the dataset based on index.
+
+# In[9]:
+
+
+import matplotlib.pyplot as plt
+
+# Define the function to convert label index to label name
+id2label_view = {str(i): label for i, label in enumerate(labels)}
+
+# Use first training example
+image = emotion['train'][0]['image'] # Explore image by index
+label_id = str(emotion['train'][0]['label'])
+label_name = id2label_view[label_id]
+
+# Display the image and its corresponding label
+plt.imshow(image)
+plt.title(f'Label: {label_name} (ID: {label_id})')
+plt.axis('off')
+plt.show()
+
+
+# ### Step 4: Preprocess the Data
+# 
+# You need to define the transformation function for image preprocessing and apply it to the dataset.
+
+# In[10]:
+
+
+from transformers import AutoImageProcessor
+from torchvision.transforms import RandomResizedCrop, Compose, Normalize, ToTensor
+
+# Load the image processor, Define the transforms, Define the transformation function and Apply the transformation function
+
+# Put your code here:
+image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")
+normalize = Normalize(mean=image_processor.image_mean, std=image_processor.image_std)
+size = (
+    image_processor.size["height"],
+    image_processor.size["width"],
+)
+
+transform = Compose([RandomResizedCrop(size), ToTensor(),  Normalize(mean=image_processor.image_mean, std=image_processor.image_std)])
+
+def transform_example(example):
+    image = example["image"]  # Extract image
+    image = transform(image)  # Apply transformation
+    example["pixel_values"] = image  # Store transformed image
+    del example["image"]  # Remove original image key to avoid errors
+    return example
+
+emotion_transformed = emotion.map(transform_example)
+
+# ---- End of your code ----
+
+
+# ### Step 5: Model Setup
+# 
+# In this step, define the model architecture with the pre-trained ViT model and load it.
+
+# In[11]:
+
+
+from transformers import AutoModelForImageClassification
+
+# Define the model
+
+# Put your code here:
+model = AutoModelForImageClassification.from_pretrained(
+    "google/vit-base-patch16-224-in21k",
+    num_labels=len(labels),
+    id2label=id2label,
+    label2id=label2id,
+)
+# ---- End of your code ----
+
+
+# ### Step 6: Training Setup
+# 
+# Define the training arguments and instantiate the trainer.
+
+# In[12]:
+
+
+import evaluate
+
+# Load accuracy metric
+
+# Put your code here:
+metric = load("accuracy")
+
+
+# ---- End of your code ----
+
+
+# In[13]:
+
+
+# Define compute metric function
+
+# Put your code here:
+def compute_metrics(eval_pred):
+    predictions, labels = eval_pred
+    predictions = predictions.argmax(axis=1)
+    return metric.compute(predictions=predictions, references=labels)
+
+# ---- End of your code ----
+
+
+# In[14]:
+
+
+from transformers import TrainingArguments, Trainer
+
+# Define training arguments
+
+# Update your code here:
+# Define training arguments
+training_args = TrainingArguments(
+    output_dir="emotion-classifier",
+    learning_rate=5e-5,
+    per_device_train_batch_size=16,
+    per_device_eval_batch_size=16,
+    num_train_epochs=3,
+    weight_decay=0.01,
+    evaluation_strategy="epoch",
+    save_strategy="epoch",
+    load_best_model_at_end=True,
+    push_to_hub=True,
+)
+
+# ---- End of your code ----
+
+
+# To use Hugging Face `Trainer` you need to install the `accelerate` library version `0.20.1` or later. It is used for performance enhancement on PyTorch.
+
+# In[15]:
+
+
+get_ipython().run_line_magic('pip', 'install accelerate -U')
+
+
+# In[ ]:
+
+
+from transformers import DefaultDataCollator
+
+# Instantiate the trainer
+
+# Update your code here:
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=emotion_transformed["train"],
+    eval_dataset=emotion_transformed["test"],
+    compute_metrics=compute_metrics,
+    data_collator=DefaultDataCollator(),
+)
+# ---- End of your code ----
+
+
+# If there are problems when using the Trainer after installing `accelerate` you can restart the Kernel
+
+# ### Step 7: Train and Evaluate the Model
+# 
+# Now, you are ready to train the model and evaluate it on the test set.
+
+# In[ ]:
+
+
+# Train the model
+
+# Put your code here:
+trainer.train()
+# ---- End of your code ----
+
+
+# In[ ]:
+
+
+# Evaluate the model
+
+# Update your code here:
+eval_result = trainer.evaluate()
+
+# ---- End of your code ----
+
+# Save the formatted accuracy in a variable
+accuracy_str = "{:.4f}".format(eval_result["eval_accuracy"])
+print(f"Accuracy: {accuracy_str}")
+
+
+# ### Step 8: Publishing the Trained Model
+# 
+# Finally, make sure to push your trained model to the Hugging Face Model Hub.
+# 
+# > **Note**: No need to change the code below! Just run to publish your model.
+
+# In[ ]:
+
+
+trainer.push_to_hub()
+
+
+# Once you've trained your model and pushed it to the Hugging Face Model Hub, you'll have a link that points directly to your model's page. You can share this link with others, and they can use it to directly load your model for their own uses.
+# 
+# The following link is an example of what a trained model's page looks like: https://huggingface.co/aditira/emotion_classification. This is not your model, but rather an example of what your final result might resemble.
+# 
+# Remember, for this project you should push your output model to your own Hugging Face account. The link for your model will be different and should reflect your own username and model name.
+
+# # Submit Method
+# huggingface_model_link = "" # Put your model link
+# 
+# assignment_id = "00_transfer_learning"
+# question_id = "00_emotion_recognition_huggingface"
+# submit(student_id, name, assignment_id, huggingface_model_link, question_id, drive_link)
+# 
+# question_id = "01_emotion_recognition_accuracy"
+# submit(student_id, name, assignment_id, accuracy_str, question_id, drive_link)
+
+# ### Step 9:  Build an Interactive Application with Gradio
+
+# In this task, you will be building an interactive application using Gradio that will use your fine-tuned emotion recognition model along with another pretrained model ('`nateraw/vit-age-classifier`') to guess the emotion and age from an input image.
+# 
+# Please make sure to:
+# - Install the necessary package (`gradio`) for creating the web-based interface.
+# - Load your fine-tuned model as well as the pretrained model '`nateraw/vit-age-classifier`'.
+# - Define a function that will take an image as input and return the predicted emotion and age.
+# - Utilize Gradio to create an Interface (UI) for your function, allowing users to upload images and see the predicted emotion and age.
+
+# In[ ]:
+
+
+# Install Gradio
+get_ipython().system('pip install gradio')
+
+
+# #### Submisssion
+# 
+# ![Upload colab](https://storage.googleapis.com/rg-ai-bootcamp/project-3-pipeline-and-gradio/upload-colab.png)
+# 
+# You need to submit screenshot of your Gradio's app. In Google Colab you can just use the "Folder" sidebar and click the upload button. Make sure your screenshot match below requirements:
+# 
+# - Image name screenshot is `submission.jpg`
+# - You should upload a person's image to that app
+# - The score should be included at the screenshot
+
+# In[ ]:
+
+
+# Put your code here:
+def predict_age_and_emotion(image):
+    # Age prediction
+    age_classifier = pipeline("image-classification", model="nateraw/vit-age-classifier")
+    age_pred = age_classifier(image)
+    max_age_pred = max(age_pred, key=lambda x: x['score'])
+    
+    # Emotion prediction
+    # Replace YOUR_USERNAME with your actual Hugging Face username
+    emotion_classifier = pipeline("image-classification", model="YOUR_USERNAME/emotion-classifier")
+    emotion_pred = emotion_classifier(image)
+    max_emotion_pred = max(emotion_pred, key=lambda x: x['score'])
+    
+    return (
+        f"Age: {max_age_pred['label']} (confidence: {max_age_pred['score']:.5f})",
+        f"Emotion: {max_emotion_pred['label']} (confidence: {max_emotion_pred['score']:.5f})"
+    )
+
+demo_combined = gr.Interface(
+    fn=predict_age_and_emotion,
+    inputs=gr.Image(),
+    outputs=["text", "text"],
+    title="Age and Emotion Classification"
+)
+
+demo_combined.launch()
+# ---- End of your code ----
+
+
+# Example of Expected Output:
+# 
+# ![gradio-result](https://storage.googleapis.com/rg-ai-bootcamp/project-4-transfer-learning/gradio_emotion_age_app.png)
+
+# > Note: If your submission for Task-2 did not run (After you run it never changes from "*" to a number), stop the Code block that's running the Gradio app, then the submission will run. To stop the Code block, you can click on the Code block and then click the stop button.

emotion-classifier/runs/Feb23_03-09-15_LAPTOP-VKSJJT34/events.out.tfevents.1740255001.LAPTOP-VKSJJT34.10956.0

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

emotion-classifier/runs/Feb23_03-21-00_LAPTOP-VKSJJT34/events.out.tfevents.1740255792.LAPTOP-VKSJJT34.10956.1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41089a6c3f2ddc3f7883da97570aa90d19546a73557e8f2b042d134c02c029c3
+size 5256

emotion-classifier/runs/Feb23_03-27-01_LAPTOP-VKSJJT34/events.out.tfevents.1740256033.LAPTOP-VKSJJT34.21776.0

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

nyoba-03A.ipynb

@@ -0,0 +1,485 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_8ZwOksxZ0-q"
+      },
+      "source": [
+        "# Project: Deep Learning - Calculations"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_R3K9DR2Z0-r"
+      },
+      "source": [
+        "**Instructions for Students:**\n",
+        "\n",
+        "Please carefully follow these steps to complete and submit your project:\n",
+        "\n",
+        "1. **Make a copy of the Project**: Please make a copy of this project either to your own Google Drive or download locally. Work on the copy of the project. The master project is **Read-Only**, meaning you can edit, but it will not be saved when you close the master project. To avoid total loss of your work, remember to make a copy.\n",
+        "\n",
+        "2. **Completing the Project**: You are required to work on and complete all tasks in the provided project. Be disciplined and ensure that you thoroughly engage with each task.\n",
+        "   \n",
+        "3. **Creating a Google Drive Folder**: Each of you must create a new folder on your Google Drive. This will be the repository for all your completed project files, aiding you in keeping your work organized and accessible.\n",
+        "   \n",
+        "4. **Uploading Completed Project**: Upon completion of your project, make sure to upload all necessary files, involving codes, reports, and related documents into the created Google Drive folder. Save this link in the 'Student Identity' section and also provide it as the last parameter in the `submit` function that has been provided.\n",
+        "   \n",
+        "5. **Sharing Folder Link**: You're required to share the link to your project Google Drive folder. This is crucial for the submission and evaluation of your project.\n",
+        "   \n",
+        "6. **Setting Permission to Public**: Please make sure your Google Drive folder is set to public. This allows your instructor to access your solutions and assess your work correctly.\n",
+        "\n",
+        "Adhering to these procedures will facilitate a smooth project evaluation process for you and the reviewers."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "XeK2fKDrZ0-s"
+      },
+      "source": [
+        "## Project Description\n",
+        "\n",
+        "The Deep Learning Projects are divided into two parts, the first is the Calculations worth 30% in this notebook and the second one is Pytorch Project worth 70%.\n",
+        "\n",
+        "The two projects will help you gain experience to learn about Deep Learning in detail.\n",
+        "\n",
+        "Happy coding!"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Lgd8szRCZ0-t"
+      },
+      "source": [
+        "## Grading Criteria\n",
+        "\n",
+        "There are 4 primary tasks in this project, all have the same weight. Each task will give you either 100 point if you are correct and 0 if you are wrong. The final score for the project will the the average of all 4 tasks.\n",
+        "\n",
+        "There is also an optional task (Task 5) that you can do to challenge your understanding.\n",
+        "\n",
+        "* Task 1: This task will assess your ability to do basic matrix multiplication which is an important part in machine and deep learning.\n",
+        "\n",
+        "* Task 2: This task will assess your ability to understand how a neural network work through weight and biases.\n",
+        "\n",
+        "* Task 3: The task will assess your ability to understand how a neural network layer works.\n",
+        "\n",
+        "* Task 4: This task will assess your ability to understand how backpropagation works in a neural network.\n",
+        "\n",
+        "* Task 5 (optional): This task will assess your ability to understand how to calculate cost and why it's important by using backpropagation in a neural network.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "W1dT1yHmZ0-t"
+      },
+      "source": [
+        "## Student Identity"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "TuVolX9FZ0-u"
+      },
+      "source": [
+        "## Import package"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Pl3QEX2HZ0-u"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt \n",
+        "import graphviz"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "4gtGSA8SZ0-v"
+      },
+      "source": [
+        "\n",
+        "## Task 1\n",
+        "\n",
+        "Given\n",
+        "\n",
+        "$$\n",
+        "X = \\begin{bmatrix}\n",
+        "a \\\\\n",
+        "b \\\\\n",
+        "c \\\\\n",
+        "d \\\\\n",
+        "e\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "and\n",
+        "\n",
+        "$$\n",
+        "M =\n",
+        "\\begin{bmatrix}\n",
+        "-2 & 3 & 3 & 3 & -4 \\\\\n",
+        "0 & -4 & -1 & 1 & 2 \\\\\n",
+        "1 & 5 & 4 & 2 & 0 \\\\\n",
+        "-2 & 5 & -5 & 3 & 1 \\\\\n",
+        "-3 & 2 & 4 & 3 & 4 \\\\\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "and\n",
+        "\n",
+        "$$\n",
+        "M \\cdot X =\n",
+        " =\n",
+        "\\begin{bmatrix}\n",
+        "-33 \\\\\n",
+        "9 \\\\\n",
+        "-34 \\\\\n",
+        "-38 \\\\\n",
+        " -40\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "What is the value of $a + b + c + d + e$?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "JCwFuKpEZ0-v"
+      },
+      "outputs": [],
+      "source": [
+        "# You may add any code here to derive your variables\n",
+        "# Please change this\n",
+        "M = np.array([\n",
+        "    [-2, 3, 3, 3, -4],\n",
+        "    [0, -4, -1, 1, 2],\n",
+        "    [1, 5, 4, 2, 0],\n",
+        "    [-2, 5, -5, 3, 1],\n",
+        "    [-3, 2, 4, 3, 4]\n",
+        "])\n",
+        "\n",
+        "MX = np.array([-33, 9, -34, -38, -40])\n",
+        "\n",
+        "# Solve for X\n",
+        "X = np.linalg.solve(M, MX)\n",
+        "\n",
+        "# Calculate the sum of a, b, c, d, e\n",
+        "total = np.sum(X)\n",
+        "\n",
+        "\n",
+        "print(f\"The total is {total}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "AnzwjHI5Z0-v"
+      },
+      "source": [
+        "## Task 2\n",
+        "\n",
+        "What is the output of the following Neural Network?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "5Dhvs1l-Z0-v",
+        "outputId": "8fec2c6f-eb16-4791-bcee-d3414a8b7fab"
+      },
+      "outputs": [],
+      "source": [
+        "from fastbook import *\n",
+        "\n",
+        "\n",
+        "# Draw neurons with multiple inputs and weights\n",
+        "gv('''\n",
+        "z_1[shape=box3d width=1 height=0.7 label=\"b = -2, ReLU\"];\n",
+        "z_2[shape=box3d width=1 height=0.7 label=\"b = -6, ReLU\"];\n",
+        "z_3[shape=box3d width=1 height=0.7 label=\"b = 4, ReLU\"];\n",
+        "input_1[width=1 height=0.7 label=\"4\"];\n",
+        "input_2[width=1 height=0.7 label=\"-3\"];\n",
+        "input_1 -> z_1 [label=\"4\"]\n",
+        "input_2 -> z_1 [label=\"2\"]\n",
+        "input_1 -> z_2 [label=\"0\"]\n",
+        "input_2 -> z_2 [label=\"-1\"]\n",
+        "\n",
+        "z_1 -> z_3 [label=\"2\"]\n",
+        "z_2 -> z_3 [label=\"3\"]\n",
+        "z_3 ->output\n",
+        "\n",
+        "\n",
+        "''')\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "jtzFBQeIZ0-w"
+      },
+      "outputs": [],
+      "source": [
+        "# You may add any code here to derive your variables\n",
+        "\n",
+        "# Inputs\n",
+        "input_1 = 4  # This is the first input\n",
+        "input_2 = -3  # This is the second input\n",
+        "\n",
+        "# Weights and biases\n",
+        "w1 = np.array([4, 2])  # Weights for the first neuron (z1)\n",
+        "w2 = np.array([0, -1])  # Weights for the second neuron (z2)\n",
+        "b1 = -2  # Bias for the first neuron (z1)\n",
+        "b2 = -6  # Bias for the second neuron (z2)\n",
+        "\n",
+        "# Calculate z1 and z2\n",
+        "z1 = max(0, input_1 * w1[0] + input_2 * w1[1] + b1)  # ReLU activation for z1\n",
+        "z2 = max(0, input_1 * w2[0] + input_2 * w2[1] + b2)  # ReLU activation for z2\n",
+        "\n",
+        "# Weights and bias for the next layer\n",
+        "w3 = np.array([2, 3])  # Weights for the output neuron\n",
+        "b3 = 4  # Bias for the output neuron\n",
+        "\n",
+        "# Calculate the output\n",
+        "output = max(0, z1 * w3[0] + z2 * w3[1] + b3)\n",
+        "\n",
+        "\n",
+        "print(f\"The output is {output}\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nw5Rc4_QZ0-w"
+      },
+      "source": [
+        "## Task 3\n",
+        "\n",
+        "Given the following Neural Networks:\n",
+        "\n",
+        "First layer:\n",
+        "\n",
+        "$$\n",
+        "W = \\begin{bmatrix}\n",
+        "0.23 & 0.67 & 0.12 \\\\\n",
+        "-0.89 & -0.45 & 0.78 \\\\\n",
+        "0.34 & 0.56 & -0.90 \\\\\n",
+        "-0.12 & 0.34 & 0.56 \\\\\n",
+        "0.78 & -0.90 & 0.23 \\\\\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "$$\n",
+        "bias = \\begin{bmatrix}\n",
+        "0.23 \\\\\n",
+        "-0.89 \\\\\n",
+        "0.34 \\\\\n",
+        "0.12 \\\\\n",
+        "-0.78 \\\\\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "Second layer:\n",
+        "\n",
+        "$$\n",
+        "W = \\begin{bmatrix}\n",
+        "0.23 & 0.67 & 0.12 & 0.45 & 0.89 \\\\\n",
+        "0.12 & 0.34 & 0.56 & 0.78 & 0.90 \\\\\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "$$\n",
+        "bias = \\begin{bmatrix}\n",
+        "1.96 \\\\\n",
+        "-1.08 \\\\\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "Third layer:\n",
+        "$$\n",
+        "W = \\begin{bmatrix}\n",
+        "1.08 & -0.16\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "$$\n",
+        "bias = \\begin{bmatrix}\n",
+        "-2.8\n",
+        "\\end{bmatrix}\n",
+        "$$\n",
+        "\n",
+        "All layers use the ReLU activation function.\n",
+        "\n",
+        "What is the output given the following inputs?\n",
+        "\n",
+        "$$\n",
+        "X = \\begin{bmatrix}\n",
+        "1 \\\\\n",
+        "2 \\\\\n",
+        "4 \\\\\n",
+        "\\end{bmatrix}\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "4d8Oibi1Z0-x"
+      },
+      "outputs": [],
+      "source": [
+        "# You may add any code here to derive your variables\n",
+        "# Input\n",
+        "X = np.array([1, 2, 4])\n",
+        "\n",
+        "# First layer weights and biases\n",
+        "W1 = np.array([\n",
+        "    [0.23, 0.67, 0.12],\n",
+        "    [-0.89, -0.45, 0.78],\n",
+        "    [0.34, 0.56, -0.90],\n",
+        "    [-0.12, 0.34, 0.56],\n",
+        "    [0.78, -0.90, 0.23]\n",
+        "])\n",
+        "b1 = np.array([0.23, -0.89, 0.34, 0.12, -0.78])\n",
+        "\n",
+        "# Second layer weights and biases\n",
+        "W2 = np.array([\n",
+        "    [0.23, 0.67, 0.12, 0.45, 0.89],\n",
+        "    [0.12, 0.34, 0.56, 0.78, 0.90]\n",
+        "])\n",
+        "b2 = np.array([1.96, -1.08])\n",
+        "\n",
+        "# Third layer weights and biases\n",
+        "W3 = np.array([1.08, -0.16])\n",
+        "b3 = np.array([-2.8])\n",
+        "\n",
+        "# First layer calculation\n",
+        "z1 = np.maximum(0, np.dot(W1, X) + b1)\n",
+        "\n",
+        "# Second layer calculation\n",
+        "z2 = np.maximum(0, np.dot(W2, z1) + b2)\n",
+        "\n",
+        "# Third layer calculation\n",
+        "output = np.maximum(0, np.dot(W3, z2) + b3)\n",
+        "\n",
+        "print(f\"The output is {output}\")\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Vn5o5XmfZ0-x"
+      },
+      "source": [
+        "## Task 4\n",
+        "\n",
+        "Given [the following sheet (sheet name = Project A)](https://docs.google.com/spreadsheets/d/15JWbRFB4k5CNcfD-2hduHHssXIc1SGhNVSpu_30wVAw/edit#gid=180755192)\n",
+        "\n",
+        "Make a backpropagation algorithm to train the network. You can refer to AND and NOT sheet. Use sigmoid activation function for all\n",
+        "\n",
+        "Hint: it needs 1 layer with 1 neuron\n",
+        "\n",
+        "What is the cost at 10th iteration (the iteration start from 1)?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "d2aSUbaaZ0-x"
+      },
+      "outputs": [],
+      "source": [
+        "# Please clone the Google Sheet and do your calculation there\n",
+        "\n",
+        "# Please change this\n",
+        "cost = 0\n",
+        "\n",
+        "# Don't forget to fill in the link to your Google Sheet\n",
+        "link_to_gsheet = \"\"\n",
+        "\n",
+        "print(f\"The cost is {cost}\")\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Kh7uzjtDZ0-x"
+      },
+      "source": [
+        "## Task 5 (Bonus - Optional)\n",
+        "\n",
+        "_This task is optional, it will earn you a distinction, but will not give you additional points._\n",
+        "\n",
+        "Given [the following sheet (sheet name = Project B)](https://docs.google.com/spreadsheets/d/15JWbRFB4k5CNcfD-2hduHHssXIc1SGhNVSpu_30wVAw/edit#gid=1029811725)\n",
+        "\n",
+        "Make a backpropagation algorithm to train the network. You can refer to AND and NOT sheet. Use sigmoid activation function for all\n",
+        "\n",
+        "Hint: it needs 2 layer (1 hidden layer + 1 output layer). The hidden layer has 2 neurons\n",
+        "\n",
+        "What is the cost at 10th iteration (the iteration start from 1)?"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "KJJOi3V1Z0-x"
+      },
+      "outputs": [],
+      "source": [
+        "# Please clone the Google Sheet and do your calculation there\n",
+        "\n",
+        "# Please change this\n",
+        "cost = 0\n",
+        "\n",
+        "# Don't forget to fill in the link to your Google Sheet\n",
+        "link_to_gsheet = \"\"\n",
+        "\n",
+        "print(f\"The cost is {cost}\")\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.9.6"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

nyoba-03B.ipynb

@@ -0,0 +1,536 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "def8e46c-7606-4991-9b29-9223ccacd54b",
+      "metadata": {
+        "id": "def8e46c-7606-4991-9b29-9223ccacd54b"
+      },
+      "source": [
+        "# Project: Deep Learning - Pytorch"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "911a145c-7d01-4210-9699-0e1fef80ff19",
+      "metadata": {
+        "id": "911a145c-7d01-4210-9699-0e1fef80ff19"
+      },
+      "source": [
+        "**Instructions for Students:**\n",
+        "\n",
+        "Please carefully follow these steps to complete and submit your project:\n",
+        "\n",
+        "1. **Make a copy of the Project**: Please make a copy of this project either to your own Google Drive or download locally. Work on the copy of the project. The master project is **Read-Only**, meaning you can edit, but it will not be saved when you close the master project. To avoid total loss of your work, remember to make a copy.\n",
+        "\n",
+        "2. **Completing the Project**: You are required to work on and complete all tasks in the provided project. Be disciplined and ensure that you thoroughly engage with each task.\n",
+        "   \n",
+        "3. **Creating a Google Drive Folder**: Each of you must create a new folder on your Google Drive. This will be the repository for all your completed project files, aiding you in keeping your work organized and accessible.\n",
+        "   \n",
+        "4. **Uploading Completed Project**: Upon completion of your project, make sure to upload all necessary files, involving codes, reports, and related documents into the created Google Drive folder. Save this link in the 'Student Identity' section and also provide it as the last parameter in the `submit` function that has been provided.\n",
+        "   \n",
+        "5. **Sharing Folder Link**: You're required to share the link to your project Google Drive folder. This is crucial for the submission and evaluation of your project.\n",
+        "   \n",
+        "6. **Setting Permission to Public**: Please make sure your Google Drive folder is set to public. This allows your instructor to access your solutions and assess your work correctly.\n",
+        "\n",
+        "Adhering to these procedures will facilitate a smooth project evaluation process for you and the reviewers."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "d3b9e0f7-75d2-476a-9b29-07c1a3800925",
+      "metadata": {
+        "id": "d3b9e0f7-75d2-476a-9b29-07c1a3800925"
+      },
+      "source": [
+        "## Project Description\n",
+        "\n",
+        "The Deep Learning Projects are divided into two parts, the first is the Calculations worth 30% and the second one is Pytorch Project worth 70% in this notebook.\n",
+        "\n",
+        "The two projects will help you gain experience to learn about Deep Learning in detail.\n",
+        "\n",
+        "In this project, you will use what you learn to create your own Deep Learning model. We'll use a variety of datasets, each with different data types such as images, text, and numerical/categorical data. Your task is to choose one of these datasets and build a deep learning model upon it.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "d333f8fe-3ae6-4060-b597-e9f7d9e37582",
+      "metadata": {
+        "id": "d333f8fe-3ae6-4060-b597-e9f7d9e37582"
+      },
+      "source": [
+        "## Datasets\n",
+        "\n",
+        "Choose one from the following datasets for your project:\n",
+        "\n",
+        "1. **Digits Dataset**: A simplified version of MNIST containing 8x8 images of hand-written digits. [Dataset Link](https://scikit-learn.org/stable/auto_examples/datasets/plot_digits_last_image.html)\n",
+        "2. **Dogs vs. Cats Dataset from Kaggle**: A sizable dataset of 25,000 images with equal representation of dogs and cats. [Dataset Link](https://www.kaggle.com/c/dogs-vs-cats)\n",
+        "3. **Breast Cancer Wisconsin (Diagnostic) Dataset**: Computed features from a digitized image of a fine needle aspirate (FNA) of a breast mass. [Dataset Link](https://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+%28Diagnostic%29)\n",
+        "4. **Spam Text Message Classification Dataset**: A collection of labeled SMS messages, categorized as \"spam\" or \"ham\". [Dataset Link](https://www.kaggle.com/uciml/sms-spam-collection-dataset)\n",
+        "5. **German Credit Risk Dataset**: People's data categorized by various attributes to predict credit risk. [Dataset Link](https://archive.ics.uci.edu/ml/datasets/Statlog+%28German+Credit+Data%29)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "84fea308-2c09-472c-a5ec-e4ba0900d496",
+      "metadata": {
+        "id": "84fea308-2c09-472c-a5ec-e4ba0900d496"
+      },
+      "source": [
+        "\n",
+        "## Grading Criteria\n",
+        "\n",
+        "Your work will be evaluated based on both accuracy and loss value:\n",
+        "\n",
+        "100: The model has an accuracy of more than 80% and a Loss Value of less than 0.2. This model is excellent and demonstrates a strong understanding of the task.\n",
+        "\n",
+        "90: The model has an accuracy between 70% - 79% and a Loss Value between 0.2 - 0.3. This model is very good, with some room for improvement.\n",
+        "\n",
+        "80: The model has an accuracy between 60% - 69% and a Loss Value between 0.3 - 0.4. This model is fairly good but needs improvement in balancing accuracy and loss value.\n",
+        "\n",
+        "70: The model has an accuracy between 50% - 59% and a Loss Value between 0.4 - 0.5. This model is below average and needs significant improvement.\n",
+        "\n",
+        "60 or below: The model has an accuracy of less than 50% or a Loss Value of more than 0.5, or the student did not submit the accuracy and Loss Value. This model is poor and needs considerable improvement."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "915df21b-3a7e-444a-999d-c830acdbe7f2",
+      "metadata": {
+        "id": "915df21b-3a7e-444a-999d-c830acdbe7f2"
+      },
+      "source": [
+        "Rmember to make a copy of this notebook in your Google Drive and work in your own copy.\n",
+        "\n",
+        "Let's start your deep learning journey! Choose your dataset and delve into the project! Happy modeling!"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "8018f21d-d661-4ae4-a50d-9fb66feb291d",
+      "metadata": {
+        "id": "8018f21d-d661-4ae4-a50d-9fb66feb291d"
+      },
+      "source": [
+        "## Student Identity"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "e0b68327-fc7b-43de-9f16-b058d11d775b",
+      "metadata": {
+        "id": "e0b68327-fc7b-43de-9f16-b058d11d775b"
+      },
+      "source": [
+        "## Project Structure\n",
+        "\n",
+        "Your project should be organized into five main sections."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "25ecc459-5019-42d8-84a6-8644cecafef3",
+      "metadata": {
+        "id": "25ecc459-5019-42d8-84a6-8644cecafef3"
+      },
+      "source": [
+        "### 1. Package and Module Installation\n",
+        "\n",
+        "First, let's pool all package and module that you'll need in the installation section below."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "62606ca1-5868-4c65-93ef-1d6ee8d8d59a",
+      "metadata": {
+        "id": "62606ca1-5868-4c65-93ef-1d6ee8d8d59a"
+      },
+      "outputs": [],
+      "source": [
+        "# Write any package/module installation that you need\n",
+        "# pip install goes here, this helps declutter your output below\n",
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "from ucimlrepo import fetch_ucirepo \n",
+        "import plotly.graph_objects as go\n",
+        "from plotly.subplots import make_subplots\n",
+        "from sklearn.preprocessing import LabelEncoder\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "import torch.optim as optim\n",
+        "from torch.utils.data import Dataset, DataLoader\n",
+        "from sklearn.preprocessing import StandardScaler\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "b0837717-de95-4193-9898-e2f4cadfcfc6",
+      "metadata": {
+        "id": "b0837717-de95-4193-9898-e2f4cadfcfc6"
+      },
+      "source": [
+        "### 2. Data Loading and Preprocessing\n",
+        "\n",
+        "Load the chosen dataset and preprocess it for deep learning."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "6458c396",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Fetch dataset from UCI repository based on documentation\n",
+        "breast_cancer_wisconsin_diagnostic = fetch_ucirepo(id=17)\n",
+        "\n",
+        "# Extract features (X) and target labels (y) based on documentation\n",
+        "X = breast_cancer_wisconsin_diagnostic.data.features  # Features as pandas DataFrame\n",
+        "y = breast_cancer_wisconsin_diagnostic.data.targets  # Target as pandas DataFrame\n",
+        "\n",
+        "# Combine features and target into a single DataFrame for visualization\n",
+        "df = pd.concat([X, y], axis=1)\n",
+        "\n",
+        "# Display first 5 rows of the full dataset\n",
+        "print(df.head())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "f052beb7",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(df.tail())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "db941354",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "df.info()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "cd4056ec",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "df.describe()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "26e0715f",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "df.isnull().sum()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "b5512b49",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "df.shape"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "fa185a09",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Visualize feature distributions in a grid layout\n",
+        "features = df.columns[2:]  # Select the feature columns\n",
+        "num_features = len(features)\n",
+        "num_cols = 3  # Number of columns in the grid\n",
+        "num_rows = (num_features + num_cols - 1) // num_cols  # Calculate the number of rows\n",
+        "\n",
+        "fig = make_subplots(rows=num_rows, cols=num_cols, subplot_titles=features)\n",
+        "\n",
+        "for i, feature in enumerate(features):\n",
+        "    row = i // num_cols + 1\n",
+        "    col = i % num_cols + 1\n",
+        "    \n",
+        "    # Plot the histogram for the current feature\n",
+        "    fig.add_trace(go.Histogram(x=df[df['Diagnosis'] == 'M'][feature], name='Malignant', opacity=0.7), row=row, col=col)\n",
+        "    fig.add_trace(go.Histogram(x=df[df['Diagnosis'] == 'B'][feature], name='Benign', opacity=0.7), row=row, col=col)\n",
+        "    \n",
+        "    # Set subplot title\n",
+        "    fig.update_xaxes(title_text=feature, row=row, col=col)\n",
+        "\n",
+        "# Update layout\n",
+        "fig.update_layout(showlegend=False, height=2000, width=1500, title_text=\"Feature Distributions\")\n",
+        "\n",
+        "fig.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "20848bd8",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Calculate the correlation matrix\n",
+        "cor = df.corr()\n",
+        "\n",
+        "# Create the heatmap trace\n",
+        "heatmap = go.Heatmap(\n",
+        "    z=cor.values,\n",
+        "    x=cor.columns,\n",
+        "    y=cor.columns,\n",
+        "    colorscale='RdBu',\n",
+        "    colorbar=dict(title='Correlation')\n",
+        ")\n",
+        "\n",
+        "# Create the layout\n",
+        "layout = go.Layout(\n",
+        "    title='Correlation Matrix',\n",
+        "    xaxis=dict(title='Features'),\n",
+        "    yaxis=dict(title='Features'),\n",
+        ")\n",
+        "\n",
+        "# Create the figure and add the trace\n",
+        "fig = go.Figure(data=[heatmap], layout=layout)\n",
+        "\n",
+        "# Show the figure\n",
+        "fig.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "30ce0c59-0e94-480a-81ae-528e68356a15",
+      "metadata": {
+        "id": "30ce0c59-0e94-480a-81ae-528e68356a15"
+      },
+      "source": [
+        "### 3. Model Building\n",
+        "\n",
+        "Define your deep learning model's architecture."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "1aa3c3f7-c6c5-4419-9b25-e8d7a8ec345a",
+      "metadata": {
+        "id": "1aa3c3f7-c6c5-4419-9b25-e8d7a8ec345a"
+      },
+      "outputs": [],
+      "source": [
+        "# Write your code here for Model Building here\n",
+        "label_encoder = LabelEncoder()\n",
+        "df['Diagnosis'] = label_encoder.fit_transform(df['Diagnosis'])\n",
+        "# define your Deep Learning Model here, training is in the next section.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "cfeaeee7",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "features = df.drop(columns=['Diagnosis']).values\n",
+        "labels = df['Diagnosis'].values\n",
+        "\n",
+        "X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=42)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "c94dbf5d",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Convert the data to PyTorch tensors\n",
+        "X_train = torch.tensor(X_train, dtype=torch.float32)\n",
+        "X_test = torch.tensor(X_test, dtype=torch.float32)\n",
+        "y_train = torch.tensor(y_train, dtype=torch.long)\n",
+        "y_test = torch.tensor(y_test, dtype=torch.long)\n",
+        "\n",
+        "# Define the model architecture in PyTorch\n",
+        "class DiseaseClassifier(nn.Module):\n",
+        "    def __init__(self, input_dim, hidden_dim, output_dim):\n",
+        "        super(DiseaseClassifier, self).__init__()\n",
+        "        self.fc1 = nn.Linear(input_dim, hidden_dim)\n",
+        "        self.relu = nn.ReLU()\n",
+        "        self.fc2 = nn.Linear(hidden_dim, output_dim)\n",
+        "        \n",
+        "    def forward(self, x):\n",
+        "        out = self.fc1(x)\n",
+        "        out = self.relu(out)\n",
+        "        out = self.fc2(out)\n",
+        "        return out\n",
+        "\n",
+        "# Define the hyperparameters\n",
+        "input_dim = X_train.shape[1]\n",
+        "hidden_dim = 64\n",
+        "output_dim = 2\n",
+        "learning_rate = 0.001\n",
+        "num_epochs = 10\n",
+        "batch_size = 16\n",
+        "\n",
+        "# Create an instance of the model\n",
+        "model = DiseaseClassifier(input_dim, hidden_dim, output_dim)\n",
+        "\n",
+        "# Define the loss function and optimizer\n",
+        "criterion = nn.CrossEntropyLoss()\n",
+        "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
+        "\n",
+        "# Create data loaders for batching\n",
+        "train_dataset = torch.utils.data.TensorDataset(X_train, y_train)\n",
+        "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "585b925f-fcf0-4518-81d8-598dba65d646",
+      "metadata": {
+        "id": "585b925f-fcf0-4518-81d8-598dba65d646"
+      },
+      "source": [
+        "### 4. Model Training\n",
+        "\n",
+        "Train your model and evaluate its performance using validation data."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "ee33d9bc-2b35-4f78-b5d8-3eb65db1e361",
+      "metadata": {
+        "id": "ee33d9bc-2b35-4f78-b5d8-3eb65db1e361"
+      },
+      "outputs": [],
+      "source": [
+        "# Write your code here for Model Training here\n",
+        "#dl_loss_value = 1\n",
+        "\n",
+        "#define the iteration\n",
+        "\n",
+        "#create the training loop\n",
+        "# Training loop\n",
+        "for epoch in range(num_epochs):\n",
+        "    running_loss = 0.0\n",
+        "    for inputs, labels in train_loader:\n",
+        "        # Zero the gradients\n",
+        "        optimizer.zero_grad()\n",
+        "        \n",
+        "        # Forward pass\n",
+        "        outputs = model(inputs)\n",
+        "        \n",
+        "        # Compute the loss\n",
+        "        loss = criterion(outputs, labels)\n",
+        "        \n",
+        "        # Backward pass and optimization\n",
+        "        loss.backward()\n",
+        "        optimizer.step()\n",
+        "        \n",
+        "        # Track the loss\n",
+        "        running_loss += loss.item()\n",
+        "        \n",
+        "    # Print the average loss for the epoch\n",
+        "    print(f\"Epoch {epoch+1}/{num_epochs}, Loss: {running_loss / len(train_loader)}\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "1d391ec9-ca95-4c56-b4f6-fccf8e0be14a",
+      "metadata": {
+        "id": "1d391ec9-ca95-4c56-b4f6-fccf8e0be14a"
+      },
+      "source": [
+        "### 5. Model Evaluation\n",
+        "Evaluate your model's performance on the test data using the grading scheme defined above."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "c8ca8f78-e33c-4552-9f4d-8bed711e661f",
+      "metadata": {
+        "id": "c8ca8f78-e33c-4552-9f4d-8bed711e661f"
+      },
+      "outputs": [],
+      "source": [
+        "# Write your code here for Model Evaluation here\n",
+        "# dl_accuracy = 0\n",
+        "\n",
+        "#define the iteration\n",
+        "\n",
+        "#create the training loop\n",
+        "with torch.no_grad():\n",
+        "    model.eval()\n",
+        "    outputs = model(X_test)\n",
+        "    _, predicted = torch.max(outputs.data, 1)\n",
+        "    accuracy = (predicted == y_test).sum().item() / y_test.size(0)\n",
+        "\n",
+        "print(f\"\\nFinal Test Accuracy: {accuracy * 100:.2f}%\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "5d59af48-18c0-4e40-80ff-33a85030b205",
+      "metadata": {
+        "id": "5d59af48-18c0-4e40-80ff-33a85030b205"
+      },
+      "source": [
+        "## Submission\n",
+        "\n",
+        "Once you are satisfied with the performance of your model, then you run the code block below to submit your project.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "aa89b9ff-0d31-416a-b3c4-851c725fadf7",
+      "metadata": {
+        "id": "aa89b9ff-0d31-416a-b3c4-851c725fadf7"
+      },
+      "source": [
+        "## FIN"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.9.6"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}