k-NN_k-Nearest Neighbors Classifier_実装_ans.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## k-nnを例に学ぶ：初めての機械学習クラス実装"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "k-NNクラスを一から実装するのは少し大変です。このノートでは、いきなりk-NNをクラスとして実装することが難しいなぁ…と思っている人のために、一歩一歩k-NNの実装を行っていきます。\n",
    "\n",
    "さて、k-NNを行うためには、\n",
    "1. 初期化: どんな条件のk-NNを行うのかを決める。\n",
    "2. 訓練: データとラベルを保存する\n",
    "3. 予測: 保存されたデータとラベルを使って未知データのクラスを予測する\n",
    "\n",
    "の3ステップが必要でした。（これは、scikit-learnの機械学習モデルクラスの実装に倣った設計になっています。）\n",
    "\n",
    "そこで、ここでは初期化、訓練、予測の3ステップに実装を分けて考えていきます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# このノートで使うパッケージをimportしておきます。\n",
    "import numpy as np\n",
    "import pandas as pd \n",
    "import plotly.express as px \n",
    "\n",
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- パッケージバージョンの確認 ---\n",
      "NumPy: 1.23.3\n",
      "Pandas: 1.5.0\n",
      "Plotly: 5.13.1\n",
      "Scikit-Learn: 1.1.2\n"
     ]
    }
   ],
   "source": [
    "print(\"--- パッケージバージョンの確認 ---\")\n",
    "print(\"NumPy:\",np.__version__,)\n",
    "print(\"Pandas:\",pd.__version__)\n",
    "import plotly; print(\"Plotly:\",plotly.__version__)\n",
    "import sklearn; print(\"Scikit-Learn:\", sklearn.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# デモで使うデータセットを読み込んでおきます。\n",
    "iris_dataset = load_iris()\n",
    "\n",
    "# 教師データとテストデータに分割します。\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    iris_dataset.data, iris_dataset.target, # 分割したい配列をここに列挙します。今回はデータとラベルです。\n",
    "    test_size=0.3, # データ全体に対するテストデータの割合を指定します。\n",
    "    #stratify=iris_dataset.target, # クラス毎に偏りが出ないような分割をします。\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# データを標準化しておきます。（このセルを実行しなくても構いません）\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 初期化の実装"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "このノートの最終目的はk-NNをクラスとして実装することです。ですがまずはクラスのことを忘れて訓練と予測をそれぞれ関数として実装します。  \n",
    "関数の中ではできるだけ、「関数の引数」と「関数の中で定義した変数」のみが利用可能であることを意識して下さい。（グローバル変数を関数内から参照することは極力避けてください）\n",
    "\n",
    "さて、まずはk-NNの初期化ステップです。ここでは、機械学習の訓練をする前に、どのような設定でこの機械学習モデルを構築するのかを定義します。\n",
    "\n",
    "関数として必要な機能を実装していくので、クラスは必要ないのですが、あくまでも「辞書型っぽいなにか」として利用するために、クラスを用意しておきます。\n",
    "\n",
    "```python\n",
    "class knnに必要な情報をまとめたデータ構造:\n",
    "    def __init__(self):\n",
    "        ...\n",
    "```\n",
    "\n",
    "さて、k-NNを利用するときに、最低限確認したい情報は\n",
    "- kを何にするのか\n",
    "\n",
    "だけです。  \n",
    "つまりこの下で用意する「knnに必要な情報をまとめたデータ構造」は、メンバ変数としてk（近傍の何個の点を見るのか」のみを持っていることになりそうです。\n",
    "これを上のクラスに追加します。\n",
    "\n",
    "```python\n",
    "class knnに必要な情報をまとめたデータ構造:\n",
    "    def __init__(self, k:int):\n",
    "        self.k = k\n",
    "```\n",
    "\n",
    "こうして作った「knnに必要な情報をまとめたデータ構造」というクラスは、今はただkの値を持つだけのデータ型です。  \n",
    "クラスは設計書とも言われるようなもので、この設計書をもとに実際にものを作ることで実態を得ます。この「設計書（クラス）を元に実際に作られたもの」のことをインスタンス（instance）と呼びます。\n",
    "\n",
    "では実際に、コードセルで上記のコードを実行してみます。ついでにインスタンスを生成しておきましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.knnに必要な情報をまとめたデータ構造 object at 0x1766bbb50>\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "class knnに必要な情報をまとめたデータ構造:\n",
    "    def __init__(self, k:int):\n",
    "        self.k = k\n",
    "\n",
    "data_container = knnに必要な情報をまとめたデータ構造(1) # ここではkを適当に1とします。\n",
    "print(data_container)\n",
    "print(data_container.k)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "data_containerはkの値を持っているので、data_container.kと書くことでkの値にアクセスできます。また、`data_container.hoge = huga` とすることで、そのインスタンスに新しいフィールドと値を追加することもできます。\n",
    "\n",
    "これ以降に実装する関数では、このdata_containerを引数として渡すことにします。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 訓練関数の実装"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "さて次に、データコンテナと訓練データと訓練ラベルを受け取って、訓練を行う関数を用意します。  \n",
    "ただし、knnが訓練ステップで行うのは、訓練というよりはデータペアをすべて保存するだけの「暗記」です。通常の関数は状態を持てないので、データコンテナとして渡されたdata_containerに新しいフィールドと値を追加することにします。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 「データコンテナ」という引数には、必ず「knnに必要な情報をまとめたデータ構造」クラスの\n",
    "# インスタンス（つまりdata_container）を渡して下さい。\n",
    "def 訓練(データコンテナ, 教師データ, 教師ラベル):\n",
    "    データコンテナ.教師データ = 教師データ\n",
    "    データコンテナ.教師ラベル = 教師ラベル\n",
    "    return データコンテナ "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ここで定義した関数は、引数として受け取ったデータをデータコンテナ（第一引数）の新しいメンバ変数として追加して、更新した第一引数のオブジェクトをそのまま返すだけの仕事をします。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "[0 2 1 2 0 2 2 1 0 0 1 2 1 1 2 2 0 2 2 2 2 2 1 1 2 0 2 0 0 0 1 2 1 1 1 2 1\n",
      " 1 0 2 2 2 0 0 2 1 1 0 1 0 2 2 0 2 0 1 0 2 0 2 2 0 1 0 0 0 2 1 1 2 1 2 0 1\n",
      " 0 2 0 1 1 0 1 2 0 1 1 0 1 2 0 1 0 1 0 2 1 2 0 0 2 0 2 1 1 0 1]\n"
     ]
    }
   ],
   "source": [
    "data_container = 訓練(data_container, X_train, y_train)\n",
    "\n",
    "# 訓練を行ったあとのdata_containerの中身を確認してみましょう。\n",
    "print(data_container.k)\n",
    "print(data_container.教師ラベル)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 予測関数の実装"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "k-nnでは未知データと教師データすべてのとの距離を計算して、距離の近い順番にソートします。その後に教師データのラベルがそれぞれ何個有るのかを調べて、最も多いラベルを未知データのラベルとして採用するのでした。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpyの便利な関数の紹介"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "実装を見る前に、コード中で出てくる難しそうな関数を紹介しておきます。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### np.argsort"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "背の順にデータをソートした後に、ソートした要素が入った配列を返すのがnp.sortです。これに対して、ソートした後にそれぞれの要素の元の配列での順番が入った配列を返すのがnp.argsortです。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.sort: [140 150 160 180]\n",
      "np.argsort: [2 1 3 0]\n"
     ]
    }
   ],
   "source": [
    "# np.argsortとは\n",
    "身長 = [180,150,140,160]\n",
    "print(\"np.sort:\",np.sort(身長))\n",
    "print(\"np.argsort:\", np.argsort(身長))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上の説明でわからなかったという人は、下のコードを読んでイメージを掴んで下さい。\n",
    "```python\n",
    "def argsort(arr):\n",
    "    \"\"\"argsort\n",
    "    実際にこのように実装されているわけではありませんが、上の説明でわからなかった場合はこのコードを読んでみてください。\n",
    "    \"\"\"\n",
    "    # 背の順に並び替え\n",
    "    sorted = np.sort(arr)\n",
    "    \n",
    "    # 元の配列arrでのindex（前から何番目の要素か）を取得\n",
    "    argsorted_list = []\n",
    "    for val in sorted:\n",
    "        index = arr.index(val)\n",
    "        argsorted_list.append(index)\n",
    "    \n",
    "    argsorted = np.array(argsorted_list)\n",
    "    return argsorted\n",
    "```\n",
    "\n",
    "np.argsortは自分で実装するとちょっと面倒くさい処理なので、NumPyの関数を使うことをお勧めします。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### np.bincount"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "配列内にある数字がそれぞれ何個あったのかを数えてくれる関数（最大値と同じ要素数のベクトルが返ってくる）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 3, 1, 1])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "成績 = [4,2,1,3,3,3,5]\n",
    "np.bincount(成績)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 距離を計算する関数"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ではまず、距離を計算する関数を実装しましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def 距離関数(データ点, 教師データ全部):\n",
    "    距離 = ((データ点 - 教師データ全部) ** 2).sum(axis=1)\n",
    "    return 距離"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 与えられたデータが属するクラスを予測する関数\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "距離関数を使って、与えられたデータがどのクラスに属するのかを予測する関数を作ります。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9777777777777777\n"
     ]
    }
   ],
   "source": [
    "def 予測(データコンテナ, クラスを予測したいデータ):\n",
    "    予測したクラスラベル = [] # リストとして初期化\n",
    "    \n",
    "    for (ループの回数, x) in enumerate(クラスを予測したいデータ):\n",
    "        \n",
    "        # データ点xと教師データすべてとの距離を計算し、distance_vectorに格納する。\n",
    "        # distance_vectorの要素数は教師データの数と同じになっているはず。\n",
    "        distance_vector = 距離関数(x, データコンテナ.教師データ)\n",
    "        \n",
    "        # これを小さい順にソートして、データの番号を変数に保存しておく\n",
    "        sorted_indexes = np.argsort(distance_vector)\n",
    "        \n",
    "        # 先頭からk個だけ取り出して、あとは捨てる\n",
    "        ご近所さん = sorted_indexes[:データコンテナ.k]\n",
    "        \n",
    "        # k個のご近所さんの教師ラベルを変数に保存しておく\n",
    "        ご近所さんのラベル = データコンテナ.教師ラベル[ご近所さん]\n",
    "        \n",
    "        # ご近所さんの中で一番多いラベルを見つける\n",
    "        近所で一番人気のラベル = np.bincount(ご近所さんのラベル).argmax()\n",
    "        \n",
    "        # xのご近所で一番多いのがこのクラスなら、きっとxもこのクラスなんだろうな…\n",
    "        予測したクラスラベル.append(近所で一番人気のラベル)\n",
    "        \n",
    "        # あとはこれを「クラスを予測したいデータ」すべてに対して行えばすべての予測ができる。\n",
    "        \n",
    "    return np.array(予測したクラスラベル) # 返す時はnumpyの配列としておく（おそらくy_trainもそうだったでしょ？）\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    pred_labels = 予測(data_container, X_test)\n",
    "    # 正答率\n",
    "    正答率 = (pred_labels == y_test).sum() / len(X_test)\n",
    "    print(正答率)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "これでk-NNが完成です。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### リファクタリング"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "例えば以下のように実行した場合、上で作ったプログラムはエラーを起こします。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'knnに必要な情報をまとめたデータ構�' object has no attribute '教師データ'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [11], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m data_container \u001b[39m=\u001b[39m knnに必要な情報をまとめたデータ構造(\u001b[39m1\u001b[39m) \u001b[39m# ここではkを適当に1とします。\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[39m# data_container = 訓練(data_container, X_train, y_train)\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m pred_labels \u001b[39m=\u001b[39m 予測(data_container, X_test)\n",
      "Cell \u001b[0;32mIn [10], line 8\u001b[0m, in \u001b[0;36m予測\u001b[0;34m(データコンテナ, クラスを予測したいデータ)\u001b[0m\n\u001b[1;32m      2\u001b[0m 予測したクラスラベル \u001b[39m=\u001b[39m [] \u001b[39m# リストとして初期化\u001b[39;00m\n\u001b[1;32m      4\u001b[0m \u001b[39mfor\u001b[39;00m (ループの回数, x) \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(クラスを予測したいデータ):\n\u001b[1;32m      5\u001b[0m     \n\u001b[1;32m      6\u001b[0m     \u001b[39m# データ点xと教師データすべてとの距離を計算し、distance_vectorに格納する。\u001b[39;00m\n\u001b[1;32m      7\u001b[0m     \u001b[39m# distance_vectorの要素数は教師データの数と同じになっているはず。\u001b[39;00m\n\u001b[0;32m----> 8\u001b[0m     distance_vector \u001b[39m=\u001b[39m 距離関数(x, データコンテナ\u001b[39m.\u001b[39;49m教師データ)\n\u001b[1;32m     10\u001b[0m     \u001b[39m# これを小さい順にソートして、データの番号を変数に保存しておく\u001b[39;00m\n\u001b[1;32m     11\u001b[0m     sorted_indexes \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39margsort(distance_vector)\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'knnに必要な情報をまとめたデータ構�' object has no attribute '教師データ'"
     ]
    }
   ],
   "source": [
    "data_container = knnに必要な情報をまとめたデータ構造(1) # ここではkを適当に1とします。\n",
    "# data_container = 訓練(data_container, X_train, y_train)\n",
    "pred_labels = 予測(data_container, X_test)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "訓練をしていないのに予測を走らせるとエラーが出るようです。そのために訓練済みかどうかを判別できるフラグもデータコンテナのフィールドとして与えておけば良さそうです。  \n",
    "ここまでで実装したコード⇓"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "## ここまでで実装したコード:\n",
    "class knnに必要な情報をまとめたデータ構造:\n",
    "    def __init__(self, k:int):\n",
    "        self.k = k\n",
    "        \n",
    "def 訓練(データコンテナ, 教師データ, 教師ラベル):\n",
    "    データコンテナ.教師データ = 教師データ\n",
    "    データコンテナ.教師ラベル = 教師ラベル\n",
    "    return データコンテナ \n",
    "\n",
    "def 距離を計算する関数(データ点, 教師データ全部):\n",
    "    距離 = ((データ点 - 教師データ全部) ** 2).sum(axis=1)\n",
    "    return 距離\n",
    "\n",
    "def 予測(データコンテナ, クラスを予測したいデータ):\n",
    "    予測したクラスラベル = []\n",
    "    \n",
    "    for (ループの回数, x) in enumerate(クラスを予測したいデータ):\n",
    "        distance_vector = 距離を計算する関数(x, データコンテナ.教師データ)\n",
    "        sorted_indexes = np.argsort(distance_vector)\n",
    "        ご近所さん = sorted_indexes[:データコンテナ.k]\n",
    "        ご近所さんのラベル = データコンテナ.教師ラベル[ご近所さん]\n",
    "        近所で一番人気のラベル = np.bincount(ご近所さんのラベル).argmax()\n",
    "        予測したクラスラベル.append(近所で一番人気のラベル)\n",
    "    return np.array(予測したクラスラベル)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "訓練済みフラグを追加して、予測関数で訓練済みかを確認するように変更したコード⇓"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 訓練済みフラグを追加して、予測関数で訓練済みかを確認するように変更したコード:\n",
    "class knnに必要な情報をまとめたデータ構造:\n",
    "    def __init__(self, k:int):\n",
    "        self.k = k\n",
    "        self.is_fitted = False \n",
    "        \n",
    "def 訓練(データコンテナ, 教師データ, 教師ラベル):\n",
    "    データコンテナ.教師データ = 教師データ\n",
    "    データコンテナ.教師ラベル = 教師ラベル\n",
    "    データコンテナ.is_fitted = True\n",
    "    return データコンテナ \n",
    "\n",
    "def 距離を計算する関数(データ点, 教師データ全部):\n",
    "    距離 = ((データ点 - 教師データ全部) ** 2).sum(axis=1)\n",
    "    return 距離\n",
    "\n",
    "def 予測(データコンテナ, クラスを予測したいデータ):\n",
    "    assert データコンテナ.is_fitted, \"先に訓練してから予測して下さい\"\n",
    "    予測したクラスラベル = []\n",
    "    \n",
    "    for (ループの回数, x) in enumerate(クラスを予測したいデータ):\n",
    "        distance_vector = 距離を計算する関数(x, データコンテナ.教師データ)\n",
    "        sorted_indexes = np.argsort(distance_vector)\n",
    "        ご近所さん = sorted_indexes[:データコンテナ.k]\n",
    "        ご近所さんのラベル = データコンテナ.教師ラベル[ご近所さん]\n",
    "        近所で一番人気のラベル = np.bincount(ご近所さんのラベル).argmax()\n",
    "        予測したクラスラベル.append(近所で一番人気のラベル)\n",
    "    return np.array(予測したクラスラベル)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "先に訓練してから予測して下さい",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [14], line 4\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39m# 訓練しないで予測しようとした場合\u001b[39;00m\n\u001b[1;32m      3\u001b[0m data_container \u001b[39m=\u001b[39m knnに必要な情報をまとめたデータ構造(\u001b[39m3\u001b[39m)\n\u001b[0;32m----> 4\u001b[0m pred_labels \u001b[39m=\u001b[39m 予測(data_container, X_test)\n",
      "Cell \u001b[0;32mIn [13], line 18\u001b[0m, in \u001b[0;36m予測\u001b[0;34m(データコンテナ, クラスを予測したいデータ)\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m予測\u001b[39m(データコンテナ, クラスを予測したいデータ):\n\u001b[0;32m---> 18\u001b[0m     \u001b[39massert\u001b[39;00m データコンテナ\u001b[39m.\u001b[39mis_fitted, \u001b[39m\"\u001b[39m\u001b[39m先に訓練してから予測して下さい\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m     19\u001b[0m     予測したクラスラベル \u001b[39m=\u001b[39m []\n\u001b[1;32m     21\u001b[0m     \u001b[39mfor\u001b[39;00m (ループの回数, x) \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(クラスを予測したいデータ):\n",
      "\u001b[0;31mAssertionError\u001b[0m: 先に訓練してから予測して下さい"
     ]
    }
   ],
   "source": [
    "# 訓練しないで予測しようとした場合\n",
    "\n",
    "data_container = knnに必要な情報をまとめたデータ構造(3)\n",
    "pred_labels = 予測(data_container, X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9555555555555556\n"
     ]
    }
   ],
   "source": [
    "# 訓練後に予測をしようとした場合\n",
    "\n",
    "data_container = knnに必要な情報をまとめたデータ構造(3)\n",
    "data_container = 訓練(data_container, X_train,y_train)\n",
    "pred_labels = 予測(data_container, X_test)\n",
    "print((pred_labels == y_test).sum() / len(X_test)) # 正答率"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "これ以外にも、「教師データとテストデータの特徴数が異なっている」のようなパッと想像ができるエラーについては、わかりやすいエラーメッセージと一緒にエラーを起こすことは大切です。assertを使う以外にもエラーの起こし方はあるので、調べてみてください。  \n",
    "\n",
    "また、このように安全なコードを書くためには、アルゴリズムの本質とは関係のないコードを書く必要がたくさん出てきます。本質的ではないコードを書きたくない場合は、有名なOSSのリポジトリを除いてみてください。sklearn.base.BaseEstimatorのような「機械学習モデルの実装に便利な親クラス」が公開されていることがあります。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 変数名などを英語に直していく"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "さて、このコードでも十分動くのですが、変数名や関数名は英語で書くのが普通です。とりあえず、いくつか英語に直してみます。\n",
    "また、この際に「必要情報」としていた部分を、全てselfに置き換えておきます。\n",
    "\n",
    "... 教師データとそのラベルをX_train, y_train.　(training dataなのでtrain)。テストデータとそのラベルをX_test, y_testとするのでした。これについてもここで直しておきます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class knnに必要な情報をまとめたデータ構造:\n",
    "    def __init__(self, k:int):\n",
    "        self.k = k\n",
    "        self.is_fitted = False \n",
    "        \n",
    "def fit(self, X_train, y_train):\n",
    "    self._X = X_train\n",
    "    self._y = y_train\n",
    "    self.is_fitted = True\n",
    "    return self \n",
    "\n",
    "def compute_distance(a, b):\n",
    "    distance = ((a-b) ** 2).sum(axis=1)\n",
    "    return distance\n",
    "\n",
    "def predict(self, X_test):\n",
    "    assert self.is_fitted, \"先に訓練してから予測して下さい\"\n",
    "    pred_labels = []\n",
    "    \n",
    "    for (loop_counter, x) in enumerate(X_test):\n",
    "        distance_vector = compute_distance(x, self._X)\n",
    "        sorted_indexes = np.argsort(distance_vector)\n",
    "        neighbors = sorted_indexes[:self.k]\n",
    "        neighbors_label = self._y[neighbors]\n",
    "        popular_label = np.bincount(neighbors_label).argmax()\n",
    "        pred_labels.append(popular_label)\n",
    "    return np.array(pred_labels)\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    data_container = knnに必要な情報をまとめたデータ構造(3)\n",
    "    data_container = fit(data_container, X_train,y_train)\n",
    "    pred_labels = predict(data_container, X_test)\n",
    "\n",
    "    # 正答率\n",
    "    (pred_labels == y_test).sum() / len(X_test)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "よく見るプログラムらしくなってきましたね。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 関数からクラスへ"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "さて、ここで、fit, predictは「 knnに必要な情報をまとめたデータ構造」のインスタンスを第一引数に取る関数でした。それ以外のデータ構造を渡しても、おそらくエラーが出てしまいそうです。  \n",
    "このような「あるデータ構造専用の関数」のことをメソッドと呼び、classの中で定義する事ができます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9555555555555556\n"
     ]
    }
   ],
   "source": [
    "class KNearestNeighborsClassifier:\n",
    "    def __init__(self, k:int):\n",
    "        self.k = k\n",
    "        self.is_fitted = False \n",
    "        \n",
    "    def fit(self, X_train, y_train):\n",
    "        self._X = X_train\n",
    "        self._y = y_train\n",
    "        self.is_fitted = True\n",
    "        return self \n",
    "\n",
    "    def predict(self, X_test):\n",
    "        assert self.is_fitted, \"先に訓練してから予測して下さい\"\n",
    "        pred_labels = []\n",
    "\n",
    "        for (loop_counter, x) in enumerate(X_test):\n",
    "            distance_vector = self.compute_distance(x, self._X)\n",
    "            sorted_indexes = np.argsort(distance_vector)\n",
    "            neighbors = sorted_indexes[:self.k]\n",
    "            neighbors_label = self._y[neighbors]\n",
    "            popular_label = np.bincount(neighbors_label).argmax()\n",
    "            pred_labels.append(popular_label)\n",
    "        return np.array(pred_labels)\n",
    "    \n",
    "    def compute_distance(self, a, b):\n",
    "        distance = ((a - b) ** 2).sum(axis=1)\n",
    "        return distance\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    model = KNearestNeighborsClassifier(3)\n",
    "    model.fit(X_train,y_train)\n",
    "    pred_labels = model.predict(X_test)\n",
    "\n",
    "    # 正答率\n",
    "    acc = (pred_labels == y_test).sum() / len(X_test)\n",
    "    print(acc)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "この書き方をすることで、インスタンス.メソッド(self以外の引数)の形でメソッドの実行が可能です。また、それぞれのメソッドは、別のメソッドからself.メソッド名で呼び出すことができます。fitメソッドからpredictを呼び出す時は self.predict とすればいいのです。selfはインスタンス自体を示しているので、これはインスタンス.メソッドの形になっています。\n",
    "\n",
    "逆に、通常のメソッドの中で、クラス名.メソッドとするとエラーになります。（ただクラス名を書くだけだとインスタンスになっていませんよね。）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9555555555555556"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = KNearestNeighborsClassifier(3)\n",
    "model.fit(X_train,y_train)\n",
    "pred_labels = model.predict(X_test)\n",
    "\n",
    "# 正答率\n",
    "(pred_labels == y_test).sum() / len(X_test)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "これで基本的なクラスの実装は完了しました。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 型アノテーション"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pythonは動的型付け言語といって、プログラムを書くときに明示的に値の型を書かなくても実行時に型を判別してくれる言語です。そのおかげでC言語のようにint charのような型を指定せずにプログラムを書くことができています。\n",
    "\n",
    "しかしながら、ある程度長いプログラムを書くときや複数人で開発をするときには、型が明示されていた方がわかりやすいと感じる人が多いようです。そこでPythonにも変数の型を指定する型アノテーションが導入されました。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 最初に宣言だけして後から代入\n",
    "a: int\n",
    "a = 1\n",
    "\n",
    "# 型の宣言と代入を同時に行う\n",
    "b: int = 2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "これをtype hintと呼ぶこともあります。これが特に用いられるのは関数を定義する際です。\n",
    "\n",
    "先ほどの例にあったcompute_distanceメソッドでは、aとbが何型なのか、どんな型の値が返ってくるのかがわかりませんでした。\n",
    "```python\n",
    "    def compute_distance(self, a, b):\n",
    "        distance = ((a - b) ** 2).sum(axis=1)\n",
    "        return distance\n",
    "```\n",
    "これにtype hintをつけることで、以下のようになります。\n",
    "```python\n",
    "    def compute_distance(self, a:np.ndarray[np.float64], b:np.ndarray[np.float64])->np.ndarray[np.float64]:\n",
    "        distance = ((a - b) ** 2).sum(axis=1)\n",
    "        return distance\n",
    "```\n",
    "\n",
    "これで最低限、aとbがNumPyの配列で、返り値として同じ型のオブジェクトを返すことがわかるようになりました。\n",
    "\n",
    "本来、このtype hintは期待していない値が入力されてもエラーなどは出してくれません。しかし、mypyを使ったデバッグやIDEの補完機能などでは利用されます。綺麗なコードを書きたい場合は極力type hintをつけることを忘れないようにするべきでしょう。\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Docstrings"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ここでは詳しく説明をしませんが、Pythonにはクラスや関数の説明文を書くためのdocstirngという機能があります。関数の場合では、関数名の定義をした次の行に文字列を書いておけば、これがdocstringとして扱われます。多くの場合は改行が必要になるので、「\"\"\"」で囲んで関数の説明を書くことになります。docstringの書き方にはNumPyスタイルやGoogleスタイルなどの有名な書式があります。外部公開しないコードであれば、とりあえず関数の説明を書いておくだけでOKです。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a:float, b:float=0)->float:\n",
    "    \"\"\"aとbの和を求める\n",
    "\n",
    "    Args:\n",
    "        a (float): 足す数\n",
    "        b (float, optional): 足される数. Defaults to 0.\n",
    "\n",
    "    Returns:\n",
    "        float: aとbの和\n",
    "    \"\"\"\n",
    "    return a+b"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "docstringをしっかりと書いておくことには明確な利点があります。\n",
    "\n",
    "これを[自動で収集してAPIリファレンスを作ってくれるツール](https://sphinx-rtd-tutorial.readthedocs.io/en/latest/docstrings.html)や、[マウスオーバーでdocstringを表示してくれるIDEやテキストエディタの機能](https://marketplace.visualstudio.com/items?itemName=ms-python.python)などで役立ちます。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 演習問題"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ★☆☆☆☆ Accuracyメソッドの実装 "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "実装したKNearestNeighborsClassifierクラスに、新しいメソッドaccuracyを追加してください。このメソッドは予測したラベルの配列と正しいラベルの配列の二つを引数に取り、返り値として正答率を返します。\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 解答例"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通常のメソッドで実装する場合: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9555555555555556\n"
     ]
    }
   ],
   "source": [
    "class KNearestNeighborsClassifier:\n",
    "    def __init__(self, k:int):\n",
    "        self.k = k\n",
    "        self.is_fitted = False \n",
    "        \n",
    "    def fit(self, X_train, y_train):\n",
    "        self._X = X_train\n",
    "        self._y = y_train\n",
    "        self.is_fitted = True\n",
    "        return self \n",
    "\n",
    "    def predict(self, X_test):\n",
    "        assert self.is_fitted, \"先に訓練してから予測して下さい\"\n",
    "        pred_labels = []\n",
    "\n",
    "        for (loop_counter, x) in enumerate(X_test):\n",
    "            distance_vector = self.compute_distance(x, self._X)\n",
    "            sorted_indexes = np.argsort(distance_vector)\n",
    "            neighbors = sorted_indexes[:self.k]\n",
    "            neighbors_label = self._y[neighbors]\n",
    "            popular_label = np.bincount(neighbors_label).argmax()\n",
    "            pred_labels.append(popular_label)\n",
    "        return np.array(pred_labels)\n",
    "    \n",
    "    def compute_distance(self, a, b):\n",
    "        distance = ((a - b) ** 2).sum(axis=1)\n",
    "        return distance\n",
    "\n",
    "    def accuracy(self, pred_labels:np.ndarray[np.float64], true_labels:np.ndarray[np.float64])->float:\n",
    "        \"\"\"正答率\n",
    "\n",
    "        Args:\n",
    "            pred_labels (np.ndarray[np.float64]): 予測したラベルを持った配列\n",
    "            true_labels (np.ndarray[np.float64]): 正しいラベルを持った配列\n",
    "\n",
    "        Returns:\n",
    "            float: 正答率\n",
    "        \"\"\"\n",
    "        return (pred_labels == y_test).sum() / len(X_test)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    model = KNearestNeighborsClassifier(3)\n",
    "    model.fit(X_train,y_train)\n",
    "    pred_labels = model.predict(X_test)\n",
    "\n",
    "    # 正答率\n",
    "    acc = model.accuracy(pred_labels, y_test)\n",
    "    print(acc)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "staticmethodで実装する場合:\n",
    "\n",
    "accuracyはselfに紐づくデータを参照せずに求められるので、ここでは@staticmethodというデコレータを用いています。これを使うとメソッドの第一引数のselfが不要になります。もちろん通常のselfを使ったメソッドでもOKですが、staticmethodデコレータがついているメソッドは「インスタンスの状態に依存したメソッドなのかが一目瞭然になる」という利点があります。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9555555555555556\n"
     ]
    }
   ],
   "source": [
    "class KNearestNeighborsClassifier:\n",
    "    def __init__(self, k:int):\n",
    "        self.k = k\n",
    "        self.is_fitted = False \n",
    "        \n",
    "    def fit(self, X_train, y_train):\n",
    "        self._X = X_train\n",
    "        self._y = y_train\n",
    "        self.is_fitted = True\n",
    "        return self \n",
    "\n",
    "    def predict(self, X_test):\n",
    "        assert self.is_fitted, \"先に訓練してから予測して下さい\"\n",
    "        pred_labels = []\n",
    "\n",
    "        for (loop_counter, x) in enumerate(X_test):\n",
    "            distance_vector = self.compute_distance(x, self._X)\n",
    "            sorted_indexes = np.argsort(distance_vector)\n",
    "            neighbors = sorted_indexes[:self.k]\n",
    "            neighbors_label = self._y[neighbors]\n",
    "            popular_label = np.bincount(neighbors_label).argmax()\n",
    "            pred_labels.append(popular_label)\n",
    "        return np.array(pred_labels)\n",
    "    \n",
    "    def compute_distance(self, a, b):\n",
    "        distance = ((a - b) ** 2).sum(axis=1)\n",
    "        return distance\n",
    "\n",
    "    @staticmethod\n",
    "    def accuracy(pred_labels:np.ndarray[np.float64], true_labels:np.ndarray[np.float64])->float:\n",
    "        \"\"\"正答率\n",
    "\n",
    "        Args:\n",
    "            pred_labels (np.ndarray[np.float64]): 予測したラベルを持った配列\n",
    "            true_labels (np.ndarray[np.float64]): 正しいラベルを持った配列\n",
    "\n",
    "        Returns:\n",
    "            float: 正答率\n",
    "        \"\"\"\n",
    "        return (pred_labels == y_test).sum() / len(X_test)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    model = KNearestNeighborsClassifier(3)\n",
    "    model.fit(X_train,y_train)\n",
    "    pred_labels = model.predict(X_test)\n",
    "\n",
    "    # 正答率\n",
    "    acc = model.accuracy(pred_labels, y_test)\n",
    "    print(acc)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ★★☆☆☆ 距離関数の差し替え"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "実装したKNearestNeighborsClassifierクラスのcompute_distanceメソッドでは、ユークリッド距離の代わりとして二乗和を使っています。NearestNeighborsClassifierクラスを修正し、クラスの初期化の際に距離関数を切り替えられるようにしてください。また、以下の例のように実行できる必要があります。\n",
    "\n",
    "```python\n",
    "# 二乗和を使う場合\n",
    "KNearestNeighborsClassifier(3)\n",
    "\n",
    "# l1（マンハッタン）距離を使う場合\n",
    "KNearestNeighborsClassifier(3, distance_function=\"l1\")\n",
    "\n",
    "# l2（ユークリッド）距離を使う場合\n",
    "KNearestNeighborsClassifier(3, distance_function=\"l2\")\n",
    "\n",
    "# cos距離を使う場合\n",
    "from scipy.spatial.distance import cosine\n",
    "cosine_distance = lambda a,B: np.hstack([cosine(a,b) for b in B])\n",
    "\n",
    "KNearestNeighborsClassifier(3, distance_function=cosine_distance)\n",
    "\n",
    "# 定義されていない関数名が与えられた場合\n",
    "KNearestNeighborsClassifier(3, distance_function=\"存在しない関数名\")\n",
    "# この場合はNotImplementedErrorをraiseしてください。\n",
    "```\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 解答例"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不要になったcompute_distanceを削除し、__init__の引数としてdistance_functionを追加します。文字列を受け取った場合はあらかじめ定義しておいた関数をcompute_distanceに代入し、関数自体が与えられた場合はそれを代入します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "二乗和: 0.9555555555555556\n",
      "l1: 0.9111111111111111\n",
      "l2: 0.9555555555555556\n",
      "cos: 0.8666666666666667\n"
     ]
    },
    {
     "ename": "NotImplementedError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [40], line 78\u001b[0m\n\u001b[1;32m     75\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mcos:\u001b[39m\u001b[39m\"\u001b[39m,acc)\n\u001b[1;32m     77\u001b[0m \u001b[39m# 定義されていない関数名が与えられた場合\u001b[39;00m\n\u001b[0;32m---> 78\u001b[0m model \u001b[39m=\u001b[39m KNearestNeighborsClassifier(\u001b[39m3\u001b[39;49m, distance_function\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39m存在しない関数名\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n",
      "Cell \u001b[0;32mIn [40], line 8\u001b[0m, in \u001b[0;36mKNearestNeighborsClassifier.__init__\u001b[0;34m(self, k, distance_function)\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mis_fitted \u001b[39m=\u001b[39m \u001b[39mFalse\u001b[39;00m\n\u001b[1;32m      7\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdistance_function \u001b[39m=\u001b[39m distance_function\n\u001b[0;32m----> 8\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcompute_distance \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m__set_distance_function()\n",
      "Cell \u001b[0;32mIn [40], line 37\u001b[0m, in \u001b[0;36mKNearestNeighborsClassifier.__set_distance_function\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     35\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mlambda\u001b[39;00m a,b: ((a \u001b[39m-\u001b[39m b) \u001b[39m*\u001b[39m\u001b[39m*\u001b[39m \u001b[39m2\u001b[39m)\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m)\u001b[39m*\u001b[39m\u001b[39m*\u001b[39m(\u001b[39m1\u001b[39m\u001b[39m/\u001b[39m\u001b[39m2\u001b[39m)\n\u001b[1;32m     36\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdistance_function, \u001b[39mstr\u001b[39m):\n\u001b[0;32m---> 37\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mNotImplementedError\u001b[39;00m\n\u001b[1;32m     38\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdistance_function\n",
      "\u001b[0;31mNotImplementedError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "from typing import Callable\n",
    "\n",
    "class KNearestNeighborsClassifier:\n",
    "    def __init__(self, k:int, distance_function:str|Callable=\"sum_of_squares\"):\n",
    "        self.k = k\n",
    "        self.is_fitted = False\n",
    "        self.distance_function = distance_function\n",
    "        self.compute_distance = self.__set_distance_function()\n",
    "        \n",
    "    def fit(self, X_train, y_train):\n",
    "        self._X = X_train\n",
    "        self._y = y_train\n",
    "        self.is_fitted = True\n",
    "        return self \n",
    "\n",
    "    def predict(self, X_test):\n",
    "        assert self.is_fitted, \"先に訓練してから予測して下さい\"\n",
    "        pred_labels = []\n",
    "\n",
    "        for (loop_counter, x) in enumerate(X_test):\n",
    "            distance_vector = self.compute_distance(x, self._X)\n",
    "            sorted_indexes = np.argsort(distance_vector)\n",
    "            neighbors = sorted_indexes[:self.k]\n",
    "            neighbors_label = self._y[neighbors]\n",
    "            popular_label = np.bincount(neighbors_label).argmax()\n",
    "            pred_labels.append(popular_label)\n",
    "        return np.array(pred_labels)\n",
    "    \n",
    "    def __set_distance_function(self)->Callable[[np.ndarray, np.ndarray],np.ndarray]:\n",
    "        \"\"\"self.disntance_functionを参考に距離関数を返します。\n",
    "\n",
    "        Raises:\n",
    "            NotImplementedError: 存在しない関数名が与えられた場合はErrorを出します。\n",
    "\n",
    "        Returns:\n",
    "            Callable: 距離関数\n",
    "        \"\"\"\n",
    "        if self.distance_function == \"sum_of_squares\":\n",
    "            return lambda a,b: ((a - b) ** 2).sum(axis=1)\n",
    "        if self.distance_function == \"l1\":\n",
    "            return lambda a,b: np.abs(a-b).sum(axis=1)\n",
    "        if self.distance_function == \"l2\":\n",
    "            return lambda a,b: ((a - b) ** 2).sum(axis=1)**(1/2)\n",
    "        if isinstance(self.distance_function, str):\n",
    "            raise NotImplementedError\n",
    "        return self.distance_function\n",
    "\n",
    "    @staticmethod\n",
    "    def accuracy(pred_labels:np.ndarray[np.float64], true_labels:np.ndarray[np.float64])->float:\n",
    "        \"\"\"正答率\n",
    "\n",
    "        Args:\n",
    "            pred_labels (np.ndarray[np.float64]): 予測したラベルを持った配列\n",
    "            true_labels (np.ndarray[np.float64]): 正しいラベルを持った配列\n",
    "\n",
    "        Returns:\n",
    "            float: 正答率\n",
    "        \"\"\"\n",
    "        return (pred_labels == y_test).sum() / len(X_test)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "\n",
    "    \n",
    "    # 二乗和を使う場合\n",
    "    model = KNearestNeighborsClassifier(3).fit(X_train,y_train)\n",
    "    acc = model.accuracy(model.predict(X_test), y_test)\n",
    "    print(\"二乗和:\", acc)\n",
    "\n",
    "    # l1（マンハッタン）距離を使う場合\n",
    "    model = KNearestNeighborsClassifier(3, distance_function=\"l1\").fit(X_train,y_train)\n",
    "    acc = model.accuracy(model.predict(X_test), y_test)\n",
    "    print(\"l1:\",acc)\n",
    "    # l2（ユークリッド）距離を使う場合\n",
    "    model = KNearestNeighborsClassifier(3, distance_function=\"l2\").fit(X_train,y_train)\n",
    "    acc = model.accuracy(model.predict(X_test), y_test)\n",
    "    print(\"l2:\",acc)\n",
    "\n",
    "    # cos距離を使う場合\n",
    "    from scipy.spatial.distance import cosine\n",
    "    cosine_distance = lambda a,B: np.hstack([cosine(a,b) for b in B])\n",
    "    model = KNearestNeighborsClassifier(3, distance_function=cosine_distance).fit(X_train,y_train)\n",
    "    acc = model.accuracy(model.predict(X_test), y_test)\n",
    "    print(\"cos:\",acc)\n",
    "\n",
    "    # 定義されていない関数名が与えられた場合\n",
    "    model = KNearestNeighborsClassifier(3, distance_function=\"存在しない関数名\")\n",
    "    "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "datasci",
   "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.10.6"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "a79fb6e5a930026e4265f7488905aff41e03ef0de0bdcf381b857b9bad06edd5"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}