ex4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ex4.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OML25K1Bv3L2"
      },
      "source": [
        "# 課題4 テキストデータ分析\n",
        "配点\n",
        "- Q1, 1P\n",
        "- Q2, 2P\n",
        "- Q3, 4P\n",
        "- Q4, 3P"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I_2I7_5hv7JW"
      },
      "source": [
        "# 必要なモジュールのimport\n",
        "import numpy as np\n",
        "import pandas as pd"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DpAaCPlLwEsU"
      },
      "source": [
        "## Q1\n",
        "$n$-次元ベクトル空間における、任意の2つのベクトル、$ \\vec{x}=(x_1,x_2,...,x_n)$、$\\vec{y}=(y_1,y_2,...,y_n)$、の間のcos類似度 $cos( \\vec{x}, \\vec{y})$ は以下のように定義されます。\n",
        "\n",
        "$cos( \\vec{x}, \\vec{y}) =  \\frac{\\vec{x}\\cdot \\vec{y}}{\\|x\\|_2\\|y\\|_2}=\\frac{\\Sigma^{n}_{i=1}{x_{i}y_{i}}}{\\sqrt{\\Sigma^{n}_{i=1}x_{i}^{2}}\\sqrt{\\Sigma^{n}_{i=1}y_{i}^{2}}}$\n",
        "\n",
        "入力ベクトル $\\vec{x}$, $\\vec{y}$ をそれぞれ`NumPy` の配列として引数で受け取り、それらのベクトル間のcos類似度を計算して返す関数 `cos_sim` を完成させてください。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q5g57zSEwM7M",
        "exercise_id": "q1",
        "inlinetests": {
          "InlineTest_1": "\ntry:\n  import numpy as np\n  assert 0.82 == round(cos_sim(np.array([1,0,1]), np.array([1,1,1])), 2), f\"'cos_sim(np.array([1,0,1]), np.array([1,1,1]))' returns {cos_sim(np.array([1,0,1]), np.array([1,1,1]))}, while the expected answer is {0.816}...\"\n  assert 1 == round(cos_sim(np.array([1,1,1]), np.array([1,1,1])), 2), f\"'cos_sim(np.array([1,1,1]), np.array([1,1,1]))' returns {cos_sim(np.array([1,1,1]), np.array([1,1,1]))}, while the expected answer is {1.0}\"\n  assert -1 == round(cos_sim(np.array([-1,-1,-1]), np.array([1,1,1])), 2), f\"'cos_sim(np.array([-1,-1,-1]), np.array([1,1,1]))' returns {cos_sim(np.array([-1,-1,-1]), np.array([1,1,1]))}, while the expected answer is {-1.0}\"\nexcept AssertionError as e:\n    raise e\nexcept Exception as e:\n    assert False, f\"Your function raises an exception: {e}.\""
        }
      },
      "source": [
        "def cos_sim(vec1, vec2):\n",
        "  return np.dot(vec1, vec2) / (np.sqrt(np.dot(vec1, vec1)) * np.sqrt(np.dot(vec2, vec2)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oGhCfrk9www9"
      },
      "source": [
        "`cos_sim()`関数が完成したら、以下のセルを実行して動作を確認してください。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6PBnF_Viwzak",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6417500f-b9ad-46d7-be12-390e34ffa9c8"
      },
      "source": [
        "print(round(cos_sim(np.array([1,0,1]), np.array([1,1,1])), 2))\n",
        "print(round(cos_sim(np.array([1,1,1]), np.array([1,1,1])), 2))\n",
        "print(round(cos_sim(np.array([-1,-1,-1]), np.array([1,1,1])), 2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.82\n",
            "1.0\n",
            "-1.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gHDWhcv-yYxA"
      },
      "source": [
        "結果は、`0.82`、`1.0`、`-1.0`、となります。結果が異なる場合は、作成した関数に誤りがないか確認してください。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5_QiLSAP1Jn4"
      },
      "source": [
        "## Q2\n",
        "\"course_list.csv\"ファイルには以下のように各行に授業名のテキストデータ（文字コードはUTF8）が含まれています。以下では、このファイルを読み込み、各授業のベクトルを作成し、授業間の類似度を求めるコードを実装します。\n",
        "```Python\n",
        "## course_list.csvファイル\n",
        "...\n",
        "数理科学基礎\n",
        "物性化学\n",
        "政治Ⅰ\n",
        "身体運動・健康科学実習Ⅰ（ﾒﾃﾞｨｶﾙｹｱ1）\n",
        "スペイン語テクスト分析Ⅰ\n",
        "英語二列Ｗ（ALESS）\n",
        "応用倫理学\n",
        "...\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lyBEzDX61Ngb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ea5521b5-4285-4db7-b62b-df7c9de01b76"
      },
      "source": [
        "# Colaboratoryでは以下を実行して必要なファイルをダウンロード\n",
        "!wget https://raw.githubusercontent.com/UTDataMining/2021S/master/ex5/course_list.csv"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2021-11-07 09:57:02--  https://raw.githubusercontent.com/UTDataMining/2021S/master/ex5/course_list.csv\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 27388 (27K) [text/plain]\n",
            "Saving to: ‘course_list.csv’\n",
            "\n",
            "\rcourse_list.csv       0%[                    ]       0  --.-KB/s               \rcourse_list.csv     100%[===================>]  26.75K  --.-KB/s    in 0s      \n",
            "\n",
            "2021-11-07 09:57:02 (110 MB/s) - ‘course_list.csv’ saved [27388/27388]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qmrm37sH2PWp"
      },
      "source": [
        "### Q2.1\n",
        "引数`file`に与えられたファイル名のファイルを1行ずつ**順番に**読み込み、その各行を要素とするリストを作成して返す`create_list`関数を完成さてください。作成されたリストは変数`courses`で受け取ります。**以降の処理では、リスト`courses`のインデックスをその要素（授業名）のIDとして扱います**。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IHBBvlOg2Ysq",
        "exercise_id": "q2_1",
        "inlinetests": {
          "InlineTest_2_1": "\ntry:\n  courses = create_list('course_list.csv')\n  assert 552 == len(courses), f\"'len(courses)' returns {len(courses)}, while the expected answer is {552}\"\n  assert 198 == courses.index('計算機プログラミング'), f\"'courses.index('計算機プログラミング')' returns {courses.index('計算機プログラミング')}, while the expected answer is {198}\"\n  vocab = create_list('keyword_list.csv')\n  assert 243 == len(vocab), f\"'len(vocab)' returns {len(vocab)}, while the expected answer is {243}\"\n  assert 145 == vocab.index('プログラミング'), f\"'vocab.index('プログラミング')' returns {vocab.index('プログラミング')}, while the expected answer is {145}\"\nexcept AssertionError as e:\n    raise e\nexcept Exception as e:\n    assert False, f\"Your function raises an exception: {e}.\""
        }
      },
      "source": [
        "def create_list(file):\n",
        "  return pd.read_csv(file, header=None, encoding=\"utf-8\").values.flatten().tolist()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "thBxnu7R3kDI"
      },
      "source": [
        "`create_list`関数が完成したら、以下のセルを実行して動作を確認してください。リストの長さ（授業の数）は`552`、講義\"計算機プログラミング\"のID（リスト`courses`のインデックス）は`198`となります。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ly6m0Hd-3oNE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a59f3227-b925-467a-f58f-d505849b5b7d"
      },
      "source": [
        "courses = create_list('course_list.csv')\n",
        "print(len(courses))\n",
        "print(courses.index('計算機プログラミング'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "552\n",
            "198\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7jucVWG55p-e"
      },
      "source": [
        "\"keyword_list.csv\"ファイルには以下のように各行に1単語が含まれています（文字コードはUTF8）。\n",
        "```Python\n",
        "## keyword_list.csvファイル\n",
        "...\n",
        "外国語\n",
        "日本語\n",
        "力学\n",
        "身体運動\n",
        "微分積分学\n",
        "ロシア語\n",
        "熱力学\n",
        "線型代数学\n",
        "イタリア語\n",
        "物性\n",
        "...\n",
        "```\n",
        "上記と同様に`create_list`関数により、\"keywor_list.csv\"ファイルを1行ずつ**順番に**読み込み、その各行を要素とするリストを作成します。作成されたリストは変数`vocab`で受け取ります。以降の処理では、リスト`vocab`のインデックスをその要素（単語）のIDとして扱います。リスト`vocab`は以降の処理における語彙となります。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sSIO7Yl151wl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "45648418-056d-40f4-c42e-3b22464ed8c4"
      },
      "source": [
        "# Colaboratoryでは以下を実行して必要なファイルをダウンロード\n",
        "!wget https://raw.githubusercontent.com/UTDataMining/2021S/master/ex5/keyword_list.csv"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2021-11-07 10:09:43--  https://raw.githubusercontent.com/UTDataMining/2021S/master/ex5/keyword_list.csv\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.110.133, 185.199.108.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 2513 (2.5K) [text/plain]\n",
            "Saving to: ‘keyword_list.csv’\n",
            "\n",
            "\rkeyword_list.csv      0%[                    ]       0  --.-KB/s               \rkeyword_list.csv    100%[===================>]   2.45K  --.-KB/s    in 0s      \n",
            "\n",
            "2021-11-07 10:09:43 (36.3 MB/s) - ‘keyword_list.csv’ saved [2513/2513]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uZ7efuVs6CWY"
      },
      "source": [
        "以下のセルを実行して動作を確認してください。リストの長さ（単語の数）は`243`、単語\"プログラミング\"のID（リスト`vocab`のインデックス）は`145`、単語\"英語\"のID（リスト`vocab`のインデックス）は`0`となります。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ved5dvUm6JMQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c28bf268-b541-401a-fea1-e9caa8a1ec48"
      },
      "source": [
        "vocab = create_list('keyword_list.csv')\n",
        "print(len(vocab))\n",
        "print(vocab.index('プログラミング'))\n",
        "print(vocab.index('英語'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "243\n",
            "145\n",
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PM73mMPV7TLh"
      },
      "source": [
        "### Q2.2\n",
        "リスト`courses`と`vocab`を引数で受け取り、単語のID（リスト`vocab`のその単語のインデックス）をキー、授業名を1文書（document）と考えた時のその単語のDF（Document Frequency)を値とする辞書を作成して返す`count_df`関数を作成してください。作成された辞書は変数`df`で受け取ります。この場合、ある単語のDFはその単語を授業名に含む授業数に対応します。**単語が授業名に複数回含まれる場合でも1回と数えます**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gXafFvvp7wtj",
        "exercise_id": "q2_2",
        "inlinetests": {
          "InlineTest_2_2": "\ntry:\n  courses = create_list('course_list.csv')\n  vocab = create_list('keyword_list.csv')\n  df = count_df(courses, vocab)\n  assert 243 == len(df), f\"'len(df)' returns {len(df)}, while the expected answer is {243}\"\n  assert 2 == df[vocab.index('プログラミング')], f\"'df[vocab.index('プログラミング')]' returns {df[vocab.index('プログラミング')]}, while the expected answer is {2}\"\n  assert 12 == df[vocab.index('英語')], f\"'df[vocab.index('英語')]' returns {df[vocab.index('英語')]}, while the expected answer is {12}\"\nexcept AssertionError as e:\n    raise e\nexcept Exception as e:\n    assert False, f\"Your function raises an exception: {e}.\""
        }
      },
      "source": [
        "def count_df(courses, vocab):\n",
        "  dic={}\n",
        "  for i in range(len(vocab)):\n",
        "    dic[i] = 0\n",
        "    for c in courses:\n",
        "      if vocab[i] in c:\n",
        "        dic[i] += 1\n",
        "  return dic"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jJFv8DWN8q8r"
      },
      "source": [
        "`count_df`関数が完成したら、以下のセルを実行して動作を確認してください。辞書の長さは`243`、単語\"プログラミング\"（IDは`145`）のDFは`2`、単語\"英語\"（IDは`0`）のDFは`12`となります。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MPouabvS83LR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "367e9f9e-34dc-4cfe-f6c3-2573740c2cb0"
      },
      "source": [
        "df = count_df(courses, vocab)\n",
        "print(len(df))\n",
        "print(vocab.index('プログラミング'), df[vocab.index('プログラミング')])\n",
        "print(vocab.index('英語'), df[vocab.index('英語')])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "243\n",
            "145 2\n",
            "0 12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3_sBEgPJ_nwj"
      },
      "source": [
        "## Q3\n",
        "### Q3.1\n",
        "リスト`vocab`の各単語を次元とする授業ベクトルを考えます。授業ベクトルの長さはリスト`vocab`の長さと等しく、リスト`vocab`のインデックス`i`の単語`vocab[i]`が授業名に含まれる時、授業ベクトルの`i`番目の要素は`1`、含まれなければ`0`とします。\n",
        "\n",
        "以下では、リスト`courses`と`vocab`を引数で受け取り、リスト`courses`の各授業のベクトルを行、リスト`vocab`の各単語を列とした`NumPy`の行列を作成して返す`lec_word_matrix`関数を完成させてください。作成した授業-単語行列は、授業（行）の授業名に単語（列）が含まれていれば、その要素が1であるような行列です。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XqR9PR7e_zk9",
        "exercise_id": "q3_1",
        "inlinetests": {
          "InlineTest_3_1": "\ntry:\n  courses = create_list('course_list.csv')\n  vocab = create_list('keyword_list.csv')\n  assert (552, 243) == lec_word_matrix(courses, vocab).shape, f\"'lec_word_matrix(courses, vocab).shape' returns {lec_word_matrix(courses, vocab).shape}, while the expected answer is {(552, 243)}\"\n  assert 2287 == np.sum(lec_word_matrix(courses, vocab)), f\"'np.sum(lec_word_matrix(courses, vocab))' returns {np.sum(lec_word_matrix(courses, vocab))}, while the expected answer is {2287}\"\nexcept AssertionError as e:\n    raise e\nexcept Exception as e:\n    assert False, f\"Your function raises an exception: {e}.\""
        }
      },
      "source": [
        "def lec_word_matrix(courses, vocab):\n",
        "  mat = np.zeros((len(courses), len(vocab)))\n",
        "  for i in range(len(courses)):\n",
        "    for j in range(len(vocab)):\n",
        "      if vocab[j] in courses[i]:\n",
        "        mat[i, j] = 1\n",
        "  return mat"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EgqmU3JWA0Hw"
      },
      "source": [
        "`lec_word_matrix`関数が完成したら、以下のセルを実行して動作を確認してください。作成した授業-単語行列の形状は`(552, 243)`、要素の値の和は`2287`となります。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qVVOV39zA5gk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "426df764-3668-4e4a-87cc-67848b213f7e"
      },
      "source": [
        "print(lec_word_matrix(courses, vocab).shape)\n",
        "print(np.sum(lec_word_matrix(courses, vocab)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(552, 243)\n",
            "2287.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gyrpzNGWCg-U"
      },
      "source": [
        "### Q3.2\n",
        "Q3.1で作成した授業-単語行列の各要素を、その授業の授業名に単語が含まれるか否かの1or0ではなく、その授業の授業名に単語が何回含まれるか（TF: Term Frequency)で表した行列を作成して返す`lec_word_tf_matrix`関数を完成させてください。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JZo8sCHzCqL6",
        "exercise_id": "q3_2",
        "inlinetests": {
          "InlineTest_3_2": "\ntry:\n  courses = create_list('course_list.csv')\n  vocab = create_list('keyword_list.csv')\n  assert (552, 243) == lec_word_tf_matrix(courses, vocab).shape, f\"'lec_word_tf_matrix(courses, vocab).shape' returns {lec_word_tf_matrix(courses, vocab).shape}, while the expected answer is {(552, 243)}\"\n  assert 2366 == np.sum(lec_word_tf_matrix(courses, vocab)), f\"'np.sum(lec_word_tf_matrix(courses, vocab))' returns {np.sum(lec_word_tf_matrix(courses, vocab))}, while the expected answer is {2366}\"\n  assert 2 == lec_word_tf_matrix(courses, vocab)[courses.index('自然科学ゼミナール（情報科学）'), vocab.index('科学')], f\"'lec_word_tf_matrix(courses, vocab)[courses.index('自然科学ゼミナール（情報科学）'), vocab.index('科学')]' returns {lec_word_tf_matrix(courses, vocab)[courses.index('自然科学ゼミナール（情報科学）'), vocab.index('科学')]}, while the expected answer is {2}\"\nexcept AssertionError as e:\n    raise e\nexcept Exception as e:\n    assert False, f\"Your function raises an exception: {e}.\""
        }
      },
      "source": [
        "def lec_word_tf_matrix(courses, vocab):\n",
        "  mat = np.zeros((len(courses), len(vocab)))\n",
        "  for i in range(len(courses)):\n",
        "    for j in range(len(vocab)):\n",
        "      mat[i, j] = courses[i].count(vocab[j])\n",
        "  return mat"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M26CWzOUDH_X"
      },
      "source": [
        "`lec_word_tf_matrix`関数が完成したら、以下のセルを実行して動作を確認してください。作成した授業-単語行列の要素の値の和は`2366`となります。\n",
        "\n",
        "授業「自然科学ゼミナール（情報科学）」には「科学」が2回含まれるので対応する行列の要素の値は2となります。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ve7KjM-ODVDX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "39cab88b-a753-4edf-a4d4-cc8b98a53c6f"
      },
      "source": [
        "print(np.sum(lec_word_tf_matrix(courses, vocab)))\n",
        "print(lec_word_tf_matrix(courses, vocab)[courses.index('自然科学ゼミナール（情報科学）'), vocab.index('科学')])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2366.0\n",
            "2.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oBfOCrrjEUKA"
      },
      "source": [
        "### Q3.3\n",
        "Q3.2で作成した授業-単語行列の各要素（授業`i`の単語`j`の$TF_{ij}$）にその単語のIDF値を掛けたTFIDF値を要素とする行列を作成して返す`lec_word_tfidf_matrix`関数を完成させてください。\n",
        "\n",
        "ここで、授業`i`、単語`j`のTFIDF値は以下のように定義されます。\n",
        "```Python\n",
        "TFIDF=TF_ij*log(すべての授業数/単語jのDF)=TF_ij*log(len(courses)/df[j])\n",
        "```\n",
        "`log`の計算には`np.log()`が使用できます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4xGrq29jE27m",
        "exercise_id": "q3_3",
        "inlinetests": {
          "InlineTest_3_3": "\ntry:\n  courses = create_list('course_list.csv')\n  vocab = create_list('keyword_list.csv')\n  df = count_df(courses, vocab)\n  tfidf_mat = lec_word_tfidf_matrix(courses, vocab, df)\n  assert 7274 == int(np.sum(tfidf_mat)), f\"'int(np.sum(tfidf_mat))' returns {int(np.sum(tfidf_mat))}, while the expected answer is {7274}\"\n  assert 399 == int(tfidf_mat[courses.index('自然科学ゼミナール（情報科学）'), vocab.index('科学')]*100), f\"'tfidf_mat[courses.index('自然科学ゼミナール（情報科学）'), vocab.index('科学')]' returns {tfidf_mat[courses.index('自然科学ゼミナール（情報科学）'), vocab.index('科学')]}, while the expected answer is {3.99}...\"\nexcept AssertionError as e:\n    raise e\nexcept Exception as e:\n    assert False, f\"Your function raises an exception: {e}.\""
        }
      },
      "source": [
        "def lec_word_tfidf_matrix(courses, vocab, df):\n",
        "  mat = np.zeros((len(courses), len(vocab)))\n",
        "  for i in range(len(courses)):\n",
        "    for j in range(len(vocab)):\n",
        "      mat[i, j] = courses[i].count(vocab[j]) * np.log(len(courses) / df[j])\n",
        "  return mat"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lrq2X3hfFdyx"
      },
      "source": [
        "`lec_word_tfidf_matrix`関数が完成したら、以下のセルを実行して動作を確認してください。作成した授業-単語行列の要素の値の和の整数部分は`7274`となります。\n",
        "\n",
        "講義「自然科学ゼミナール（情報科学）」には「科学」が2回含まれ、「科学」のDF値は75なので対応する行列の要素の値は$2*log(552/75)\\simeq3.99$となります。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sj9aqbuyFxZj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e1756e69-8982-4100-a80e-4eac77da9e5c"
      },
      "source": [
        "tfidf_mat = lec_word_tfidf_matrix(courses, vocab, df)\n",
        "print(int(np.sum(tfidf_mat)))\n",
        "print(df[vocab.index('科学')], tfidf_mat[courses.index('自然科学ゼミナール（情報科学）'), vocab.index('科学')])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7274\n",
            "75 3.9921198654815697\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nj-p57LnHrHj"
      },
      "source": [
        "## Q4\n",
        "Q3.3で作成した授業-単語行列を元に、入力の授業に対してcos類似度に基づいて他のすべての授業との類似度を計算し、類似する授業名をキー、その類似度を値とした辞書を返す以下の`find_similar_course`関数を完成させてください。その際、**入力の授業および類似度が0の授業は辞書に含めない**ようにしてください。cos類似度の計算にはQ1で作成した関数を使ってもよいです。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1SGjWSGJH0BY",
        "exercise_id": "q4",
        "inlinetests": {
          "InlineTest_4": "\ntry:\n  courses = create_list('course_list.csv')\n  vocab = create_list('keyword_list.csv')\n  df = count_df(courses, vocab)\n  tfidf_mat = lec_word_tfidf_matrix(courses, vocab, df)\n  title=\"自然科学ゼミナール（情報科学）\" \n  results=find_similar_course(courses.index(title), tfidf_mat, courses)\n  ranking = pd.DataFrame(list(results.items()), columns=['title', \"similarity\"])\n  assert 64 ==  int(ranking.sort_values(by='similarity', ascending=False).iloc[0,1]*100), f\"'ranking.sort_values(by='similarity', ascending=False).iloc[0,1]' returns {ranking.sort_values(by='similarity', ascending=False).iloc[0,1]}, while the expected answer is {0.64}...\"\n  assert 63 ==  int(ranking.sort_values(by='similarity', ascending=False).iloc[1,1]*100), f\"'ranking.sort_values(by='similarity', ascending=False).iloc[1,1]' returns {ranking.sort_values(by='similarity', ascending=False).iloc[1,1]}, while the expected answer is {0.63}...\"\n  assert \"自然科学ゼミナール（生命科学）\" == ranking.sort_values(by='similarity', ascending=False).iloc[0,0], f\"'ranking.sort_values(by='similarity', ascending=False).iloc[0,0]' returns {ranking.sort_values(by='similarity', ascending=False).iloc[0,0]}, while the expected answer is {'自然科学ゼミナール（生命科学）'}\"\n  assert \"生物情報科学\" == ranking.sort_values(by='similarity', ascending=False).iloc[1,0] , f\"'ranking.sort_values(by='similarity', ascending=False).iloc[1,0]' returns {ranking.sort_values(by='similarity', ascending=False).iloc[1,0]}, while the expected answer is {'生物情報科学'}\"\nexcept AssertionError as e:\n    raise e\nexcept Exception as e:\n    assert False, f\"Your function raises an exception: {e}.\""
        }
      },
      "source": [
        "def find_similar_course(target, tfidf_mat, courses):\n",
        "  similar_courses_dic = {}\n",
        "  for i in range(len(courses)):\n",
        "    cos_sim_ = cos_sim(tfidf_mat[target], tfidf_mat[i])\n",
        "    if target == i or cos_sim_ == 0:\n",
        "      continue\n",
        "    similar_courses_dic[courses[i]] = cos_sim_\n",
        "  return similar_courses_dic"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "opCyVGY2JFN8"
      },
      "source": [
        "`find_similar_course`関数が完成したら、以下のセルを実行して動作を確認してください。\n",
        "\n",
        "入力の講義`自然科学ゼミナール（情報科学）`に類似した上位の講義は、`自然科学ゼミナール（生命科学）、生物情報科学、自然科学ゼミナール（数理科学）、自然現象とモデル、人類科学、...`となります。\n",
        "\n",
        "類似した授業数は230となります。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dMxDtMWcJJ8v",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 381
        },
        "outputId": "1a2ab937-a0a6-4f03-a86c-ef17b8663d82"
      },
      "source": [
        "tfidf_mat = lec_word_tfidf_matrix(courses, vocab, df)\n",
        "title=\"自然科学ゼミナール（情報科学）\" # 入力の授業名\n",
        "results=find_similar_course(courses.index(title), tfidf_mat, courses) # 類似授業の辞書を受け取る\n",
        "print(len(results)) # 類似授業の数\n",
        "ranking = pd.DataFrame(list(results.items()), columns=['title', \"similarity\"]) # 類似度が上位の授業を表示\n",
        "ranking.sort_values(by='similarity', ascending=False).head(10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "230\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>title</th>\n",
              "      <th>similarity</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>70</th>\n",
              "      <td>自然科学ゼミナール（生命科学）</td>\n",
              "      <td>0.644874</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>88</th>\n",
              "      <td>生物情報科学</td>\n",
              "      <td>0.631863</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>68</th>\n",
              "      <td>自然科学ゼミナール（数理科学）</td>\n",
              "      <td>0.622156</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>196</th>\n",
              "      <td>自然現象とモデル</td>\n",
              "      <td>0.399247</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>67</th>\n",
              "      <td>人類科学</td>\n",
              "      <td>0.387201</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>87</th>\n",
              "      <td>食の科学</td>\n",
              "      <td>0.387201</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>65</th>\n",
              "      <td>天然物の科学</td>\n",
              "      <td>0.387201</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>情報</td>\n",
              "      <td>0.332018</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>169</th>\n",
              "      <td>全学体験ゼミナール　(都市の緑のインタープリター養成－子どもに伝える自然体験－)</td>\n",
              "      <td>0.308337</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>120</th>\n",
              "      <td>全学自由研究ゼミナール　(ミュオグラフィ科学/Muography Science)</td>\n",
              "      <td>0.281423</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                                         title  similarity\n",
              "70                             自然科学ゼミナール（生命科学）    0.644874\n",
              "88                                      生物情報科学    0.631863\n",
              "68                             自然科学ゼミナール（数理科学）    0.622156\n",
              "196                                   自然現象とモデル    0.399247\n",
              "67                                        人類科学    0.387201\n",
              "87                                        食の科学    0.387201\n",
              "65                                      天然物の科学    0.387201\n",
              "5                                           情報    0.332018\n",
              "169   全学体験ゼミナール　(都市の緑のインタープリター養成－子どもに伝える自然体験－)    0.308337\n",
              "120  全学自由研究ゼミナール　(ミュオグラフィ科学/Muography Science)    0.281423"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H8DW30_AxIxe"
      },
      "source": [
        "## コードのテスト\n",
        "以下のセルを実行してから、設問ごとにCheck関数でコードのテストをしてください。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N46m4DxjxHtn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f960a79-ad86-47e6-99a6-27e33c17d4e8"
      },
      "source": [
        "# コードのテストの前にこのセルを実行してください\n",
        "!pip install prog_edu_assistant_tools\n",
        "import re\n",
        "import sys\n",
        "import jinja2\n",
        "from IPython.core import display\n",
        "from google.colab import _message as google_message\n",
        "from prog_edu_assistant_tools.magics import report, autotest, CaptureOutput\n",
        "from prog_edu_assistant_tools.check import Check"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting prog_edu_assistant_tools\n",
            "  Downloading prog_edu_assistant_tools-0.3.1-py3-none-any.whl (16 kB)\n",
            "Requirement already satisfied: IPython in /usr/local/lib/python3.7/dist-packages (from prog_edu_assistant_tools) (5.5.0)\n",
            "Requirement already satisfied: Jinja2 in /usr/local/lib/python3.7/dist-packages (from prog_edu_assistant_tools) (2.11.3)\n",
            "Requirement already satisfied: pygments in /usr/local/lib/python3.7/dist-packages (from IPython->prog_edu_assistant_tools) (2.6.1)\n",
            "Requirement already satisfied: pickleshare in /usr/local/lib/python3.7/dist-packages (from IPython->prog_edu_assistant_tools) (0.7.5)\n",
            "Requirement already satisfied: prompt-toolkit<2.0.0,>=1.0.4 in /usr/local/lib/python3.7/dist-packages (from IPython->prog_edu_assistant_tools) (1.0.18)\n",
            "Requirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.7/dist-packages (from IPython->prog_edu_assistant_tools) (57.4.0)\n",
            "Requirement already satisfied: simplegeneric>0.8 in /usr/local/lib/python3.7/dist-packages (from IPython->prog_edu_assistant_tools) (0.8.1)\n",
            "Requirement already satisfied: traitlets>=4.2 in /usr/local/lib/python3.7/dist-packages (from IPython->prog_edu_assistant_tools) (5.1.0)\n",
            "Requirement already satisfied: pexpect in /usr/local/lib/python3.7/dist-packages (from IPython->prog_edu_assistant_tools) (4.8.0)\n",
            "Requirement already satisfied: decorator in /usr/local/lib/python3.7/dist-packages (from IPython->prog_edu_assistant_tools) (4.4.2)\n",
            "Requirement already satisfied: six>=1.9.0 in /usr/local/lib/python3.7/dist-packages (from prompt-toolkit<2.0.0,>=1.0.4->IPython->prog_edu_assistant_tools) (1.15.0)\n",
            "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from prompt-toolkit<2.0.0,>=1.0.4->IPython->prog_edu_assistant_tools) (0.2.5)\n",
            "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from Jinja2->prog_edu_assistant_tools) (2.0.1)\n",
            "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.7/dist-packages (from pexpect->IPython->prog_edu_assistant_tools) (0.7.0)\n",
            "Installing collected packages: prog-edu-assistant-tools\n",
            "Successfully installed prog-edu-assistant-tools-0.3.1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dJuIyggO0zw1"
      },
      "source": [
        "## Q1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5g_v37Xr04J4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 160
        },
        "outputId": "4edd5cb1-bed0-445b-d314-7773feec2b1f"
      },
      "source": [
        "# Run this cell to check your solution.\n",
        "# If you get an error 'Check not defined', make sure you have run all preceding\n",
        "# cells once (Runtime -> Run before)\n",
        "Check('q1')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <h4 style='color: #387;'>Your submission</h4>\n",
              "  <pre style='background: #F0F0F0; padding: 3pt; margin: 4pt; border: 1pt solid #DDD; border-radius: 3pt;'>def cos_sim(vec1, vec2):\n",
              "  return np.dot(vec1, vec2) / (np.sqrt(np.dot(vec1, vec1)) * np.sqrt(np.dot(vec2, vec2)))</pre>\n",
              "  <h4 style='color: #387;'>Results</h4>\n",
              "  \n",
              "  &#x2705;\n",
              "  Looks OK.\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e1TbzkBs5ap_"
      },
      "source": [
        "## Q2.1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gKZXt3eQ08dY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 160
        },
        "outputId": "ab7fc772-2619-45ce-dcec-d38d0d2edcb1"
      },
      "source": [
        "# Run this cell to check your solution.\n",
        "# If you get an error 'Check not defined', make sure you have run all preceding\n",
        "# cells once (Runtime -> Run before)\n",
        "Check('q2_1')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <h4 style='color: #387;'>Your submission</h4>\n",
              "  <pre style='background: #F0F0F0; padding: 3pt; margin: 4pt; border: 1pt solid #DDD; border-radius: 3pt;'>def create_list(file):\n",
              "  return pd.read_csv(file, header=None, encoding=\"utf-8\").values.flatten().tolist()</pre>\n",
              "  <h4 style='color: #387;'>Results</h4>\n",
              "  \n",
              "  &#x2705;\n",
              "  Looks OK.\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OGDf6atV-UHM"
      },
      "source": [
        "## Q2.2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HbeXyD9y5d6T",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "ac1b0d52-803e-4bbd-c0e8-b52be856b088"
      },
      "source": [
        "# Run this cell to check your solution.\n",
        "# If you get an error 'Check not defined', make sure you have run all preceding\n",
        "# cells once (Runtime -> Run before)\n",
        "Check('q2_2')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <h4 style='color: #387;'>Your submission</h4>\n",
              "  <pre style='background: #F0F0F0; padding: 3pt; margin: 4pt; border: 1pt solid #DDD; border-radius: 3pt;'>def count_df(courses, vocab):\n",
              "  dic={}\n",
              "  for i in range(len(vocab)):\n",
              "    dic[i] = 0\n",
              "    for c in courses:\n",
              "      if vocab[i] in c:\n",
              "        dic[i] += 1\n",
              "  return dic</pre>\n",
              "  <h4 style='color: #387;'>Results</h4>\n",
              "  \n",
              "  &#x2705;\n",
              "  Looks OK.\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d7HhYdJ8B7Al"
      },
      "source": [
        "## Q3.1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6TjcM2g9-Y7G",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 247
        },
        "outputId": "c5b5c550-ee4f-4fcf-ccef-e3ed56845d45"
      },
      "source": [
        "# Run this cell to check your solution.\n",
        "# If you get an error 'Check not defined', make sure you have run all preceding\n",
        "# cells once (Runtime -> Run before)\n",
        "Check('q3_1')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <h4 style='color: #387;'>Your submission</h4>\n",
              "  <pre style='background: #F0F0F0; padding: 3pt; margin: 4pt; border: 1pt solid #DDD; border-radius: 3pt;'>def lec_word_matrix(courses, vocab):\n",
              "  mat = np.zeros((len(courses), len(vocab)))\n",
              "  for i in range(len(courses)):\n",
              "    for j in range(len(vocab)):\n",
              "      if vocab[j] in courses[i]:\n",
              "        mat[i, j] = 1\n",
              "  return mat</pre>\n",
              "  <h4 style='color: #387;'>Results</h4>\n",
              "  \n",
              "  &#x2705;\n",
              "  Looks OK.\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XdIiAGXwEHif"
      },
      "source": [
        "## Q3.2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wrgq4dMVB-Mi",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 230
        },
        "outputId": "9837287c-46f5-46f9-ab8d-f01d38db6452"
      },
      "source": [
        "# Run this cell to check your solution.\n",
        "# If you get an error 'Check not defined', make sure you have run all preceding\n",
        "# cells once (Runtime -> Run before)\n",
        "Check('q3_2')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <h4 style='color: #387;'>Your submission</h4>\n",
              "  <pre style='background: #F0F0F0; padding: 3pt; margin: 4pt; border: 1pt solid #DDD; border-radius: 3pt;'>def lec_word_tf_matrix(courses, vocab):\n",
              "  mat = np.zeros((len(courses), len(vocab)))\n",
              "  for i in range(len(courses)):\n",
              "    for j in range(len(vocab)):\n",
              "      mat[i, j] = courses[i].count(vocab[j])\n",
              "  return mat</pre>\n",
              "  <h4 style='color: #387;'>Results</h4>\n",
              "  \n",
              "  &#x2705;\n",
              "  Looks OK.\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DLB_F73LHELG"
      },
      "source": [
        "## Q3.3"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vCSBLZIFEK8o",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 230
        },
        "outputId": "d83b36cb-ddae-4e69-c7c8-a7d83906f2f1"
      },
      "source": [
        "# Run this cell to check your solution.\n",
        "# If you get an error 'Check not defined', make sure you have run all preceding\n",
        "# cells once (Runtime -> Run before)\n",
        "Check('q3_3')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <h4 style='color: #387;'>Your submission</h4>\n",
              "  <pre style='background: #F0F0F0; padding: 3pt; margin: 4pt; border: 1pt solid #DDD; border-radius: 3pt;'>def lec_word_tfidf_matrix(courses, vocab, df):\n",
              "  mat = np.zeros((len(courses), len(vocab)))\n",
              "  for i in range(len(courses)):\n",
              "    for j in range(len(vocab)):\n",
              "      mat[i, j] = courses[i].count(vocab[j]) * np.log(len(courses) / df[j])\n",
              "  return mat</pre>\n",
              "  <h4 style='color: #387;'>Results</h4>\n",
              "  \n",
              "  &#x2705;\n",
              "  Looks OK.\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y91pYrUrMbss"
      },
      "source": [
        "## Q4"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qlIEnmwEHHzd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "ff940730-8186-4266-8d77-1a98996c651e"
      },
      "source": [
        "# Run this cell to check your solution.\n",
        "# If you get an error 'Check not defined', make sure you have run all preceding\n",
        "# cells once (Runtime -> Run before)\n",
        "Check('q4')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <h4 style='color: #387;'>Your submission</h4>\n",
              "  <pre style='background: #F0F0F0; padding: 3pt; margin: 4pt; border: 1pt solid #DDD; border-radius: 3pt;'>def find_similar_course(target, tfidf_mat, courses):\n",
              "  similar_courses_dic = {}\n",
              "  for i in range(len(courses)):\n",
              "    cos_sim_ = cos_sim(tfidf_mat[target], tfidf_mat[i])\n",
              "    if target == i or cos_sim_ == 0:\n",
              "      continue\n",
              "    similar_courses_dic[courses[i]] = cos_sim_\n",
              "  return similar_courses_dic</pre>\n",
              "  <h4 style='color: #387;'>Results</h4>\n",
              "  \n",
              "  &#x2705;\n",
              "  Looks OK.\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    }
  ]
}