├── K維樹(KD Tree).ipynb
├── README.md
├── k-平均演算法(k-Mean Clustering).ipynb
├── k-鄰近演算法分類(k-Nearest Neighbor Classification).ipynb
├── k-鄰近演算法回歸(k-Nearest Neighbor Regression).ipynb
├── k鄰近搜尋(k-Nearest Neighbor Search).ipynb
├── t-隨機鄰近嵌入法(t-distributed stochastic neighbor embedding).ipynb
├── 主成分分析-最大化變異數觀點(Principal Component Analysis – Maximum Variance Prospective).ipynb
├── 主成分分析-最小化平方差觀點 (Principal Component Analysis – Minimum MSE Prospective).ipynb
├── 二次判別分析(Quadratic Discriminant Analysis).ipynb
├── 交叉驗證(Cross Validation).ipynb
├── 保序回歸(Isotonic Regression).ipynb
├── 偏最小平方回歸 (Partial Least Square Regression).ipynb
├── 偏最小平方奇異值分解(Partial Least Square Singular Vectors Decomposition)¶.ipynb
├── 典型相關分析(Canonical Correlation Analysis).ipynb
├── 利用層次方法的平衡迭代規約和聚類(Balanced Iterative Reducing and Clustering using Hierarchies).ipynb
├── 區域性切空間排列(Local Tangent Space Alignment).ipynb
├── 區域性異常因子(Local Outlier Factor).ipynb
├── 半徑鄰近演算法分類(Radius Neighbor Classification).ipynb
├── 半徑鄰近演算法回歸(Radius Neighbor Regression).ipynb
├── 半正定嵌入演算法(Semidefinite Embedding).ipynb
├── 單類別支撐向量機(One Class Support Vector Machine).ipynb
├── 因素分析(Factor Analysis).ipynb
├── 均值偏移(Mean-Shift).ipynb
├── 基於密度之含噪空間聚類法(Density-Based Spatial Clustering of Applications with Noise).ipynb
├── 基於密度之含噪空間階層聚類法(Hierarchical Density-Based Spatial Clustering of Applications with Noise).ipynb
├── 基於密度聚類(Density-Based Clustering).ipynb
├── 基於聚類區域性異常因子(Cluster Based LOF).ipynb
├── 基於距離離群值因子(Distance-based Outliers).ipynb
├── 基於連接異常因子分析(Connectivity-Based Outlier Factor).ipynb
├── 堆疊分類(Stacking Classifier).ipynb
├── 堆疊回歸(Stacking Regressor).ipynb
├── 多圍標度(Multidimensional Scaling).ipynb
├── 多維標度(Multidimensional Scaling).ipynb
├── 多項式迴歸(Polynomial Regression).ipynb
├── 孤立森林(Isolation Forest).ipynb
├── 對偶支撐向量機(Dual Support Vector Machine).ipynb
├── 局部線性嵌入演算法(Locally Linear Embedding).ipynb
├── 引導聚集分類(Bagging Classifier).ipynb
├── 引導聚集回歸(Bagging Regressor).ipynb
├── 感知器(Perceptron).ipynb
├── 拉普拉斯特徵映射(Laplacian Eigenmaps).ipynb
├── 排序點來識別聚類結構(Ordering Points to Identify the Clustering Structure).ipynb
├── 探索聚類分析(Cluster in Quest).ipynb
├── 支撐向量回歸(Support Vector Regression).ipynb
├── 支撐向量機(Support Vector Machine).ipynb
├── 斷截奇異值分解(Truncated Singular Vector Decomposition).ipynb
├── 核主成分分析 (Kernel Principal Component Analysis).ipynb
├── 核函數支撐向量機(Kernel Support Vector Machine).ipynb
├── 核函數羅吉斯回歸(Kernel Logistic Regression).ipynb
├── 梯度提升決策樹分類(Gradient Boosted Decision Tree Classifier).ipynb
├── 梯度提升決策樹回歸(Gradient Boosted Decision Tree Regressor).ipynb
├── 極限隨機樹分類(Extremely Randomized Trees Classifier).ipynb
├── 極限隨機樹回歸(Extremely Randomized Trees Regressor).ipynb
├── 正則化(Regularization).ipynb
├── 決策樹分類(Decision Tree Classifier).ipynb
├── 決策樹回歸(Decision Tree Regressor).ipynb
├── 沃德階層分群法(Ward Hierarchical Clustering).ipynb
├── 沃爾曼二分區模式A偏最小平方演算法(Wold’s Two Block, Mode A Partial Least Square).ipynb
├── 獨立成分分析(Independent Component Analysis).ipynb
├── 球樹(Ball Tree).ipynb
├── 神經網絡(Neural Network).ipynb
├── 稀疏主成分分析 (Sparse Principal Component Analysis).ipynb
├── 稀疏字典學習(Sparse Dictionary Learning).ipynb
├── 等距特徵映射(Isometric Mapping).ipynb
├── 線性判別分析(Linear Discriminant Analysis).ipynb
├── 線性回歸(Linear Regression).ipynb
├── 羅吉斯回歸(Logistic Regression).ipynb
├── 聚合式階層分群法(Agglomerative Hierarchical Clustering).ipynb
├── 自適應增強分類器(Adaptive Boost Classifier).ipynb
├── 自適應增強回歸(Adaptive Boost Regressor).ipynb
├── 自適應增強決策樹分類(AdaBoost Decision Tree Classifier).ipynb
├── 自適應增強決策樹回歸(AdaBoost Decision Tree Regressor).ipynb
├── 表徵聚類(Clustering Using Representatives).ipynb
├── 譜分群(Spectral Clustering).ipynb
├── 讀熱編碼(one-hot endcoding).ipynb
├── 軟性邊界對偶支撐向量機(Soft-Margin Dual Support Vector Machine).ipynb
├── 軟性邊界支撐向量機(Soft-Margin Support Vector Machine).ipynb
├── 輸入向量機(Import Vector Machine).ipynb
├── 鄰近傳播分群法(Affinity Propagation).ipynb
├── 鄰近成分分析(Neighborhood Component Analysis).ipynb
├── 鄰近質心演算法分類(Nearest Centroid Classifier).ipynb
├── 隨機梯度下降(Stochastic Gradient Decent).ipynb
├── 隨機森林分類(Random Forest Classifier).ipynb
├── 隨機森林回歸(Random Forest Regressor).ipynb
├── 集成平均分類(Ensemble Averaging Classifier).ipynb
├── 集成平均回歸(Ensemble Averaging Regressor).ipynb
├── 集成投票分類(Ensemble Voting Classifier).ipynb
├── 集成投票回歸(Ensemble Voting Regressor).ipynb
├── 非線性分類(Non-linear Classification).ipynb
├── 非負矩陣分解(Non-negative Matrix Factorization).ipynb
├── 高斯混合模型(Gaussian Mixture Models).ipynb
└── 黑塞特徵映射(Hessian Eigenmaps).ipynb


/K維樹(KD Tree).ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# K維樹(KD Tree)"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "markdown",
 12 |    "metadata": {},
 13 |    "source": [
 14 |     "##### 先引入我們需要的packages"
 15 |    ]
 16 |   },
 17 |   {
 18 |    "cell_type": "code",
 19 |    "execution_count": 1,
 20 |    "metadata": {},
 21 |    "outputs": [],
 22 |    "source": [
 23 |     "import os \n",
 24 |     "import numpy as np\n",
 25 |     "import matplotlib.pyplot as plt\n",
 26 |     "from numpy import random\n",
 27 |     "from tqdm.notebook import tqdm\n",
 28 |     "from random import choices"
 29 |    ]
 30 |   },
 31 |   {
 32 |    "cell_type": "markdown",
 33 |    "metadata": {},
 34 |    "source": [
 35 |     "# MNIST Dataset"
 36 |    ]
 37 |   },
 38 |   {
 39 |    "cell_type": "code",
 40 |    "execution_count": 2,
 41 |    "metadata": {},
 42 |    "outputs": [
 43 |     {
 44 |      "data": {
 45 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/0AAAEACAYAAADhrBaOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3dT2sd593/8a9+DoGUGMWkTWjAUUxCAoFgG7pX/ACK3W03slddKqIPQNYDuFG87cbR5t7Gpg9A1r7FMYFASoKthrokTZCNQ0ID7vmt7htuXe+vfV3nzJwZT96vXb890plrrn8z8egzK7PZLCRJkiRJ0vT8v6EPQJIkSZIk9cObfkmSJEmSJsqbfkmSJEmSJsqbfkmSJEmSJsqbfkmSJEmSJsqbfkmSJEmSJuq5lg+vrKxUvd/vpZdewvprr71W1B49elTU7t+/X9QeP35c89URETGbzVae9P/XtiPz9ttvF7XnnitP5T/+8Y+i9vDhw+rveVo7IhZvy4svvljU3nrrraL2ww8/FLW//e1v1d/TZVteeeUVrNP4+umnn4ra559/XtTGNL5OnDhR1N54442i9uWXXy7yNZ32Cc2JCD7/9+7dq/mVTZYxV2rn/WeffbbI13Q2vrJ5QuPr1KlTRe2FF14oatk8+fTTT//P//7Pf/4T//nPfzrrk9OnT2Od9ppvv/22qH3zzTdFbYg5/+abb2Kd+qRlfW3w7Ww2+9WTPlDbFjrmCF6HX3755aJGe3/LmraMOU/ee++9okZjifaZ7LNdja/V1VWsv/rqq0WNznXLnEjMNb6ef/754nN0zBE8lui4Hzx4UB4crA0RET/++GNRW8b4+vWvf13UqN3H19eI/tcvGktZn9A+SPsHobZF8LXDz6lPIhZfi+kagNpCc6XlOq2r9YuucyP4/uOXv/xlUaM95auvvqr56ojotk9onYrg/fHu3btF7fvvv6/5mlTWlqab/lrvv/8+1q9evVrUbt26VfU5GpRD+dOf/lTU6OJze3u7qN28ebOXY5rXb37zm6J248aNovbJJ58Utayf+/b73/8e6zRuaOGi4x7T+Dp58mRR+6//+q+idunSpWUcThWaExF8/i9fvtzvwfSkdt6fO3duGYfzVNk8oWOmsXT27Nmilv1Hy+ObNW2+i/jjH/+IdTrujz76qKh9+OGHRW2IOU/zOIL7pKf19bCrX0TrVAT3Fc152vvHtKZl/vznPxc1GktZ//U57rLv3NraKmp0rjs4trnGF10If/DBB/hZGkt03HQdQ2tDBF/fLMMf/vCHokbtppuhvtcvGks0jiJ4/aL9g5w5cwbrffzjQI0x90kmW4tr20JzZYjrNLqGj+D5WbunZOtI3377299indpY25Yu+Hi/JEmSJEkT5U2/JEmSJEkT1cvj/dkjGvQ4DD0W1PJIMD2W0jd6hGd9fb2oXbhwoagN9Xh/9sjx/v5+UaNHeLO/tekbjaXsEVB6jIce66Vz0dejNPOgsT7U44e1svFB82JjY6OoHR6WT4UONeYuXryIdWrLzs5O34fTOVq/aO5QLctr6fuxxpY/maD5Q4+q9v3nSTR+s7FFZrPyTwfv3LlT1Ib6c5LsUWlqI80T6qdsn8++q2/UlrW1taraEHNlb2+v+jvpXNN+uQw0V7L5ScdI53pzc7OoZee+7/01GwvUB7WPtfc9vq5cuVLUaA+M4GtGmvN0nTXUY/yZ2j//HOpRflrvs/Wx9k8QhvpT3eOyc0ptXnRN63vcZfcptFf4eL8kSZIkSVqYN/2SJEmSJE2UN/2SJEmSJE2UN/2SJEmSJE3UwkF+FLCQBXDRezspwIvC+bKwoj6D/LLvrA29GFP4WhYqQcFQdE63t7c7P6Ya169fL2pZMEdtSMxYQvtawn2ozS1Bd32HlmQBLBRaQqE/1CdDhca1hPMNESRaqyWUiwIzW8K1+patpbWhry3hRV2tD9n4JQcHB0WN2jbU+W8JJaQwORpfdH6GCiXMXLt2repztf3Xt+w7adzQ2jVUkB/NuWws0Pym8UX7zFDrdXZeaQ7QtVrLdUx2rdeK1tysT+iz1Oahwu9I1hYKK9za2ur7cKrRNVW2P9aG/g0VmnxcNj8pVJjmBI2voYIiW/qEwq1pTeuiLf5LvyRJkiRJE+VNvyRJkiRJE+VNvyRJkiRJE+VNvyRJkiRJE+VNvyRJkiRJE7Vwej+lj2aphZTUT4ZIvad0SEpPjIhYXV2t+p1jSYmPyNNjKQ2SPnvz5s2uD6kKjRlKL43gBNLaVPghUmUphTiC20GJqy3puNlY7kqWKkpv7KD5Q3N+qKTfLHWd3nQxljd0UDp3S9I7rX8kS4am8dml7Pffvn27qNH8GSLVt+X303mlJOOWNwJ0qWUu1o6FMc3vbH/M9poxoHGerUd0rseS2N2qNp2eUrKXkeRNaymlc0dwKjwdY+2e2bdsPtQmyo9pzLW8KWRMb+mha/Hs3oresFK712R91eccysY0tYPeEpNdUw8h21Pouqz2PqyLN3P4L/2SJEmSJE2UN/2SJEmSJE2UN/2SJEmSJE2UN/2SJEmSJE1UL0F+iwbYDRG0RqEJWSDR0dFR1e8cKnSJvjcL6qoNhhhTQEYWWkLBIxRQQrXsPHQ17iiIZHd3Fz9LASVkc3OzqF25cqXtwDqSnT8KLaEAnexckCwgpSvZvKWwFZpXNL6GCI3LgopqA/6oT4cKJ21ZS9fX14vamTNnilrffUJrB4VBRvCecu3ataJGfbqMwKWW0Kuxo/OVncPaINkhQtWof1sCW6kdYwm5fRJac+n89xWE9TQtYXV0XVUbqkohpl2i89eyply/fr3Do+ley55y9+7dokZr+fb2Nv5830HYi44FCprMxnFLQHCrLDCRzjXdn41prcqOpfb80bnI9uGW/cd/6ZckSZIkaaK86ZckSZIkaaK86ZckSZIkaaK86ZckSZIkaaIWDvKjsIKW0B8K06CfzwIexozasYzAHwrzodC3DIXdjCkgI0PHSG2hgJosPKclGOlJHj58WFWL4FCV2jk1tnmySPBbSyBSl7KwIgqIo/WLQgnPnz+Pv7Or9YCOOQutms1mVZ8dKrSPxvr+/j5+dmdnp6jVBnpm56fPgL9sHi+yV2TBll2GlrWM09XV1aJWu893td4+CbUlC1eiAFYaS4sEsnUpG7t0fLT/PAv7fG1oaUs/d7nW0RjOQuNojtL8oUDJvsPhaCxk4dY0T8hQ18SkZa2hUNWWz3XZVzSWaB+M4PFO+yP165iuJakddHx9hgwuGwVhZmO2Za/3X/olSZIkSZoob/olSZIkSZoob/olSZIkSZoob/olSZIkSZqohYP87t69W9SysCIKG6gNIMjCilSiUI4s4OLs2bNFjQIyKIiEgiayz3YpC7OgMB4KPakNBelS7bFF8Pyhn9/b2ytqQwUxZUE+FBZVG6AzVJBMFlZEAX0UKkVBOdk612eIUbZmUp8cHBz0dhyt6JxmoZfURjr/t2/fLmoUbhaxnDC542gcUNvomLsM7MvQupKNma2traL2u9/9rup3DhXqlcnG3XFjCcDL5jwF+VLb6OezttE6OW8IJu2FFJwaEXHq1KmiRqGJFIi3jHBYOl/ZWkPtPjo6KmpDhKq29Aldi9y5c6eojWl+Z9fEtdcdNFeywOzj4+7+/ftV30FofGV7Fs1R6tch9jw6jmz9oM8OFfRcq+X6npw5c6aoZdfZLePLf+mXJEmSJGmivOmXJEmSJGmivOmXJEmSJGmivOmXJEmSJGmivOmXJEmSJGmiFk7vPzw8LGpZEiTVKc0zS9Vctiy1ltLpKVWR2pElg3eJzmmWGEl16idqX5a02Xd6f9YvtW94oHRWSv8dCrWPkoiXMZZqXbhwAetZmu1xlP47RGJxRH5eKS2WUpnpuId4E0G2jm5sbBS1saSPR/CxZGOBkq4plZzWpCHeCJN9J63DtW8eGSoRO3trALWR2pclmo8JnVtKJae34GTpzX3OtZa1i9pGfZodL83JLtP76S0QLWjOj2nPjOC5QuvXEMdNc5b26Qi+PlnGW0UWka2b1Cd0TUzXNtm177zzYlE0r4a6rjqO1pVszaRjrr22HEq2v9FboAjtM9n4On4uHz9+nP5e/6VfkiRJkqSJ8qZfkiRJkqSJ8qZfkiRJkqSJ8qZfkiRJkqSJWpnNZvUfXln5V0SUyX3jsjabzX71pA9MpR0RtmUAjq/x+Vm1ZSrtiJhOW56RdkRMpy2Or3GaSlscX+Pzs+qTiOm0ZSrtiHj229J00y9JkiRJkp4dPt4vSZIkSdJEedMvSZIkSdJEedMvSZIkSdJEedMvSZIkSdJEedMvSZIkSdJEedMvSZIkSdJEPdfy4ZWVlar3+73wwgtYP3PmTFH797//XdQePXpU1L755puar46IiNlstvKk/7+2HZnnn3++qL333ntVP/vpp59i/aeffipqT2tHRH1bfv3rX2P9tddeK2pffPFFUXv48GHN16TmbcuJEyeKz73yyiv48ydPnixqv/jFL4ra48ePi9rdu3fxd37//fdFre/xRd5+++2idu/evaJG4yjT5fii44vguUyoT7qc8xH1baExFxHxzjvvVH2W5s+PP/5Y89UR0f/4orXgl7/8ZdXPfv7551jve/164403sE7n/+uvvy5qNI9bdNUnp0+fxjqtXd9++21Ra5kTiW8r3qm8UJ9QW3744Yeidv/+/aLW5TyJqG8L7ekREW+99VZROzo6Kmr//Oc/a74mNc/4omOm443Ir8lqPHjwAOtffvkllecaXy+//HLxuVdffRV//h//+EdRo32eZPOH9p8ux1dmdXW1qL3++utFjdbdLvd6ageNGdoDI3jNJXTM3333XdXPRnTbJzTmIviamK5jaP0a6vrr3XffxTqtu1999VVRo/Hfoqv9Mbu2J3TNQmM2u2aZ59o+ov4+hcZRBLeR9r1F9/+sLU03/bWyheGjjz4qanTjcuvWraL24YcfLnhU3aHO/Mtf/lL1s/QfPiL4PHTpD3/4A9a3t7eL2qVLl4razZs3Oz+mGnQBmbXl/fffL2rnzp0ranQRc/nyZfydNBaH8Kc//amo0TH3PY4ydHwR9eeP+mSoOU9jLiLiv//7v4vaSy+9VNRo/nzyySeLH1hHaP5k4/84mmMR/Y+7q1evYp3OP42bsczjP/7xj1in80r7ZQdz4nDRX/A/sj6httD4p58fap5kF2g052/cuFHUsnPRJzpmOt6IiLNnz879PdneT+tczDm+fvvb3xa1Dz74AD9L1yznz5+v+p5s/mT/YaNvNFeuXbtW9bm+11y6js/W0dp1iY6Z1rlloDEXwXOZ2k2fG+r6K5v3tJ7SvBpq/B/3+9//vvqzdM1C69yFCxfw57u8JqBrxmyv39zcLGp37twpaj3t/z7eL0mSJEnSVHnTL0mSJEnSRPXyeH/2qBs9ekG1ixcvFjV6pC5imMdpsr9lHIvaR44j+NE9OtcrK0/9U5de0LmmR/Yj+HEdqtGjci2PqvaNHlui8zDUI1l0/tfX1/GzVKcxN5bHryPyx0ppraLHssbyqFym9k+qaM3IHi/L1pe+0fysXZ+zud1n/2VrF42t3d3dokZr8zL2QDpXGxsb+FmaE3TcVMvOT99zKhsLtdcsQzy2XHtsERF7e3tF7eOPPy5qlN2zjD+5oDmbtSW7FqyRzZW++4quySIidnZ2ihqd7yGuc+mYKYMggv/kgtDakO39fbe55VFpWpeon7J1pMs5RPdH2VyhPqTry7H8+XTtnxlG8DHTz7fcL8yLvje7JqI/N6j9eR/vlyRJkiRJKW/6JUmSJEmaKG/6JUmSJEmaKG/6JUmSJEmaqIWD/Ci4goImIvj9o2N5Vy8FXmQBELXv5D04OChqywhkodCj7JxSgAR9tjbIpGv0HS2hYWtra1U/P8S7YrPQl+vXrxe1ra2tokaBc8t4XzSNr8NDfj0zjZsxBd1RgFRtKFEEz5+h3tVbi8Y61agdQ/Vddk5rAwjp55cR8FOLAq4onInWjKHec52pPf/0uSzIqe+gqaOjI6xTsF1tW/rul1OnTlV/lvZRWrOHuPaKaFsz6TqyNvxuqMDYLOiW5vhQoajHtaz11Cc0Z4faG2mfz0IJKfSy9jo5W7+ycOB50JqUoTWIjmUsQX7Z+kPtoHNNY3YZ+yN9bxbeSfObQnEp8LoL/ku/JEmSJEkT5U2/JEmSJEkT5U2/JEmSJEkT5U2/JEmSJEkT5U2/JEmSJEkTtXB6f4vaBEtKXO8bJUHu7u4u/Tj6kqVzUsIkJcqOPZE8gscNpWJTQugQCdhZn9Qm4c5ms6KW9VOX7aPxkaHU4r5SSeeRJaySod7GUYPSibMkYUqtp/NA82mo9mZvpaC5TEm6Y0nyzuYhvbGD0HlYxtqVvWmE1I4R6qe7d+9Wf0+XsjWJzjddF9D861v29glSey1z5cqVoja2t0Nsbm4WNUo0p0TsoWRvWqDjHsv1V0t6P/UJ7T+0jizjjREtbfn444/n/p37+/vV3zMvGgvZ25Nq30REfTXEvM/GOZ1XesvCUG++oHOVrc+0V9S+nasL/ku/JEmSJEkT5U2/JEmSJEkT5U2/JEmSJEkT5U2/JEmSJEkTtUJhYOmHV1aqPpz9TgozoTAMCljKQpcoaGc2m6086fhq25EFMVDAAoXGULhGS+DP09oRUd+WDAXEUbtbgpzIMtpCKCSGxsyNGzeqf+c844uCUrLwLgoooaC1ixcv0nc/6dD+j3n7hMZwFsazurpa1CiocNHQknnbQucwGws0nynAaNGgwnnGF43p2hCfFhQ4E5EGTc7VJzTWs1Ah6r/ke6o+l+lqT2lB84yC7s6fP48/n8zJv85ms9886XsXHV+155pCm7LwSdr/h9pTCLUlC5WifplnfNE+nX0nnT9ac2mfbwk7jTnHF8muOWhPoT2TznPLdUyX61cWUEZtoXA/6r9srtA1dVfrV7ZP03fS8VGftOz9Xc757D6F1lM6bqpl4cy0f3XZlmyO1q4RNC+yudLV+KJjy669KFR40T2djGlPofOc3ZPS+pK1xX/plyRJkiRporzplyRJkiRporzplyRJkiRporzplyRJkiRpop7r45dSEEkEhwFRiEdLEEqfsnCy2mMZ4pgzWQAEha1QKOGzigJwFg3ymwcFuRwdHeFnf/e73xW1lgDIvtG4zoJkasPIKABnGfOHwvkyFCZTO26uXLmC9SygrhWNaaplqB0U5NPV8bbKQoUodInWNDruLAhrLGj8t4Rgjql9tD7QfMr23LGj9Subf1nYXqvacLEIPv+NAX1Ll4U307UMBeINNZZarl/ps7UBZ9n4WjQU90myoDpqBx3fUNfEdHzZfQqtS9n183F9X0dmKPQtoj4UneZKtk51dQ1Avz/73XT+KcR30RDlMaF+yq6DWvrEf+mXJEmSJGmivOmXJEmSJGmivOmXJEmSJGmivOmXJEmSJGmiegnyy0IFagNsKHRjqIAMUhtGsr6+XtSyQLa+A05azh+FY1Et+519B+hkQTU0bmjMjSXAKAsdoTqFcl2/fr3rQ5pbFjCS1Y+jebGM0B/6jizcjwJ+amWhakME41EYE4XibG1tFbUsMKhL9B3Z91LAD53rsewfWSAUzRNau2ieZOOyyyAtChXa3t7Gz9L6SuOcgrSWMb5aUH9R+2jP293dxd95vA/v378/38GBbL2lOX/27NmilgWO9o3OabbP07ygsTRU6CjNsawt+/v7RY3Wr7Fcs9A+EcEBo7XhfstA6wqFP0bwHKB1gNbEodavrF/ouv327dtFrTbwOqK7eUXfmV0n0Zyitg0V5EfjIztPdC1CfUK/s4trfv+lX5IkSZKkifKmX5IkSZKkifKmX5IkSZKkifKmX5IkSZKkifKmX5IkSZKkieolvZ+SYiM4jZDSZinBcUypvpQ6eXBwUNSovUOl92d9Qkm4tYnr2dsYjv/8o0ePqn5frZb0fuqrzc3NTo9nGWhO7OzsLP9AElmf0BygpF/qp2WgdSUb1zSHqH30O8eSHh/Bx3znzp2iNlT6NcmOhRKGqTaWtmRra+2bbWifyN6W0uWeQvMzS0o+OjoqarQ/1u4zy5Dty9RuOq+099Cc6hIdM6XBR3C6Pe0fQ80TWpOyt0NQW2gs9f0WoRbZ/kbznvaKId5OQGN6b28PP0t7Ho3PMV3H09tpIvitG7TWZdc8Q2i5FqTjpjcZ9L1+0fzM3lKxsbFR1IZ60wihtmRznq7laR2ovc9s5b/0S5IkSZI0Ud70S5IkSZI0Ud70S5IkSZI0Ud70S5IkSZI0USuz2az+wysr/4qIw/4OpxNrs9nsV0/6wFTaEWFbBuD4Gp+fVVum0o6I6bTlGWlHxHTa4vgap6m0xfE1Pj+rPomYTlum0o6IZ78tTTf9kiRJkiTp2eHj/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTdRzLR9eWVmZ1XzuzTffxPrjx4+L2vPPP1/U7t+/X9S+//77mq+OiIjZbLbypP+/th2Z06dPF7WXX365qH366adFjc5B5mntiFi8LeTtt98ual9//XVRe/jwYfXvXEZbavvlhx9+KGp/+9vfqr+nq/FFxxsR8corr1Qfy3FffPEF1qmvuuyTlrb8+OOPRY3G13fffVfz1RExf1tOnDhRfO69997Dn6dz27Iu1ep7/aI2v/HGG0Xtp59+KmpfffVV9fd0Ob5on4iIePfdd4saHffdu3eLGo3DTFd9Quc+gscctePzzz8vai17SkR8O5vNfvWkDyw6vlZXV4va66+/XtT+/e9/F7V79+7h76RzsYw95YUXXihq77zzTlF78OBBUcvmCvVXV+OLjjeC1+eTJ0/W/Mq0T5L1ubPx9eKLL2Kdjvu1114rarRej+2ahdYDWtNIttfTutbV+MrWYZoT1DZah8fWJ4SuiZ97rrx9ovU5Yr45H9HP+KK5Qv365ZdfVn9P39csdH3yi1/8oqgtuj92eR2ZXRO/9NJLRe3Ro0dFjdbdLtqyMpvV90Vtx924cQPrtDFSZ169erWo3bp1q+arI6L/Afjhhx8WtcuXLxc1ahudg8xQCxyd693d3aJ28+bN6t+5jLbU9ssnn3xS1N5///3q7+lqfNHxRkRsbm5WH8txly5dwjr1VZd90tKWO3fuVP38Rx99VPPVETF/W2gBzi5y6dy2rEu1+l6/qM10ruk8fPDBB9Xf0+X4orU0gucyHXftOpDpqk/o3EfwMVON1qmWPSUi/jqbzX7zpA8sOr4uXrxY1K5du1bUavsp++wy9pRz584VNZrzdM2TzRXqr67GFx1vBK+v6+vrNb8yrly5gvVkfe5sfGV7MtW3t7eLGq3XY7tmofWgdl3K9nr6+a7GV7YO05ygtm1sbBS1sfUJqW1fNmbnmfMR/Ywvur+ifs3GF+n7moXWGlrrFt0fu7yOzK6Ja68jaS/soi0+3i9JkiRJ0kR50y9JkiRJ0kQ1/U1/rewRRnqEhB5r2N/fL2qnTp3C39n4aGOT7FEdemT54OCgqPV5bF2hPql97K/lsawuZf1Cj4DSo0wtjyh3heZE9vjU3t5eUaO20SON58+fx9/Zd19ljyRSG+lR2OvXrxe1lsf750X9Qn+THMHrEjk8PCxqLWO2b/TYGD2STX+GMRSaxxk6p7WPZ/Yte3ydxhwdH61dLeemS9k6SsezyJ/ERQwzTyK4LbR+0WPL2frVx58E/Y+WPynY2toqavRnfNk+1ff6nH0vXX/t7OwUNfqzhKGuWTI0L2gvbXn8uuXPllpla83a2lrVz9O1TTbnh7p+pjbSNTFlEWR7ylBtobXm7Nmzyz8QUPtnhi2fHeo80xjO9iya8/SnCrTPtPwZcsZ/6ZckSZIkaaK86ZckSZIkaaK86ZckSZIkaaK86ZckSZIkaaJ6CfKjAIKItuCe44YIaMjaQUFd1Db6+SwIpc/wlYg8YKQ2jGdMoYRZEFJtQBL1VfZ+4676hc5f7diPqA8fzMZs37JxROOdAnAoCGsZWoJRKASqdnwMERqXta12LPUZOPYkNBez8UFhXTQWlxEKeRyN/axP6D32FPhD8ztrW9/hd9meQP1XG2Ta9z7Yio6b9g9qS8v63pUsKJLQ8dHaMNTenwWn1r57vDYQL2K4oEg6xtpwv761rMMU0Efo57Nrr773n2zdrL0WoT4ZahxlagM8xxJuTYHCERyUTvNkKDQWsjlLbaR1m85PF0GR/ku/JEmSJEkT5U2/JEmSJEkT5U2/JEmSJEkT5U2/JEmSJEkT5U2/JEmSJEkT1Ut6f5aKubu7W9QojfDChQtdH9JTUary6uoqfpbaR6mwlNKYpSy2pO4+DR1L1ifr6+tVv3OoBF/qF0pKjlgsIb/v1FVKqM3aQZ+tTZnP3g6RfVffbt++XdSon+iNGMtwdHS00M9T+yjlv280v7MUYjq+tbW1ojbUnG9500Ht/Kak32yuZPVWdP6yRF/6Tvp5ake2NvT9xoLs91P/0VsHxpQUn6FjzNLGj+t7T6HrC3qbRQSPO+onWgeGSsnO1tGdnZ2iRnNgiLcntKJzS2OO2tJ3v9BYyNRevw7VT/S9i74xaIg38rSidtO6NMQcb+n3se0Li6A1msYS7TNdnAf/pV+SJEmSpInypl+SJEmSpInypl+SJEmSpInypl+SJEmSpInqJcivJRSCgglu3brV4dHUaQk6WyRUpauQqCeh8I4sAILavbe3V9SG6JPM5uYm1h8+fFjUsjDG47L+7yoMi37/9vZ29c9T2yjoaBnjqwUdIwV10vjKArO6DMii48sCpOh4rl27VtQODg6KWt9BNBSklIUrUTsoFKzvILIMrV9Z0CMFxJEhQpfu3r1b1LLwotrxQYFsXYbAtsjOKa2ZNL/HtKdkaK7Uhq/13T5aR2keP6leIxtf1OZloPO6v79f1CjwbxlrGq1fWdgm1WtDf8cUbkZjhNYBOv9DBeJtbW1hndZYGl9DBVySbH5TG8cS5NeC5gld6z4L+0xLGG8f/Jd+SZIkSZImypt+SZIkSZImykrZ9BIAABsHSURBVJt+SZIkSZImypt+SZIkSZImqpcgvyyUgEIlKKCEAmL6DppoCaXJguSOo/CpZQTJUIBKFkhHISoUfpeFqvWNQjhWVlaqf57ON405Cm/pEoWOZH1CAWD082MPX8nQXKOAs+z89B16koU6UlgOBclRqNGz2FdZ6Fzf6Jxm63PtekqhV30HYVEgJIWkRvD4qF27lrE20/qTBZHeuXOnqLUE5faN1o8sEJL2Qgrv7CrwtQX1SdYOOv90HXPlypWiNkTbIvJQWlpf6Vrr9u3bHR9RHVo3W0J7qQ+GCCOjQFoKFI7g9bk2tG8ZgYQtAW+1wYJD7Y90rnd3d6t/nsbX2NE6XBuOnbV3qHWNxh3df9D610Vor//SL0mSJEnSRHnTL0mSJEnSRHnTL0mSJEnSRHnTL0mSJEnSRC0c5NcSqkVhBRTGMJYgrCw8ioJHKEAiC6IZk7GHlrSoDcPqO7SvVksox1ChI7WydYDqFDxGnxuqn7J+uX79etXPj2V8ZdbW1qo+N9Scp/OXhT3RvKAwM1qLawNZu5TNY2ozrV1nz54tassIZqJQNApPi+BjrA1nXEbQLQUpZd9Lbaldt1v6eh40J7JwMjrX1H9j2mey8Du6ZqRwxSx0rm90DrN+oc/S+KLxmY3ZruZQy/iikNv9/f2iRn0ypjH3LKD1g8Z/BF9X0XUMzansnqurUEn6PRT2HsFBhbVzJ7sP63vcZQG7dM9Fc3ZjY6OotdyTZvyXfkmSJEmSJsqbfkmSJEmSJsqbfkmSJEmSJsqbfkmSJEmSJsqbfkmSJEmSJmrh9H5KkszSaSktkVILs4TCsahNvO8q5bJPtW0ZeyJ5BKeNU2r0WFBiakTE3t5eUWtJ5xxCNmcpwZTmPCXFDvX2i+x7Ke2a0mLHPu/v3LlT1KhtY2pHlphOfUVjicbnzZs3Fz2sZtk8oZRlWpt3dnaK2jLSr+lcZeeP+opqtDZn/dz3/pMlLVO/0LpNtSxFvc+2ZG9RoXT1bP8Zi+ytFDRuDg4OitqYrlmysUB9QOsuJeFn/dfnGzBars3pemzs1/YRfK1F46vlzWVdovHRslfT/khtGeKas+UtbbXXh5SCvwzZvkxvhKG3WvR1H+C/9EuSJEmSNFHe9EuSJEmSNFHe9EuSJEmSNFHe9EuSJEmSNFErs9ms/sMrK/+KiDLxaVzWZrPZr570gam0I8K2DMDxNT4/q7ZMpR0R02nLM9KOiOm0xfE1TlNpi+NrfH5WfRIxnbZMpR0Rz35bmm76JUmSJEnSs8PH+yVJkiRJmihv+iVJkiRJmihv+iVJkiRJmihv+iVJkiRJmihv+iVJkiRJmihv+iVJkiRJmqjnWj68srJS9X6/N954A+svvfRSUXv8+HFRu3v3blH7/vvva746IiJms9nKk/7/2na8/PLLWH/11VeL2gsvvFDU7t27V9S+++67mq+OiKe3I6K+Le+99x7Wn3/++aL2008/FbX79+8XtWW0hc7ru+++W/291Javv/66qGVtofHZ1fjK0LijOfX5558XtS7nScTibTl9+nRRO3HiRFGjudJiGW2hPqC2fPnll4t8TWfja3V1Feuvv/56Ufv0009rfmWTocYX+eqrrxb5mt73FKo/91y5PbesXYlvK96p3Pl7fGn/obZ888031b9z3vFFc/add97Bn6f98Ycffqg6PmpfRMTDhw+LWlfji9oWwe2jdiy6Dsec44uO+80338Sfp3nx97//vai17IWky/Wr5Zrl6OioqNEcp2ubTN/XLITW5pMnTxa1zz77rPp3dnkdSXM7gvdHug5cdC1exv5IaF5Rv3zxxRf48zSvuhpf2b1j7X3KmK4jX3zxRayfOXOmqNFa3Nd15MpsVj+mahv70UcfYf3SpUtF7cGDB0Xt8uXLRe3WrVs1Xx0R3Q1AOo6IiA8++KConT17tqhduXKlqGXnhnQ5ALPJsLa2VtQODw+L2tWrV4vaMtpy7ty54nO3b9+u/l5qy4cffljUsrbQ+Ox7A6Vxd/369aJ24cKFotblPIlYvC10ruk//mVzrdYy2kJjhNpC61yLrsbXxYsXsX7t2rWilm22ixhqfBFas1v0vadQncZWy9qV+OtsNvvNkz7Qx4Um7T/Ultr+jJh/fNF5zdZNmheffPJJxdFF7O7uYv3mzZtFravxRW2L4PZROxZdh2PO8UXHfePGDfx5+izN75a9kHS5ftWOmQhuN83xlhucIW76aS6///77RY2u8TJdXkfStW8E7490HbjoWjzUTT+NL+qX7DqG5lVX4ys7f7QO0/gf03UkndMIbiOtD31dR/p4vyRJkiRJE+VNvyRJkiRJE9XL4/3ZYw30iEbto/L0dxAR/IjHPI+atDxGTo+M0yNn9De1p06dwt85z2PkEfV9kj3eSu3e2Nio+ZVx/vx5rNOjKl0+ikl/apChx32oX+hR+Yh+H2VqeRST5g7VaBxlljG+6BHXra2totbyWC/psi3ZsWxubha1Rf+Eh3Q1vrLHW2l+Lvr4O+myT7JHQGmNpsczh3i8v/bPdCL4mKnN6+vrRa1lb4wlPN5P44v29EX7ad7xRdcn+/v7+PM7OztVx0LnustHfakddK6yPymo1cHaPNf4aumTWnR90vKY/bzji/6sKvtThVoHBwdFLbvOJn0/3k/XIpTNRZZxTUxjmPbzCD7XNL+pzV32ScTi/bLIn8fSeYjgNvZ9z1VrqD95pba0fC/dk/S1P/ov/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTdRzffzSLMCAwg5qA35a3kk6j5b3JNJ7dilcbnt7u6hl4W0tAWzzyMJ4KHSmNsiv7z6J4POShVlQnQIyKKCkJeBnHtTvWdATzQkai32PmRbZ+1Hv3LlT1BYNuuvbVNqShd/1EdrXJTruLAhrb2+vqFH7at/z26Vsra9F54HG4DLWYdKyfpGhjrv2vEa0hcYuW8v4ovbRnkftXTRkdSi0Diz6Hu8adH3x8OFD/Cz1QUsY3FjUXsfT+V/GdUzL9R2NG5oDY7r+ytB1IwWRr62tLeNw/g8a59k8oc9S26ifsuugLtGxZPsbHU9tEGC2H7WMRf+lX5IkSZKkifKmX5IkSZKkifKmX5IkSZKkifKmX5IkSZKkifKmX5IkSZKkieolvT9Tm9bbd5J6LUrpX9Siic5dy1KLj9vZ2SlqY0svpYRuMkSCLCXC0psTIjiRnMYipWdnb87oO2U+O/eUNjq2cXNcdnxjWZcIrSv05oqIcbcjgudKli788ccfV/08jcNszHY1PilJOEvmpjWJ+m+oNy/Q92ZveaG9gt5kk72RoW80V7KxQHOFPjv21PvsTUQ1n8vSr7tcR2jfunLlCn72+vXrRY0SyWl8LiO9n9aP7FzRWKS5Rvv3mPbR2mvl2nHYNVprWt4Ctb6+XtSy8Tkmt2/fLmq0ftFc6fuakcZ+Nk+oTjWa30O9Ma3l91NbaP/I5k9LX/kv/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTdRSg/wo2IBCyyiMoe9QCQqryULRsoCsGlmQzFABTRSueHBwUNQoQCILKhoqYIbGCJ3vlrZ0JQvwItQndHwUvpIFUnU5f6gt2ZyggCs6/xS0s4wgLAp5yYJfagO86FzXhpguA7WD+oTCZbI1sUt0TrM+of2DxmJtYGnfsiAeOq80ZpZx/gmN6bt37+JnT506VfU7aR3pe5+P4HUlm59HR0dF7fz580VtiD2FQroePnxY/fPUZprz2d7VdyBoNhZqx8hsNitqWVv6nlfZ76eAy93d3aJG46vlmqJvdP1MazOt7cvQEq5I11XUlmWsVYT2wuy+gsYIBUjT/jhU+xZBa252bzXUWFxEbVj5k/gv/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTdRSg/wIhSxQeE7fASxra2tFLQv3oSAN+vmbN28WtWchHIMCLvb394taFh6yjAA2QsEsdL6pfX0fM52rLEiGwn1qUSBe11pC6aiNdP5pHaBwoIh83M2jJeBnfX29qkb9R0FAEWW7Hz16hJ97mpaAlyyArca1a9ew3mUQKY2vLACPvpeCsGjMDBE4mo1pGkdjChqic0X7W8S4AsYItaVlX97a2qr6nX2jwN0M9QldO9E4HCpkeFEUTpbNv76D/LK5TN9La93m5mZRy9rSVcBi7dqaofVhqGtDumbP9pSxo7FE4yNzeHhY1IZYsymIdNE+aQki7VJLW2gsLnP/8F/6JUmSJEmaKG/6JUmSJEmaKG/6JUmSJEmaKG/6JUmSJEmaqIWD/CiUIAstoTC4U6dOVX1P3wEsFDqSBRXRd9J5GEt4VETExYsXsX7hwoWiNqaAEzqvLWEwGxsbVZ/rOxSHwsmobREcPEJzZ6igHGrLzs4OfpbmwOrqatXvHGocZmGIFHJVG6aVjcPjAWJ/+ctfqn7fcTROHz58WP3zdK6p77LAoKHCvmg9pXZ3NY8X1RKC2fLZMXkWjzsLwqS1gNbtbP/oE4397HqI9oXaflrG3KFzmu2PVKc9cyz9FJG3hfZCWotpTet7ntGYyULR6LzSNSftE9mY7XLc0Vyhcx/Bezrt310GCreg0NHsvoKOkULHa8OVu0TXr1lQMB0f1ai9y9iPKDQ021NoXNMx0pzqok/8l35JkiRJkibKm35JkiRJkibKm35JkiRJkibKm35JkiRJkibKm35JkiRJkiZq4fR+So3MUrcpjZBqlOqYJWr3KUsqpRTvra2tojZUUj/J0tXPnj1b9fN7e3tFjVJEu9aSwEttoSTW3d3dojaWdO+I+oTh7C0ZQ8iOhVJJaa5Q0ukQcz4ifwMCHSOlxdJYytbErt4+QrLvpHlLb4eguUN9NyQaX5TKTEnS2dtZ+pT1CR3Ls5iCH8HHTWOJzsUy9hRaX7O1huYnJSiPZa/PEsVr3x6TXSf0jY4lGwt0/XV4eFjUqM3LeLsNyb639u1CV65cKWpDjLmWN+pQm+k6IevnvtPjz58/j/XaPXmoPYWuL7LrV+oDOt/0Vp7sOjS7L+pCNk9o3FGbaU4sY0+htSab27VvhKntu1b+S78kSZIkSRPlTb8kSZIkSRPlTb8kSZIkSRPlTb8kSZIkSRO1MpvN6j+8svKviCgTU8ZlbTab/epJH5hKOyJsywAcX+Pzs2rLVNoRMZ22PCPtiJhOWxxf4zSVtji+xudn1ScR02nLVNoR8ey3pemmX5IkSZIkPTt8vF+SJEmSpInypl+SJEmSpInypl+SJEmSpInypl+SJEmSpInypl+SJEmSpInypl+SJEmSpIl6ruXDKysrC73f78SJE0Xt3XffLWqPHz8uap9//jn+TvrsbDZbedJx1LbjhRdewPpbb71V1J5//vmi9tNPPxW1Tz/9tOarI+Lp7YhYvE/eeOONovbSSy8VNTr/P/74Y/X3zNsWOq90/rPPPnjwoKh9++23Re37779/2uH9r3nGF439d955B3+e2vHZZ58VNRpfLZYxvqjd586dK2pffPFFUXv48GH193TZFjr/ETwvXnvttaJG/TLE+pU5ffp0UXvllVeKGh1zl/Mkop/1i8bcl19+ucjXdNYntN9F8F5DY4PmSUufRMS3Fe9U7nzOv/nmm0Xt0aNHRe2bb77B3znPPIngtrz44ovF586cOYM/n60Fx1FbsjHX55ynuR0RcfLkyaJG/fT3v/+9qLWsw7GE8UVjidbmMe0p2bUk9Rf11XfffVfU7t27V/PVEdH/nlLbJ/fv3y9q//znP6u/Z94+obFOe3cE74U0Z+nasss+iVi8X2jc0fUzXV9SmzPzjC9aW7P9kfqP0D0JrQMRfJ3WZZ9kx/zee+9VHQv1SYusLSuzWf2YWnQA0iLwySefFDWaTO+//z7+TvpsVwsc3ZxERNy4caOora2tFbXDw8OiRhepmWUsCh999FFRu3TpUlGj8099l5m3LXS+6Py3fJbafOvWracd3v+aZ3zR2M++k9pBY7FlgyHLGF/U7qOjo6JGY+7mzZvV39NlW7I5Ssd49erVokb9MsT6lfnwww+L2ubmZlG7cOFCUetynkT0s37RmKO+a9FVn2Rr5tmzZ4sa3aBQO1r6JCL+OpvNfvOkD/Qx52kdpuOmsRkx3zyJ4LbQXKRxFMH7Ojk4OChq2Zjrc85n54/aTP1E60DLOhxLGF80li5evFjUxrSnZNeS1F/r6+tFbW9vr6hdvny55qsjov89pbZPdnZ2ihrtoZl5+4TGeva9NAdoLaY2d9knEYv3C407Om76HK1TmXnGF11nZfvj6upq1XHcuXOnqGXrMF2nddknNOay76VatmbUytri4/2SJEmSJE2UN/2SJEmSJE1U09/094Een6Na9shtyyPmrbJH/uixF6rRI5tZOxZ9VPtpPvjgA6xvbGwUNXoErs/z/CR0Xra3t/Gz9AgWPT5X+3hT9v3zoEeMWv7Ug/ov69MxoUcVyZUrV4pa42Olnckel6axUPvnMVlftTza+CSLPr5Ij8X1vSa1yOYnrV/0KOxYZGOL1iQaR/v7+0Xt/Pnz+DuHWrOpr2gdoFr2eHqXah+vjODjoblMbckeK82uK1rRI/s0tyN4TtQ++ruy8tQnXpeq5bHjIbT8SSKNO/pTkZZrhT5lj6/To/y0p2TnoW80F7O5Qn+CQGNud3e3qGXr11BrMa01Y9nX6Zy2zBMai3TPlY3Zrq69WtGfKtBx05zq4prYf+mXJEmSJGmivOmXJEmSJGmivOmXJEmSJGmivOmXJEmSJGmiFg7yo7ABCuWKyN9VXWOIIIyWd2tTgAeFrwwVopGFWVD4Xcu7RofQEmZB53uIgEUKTcpCX+hYFpk7Q9ra2hr6EJpl57p2LCz6ftV50PqYvWP88PCwqFGAzlgCfyLyUDQy5vWrJXyzts3ZeO17z8zeQ1wbxkfr+DJC2mhcZ+eQrm9oXlFQXleBfRkKhaTwtAgeS7XnOuvnvvsq6xMK7xwTur7IAjxpraJxk/XBsrUECtKeMqZAu2x9pT6hOU/r11B7Zrav0FisDZXuu69o/WjZuynQuzbMexkWvQ7pK8jaf+mXJEmSJGmivOmXJEmSJGmivOmXJEmSJGmivOmXJEmSJGmivOmXJEmSJGmiFk7vp7TELHV1dXV17t85hKtXr2Kd0rmpRu3NEn37TpzOUlcpVXYZCcrLQunLBwcHRS1L1+3K/v5+UaMU9QhOGx1Tn1BSbJaEu76+XvU7+z7/LRZN4KWk5S5TfU+cOBEnT5586ndm6+jm5mZRo6Rl+p0t6fNdyvaUbA49a+hcU/IyrV3LSCem48v2Mjru2t85NrXXIkOlkh+XvTmE6jSndnd3i1p27dBlm2n9ob27xVBrA6VuZ0ncNAeoX+j89P3GIdLyFpW+317Rgs5zdv4oqZ/eSDZU+2guZ/cqtQnwt2/fLmpnzpzBz47prT7HjenaueWeLnvrSh/8l35JkiRJkibKm35JkiRJkibKm35JkiRJkibKm35JkiRJkiZq4SA/CuDKAnoobGJ7e7vqc32j8BQKvGpBIRrLCF0iWYgihZnQ+R9TQEYLCsgY4rhpLGShSxR+R0EyQ6EAp5ZQLmrfUEFYFBZFoUmLOjo66ux3PX78uBjDGxsbxeeydtS2b0zzuyV0iY6bAgjHFDRFx0whckOFKNH8zub8zs5OUaN9fsyBUK3GNFfIImv2Mtbm69evV38vBWTVrgNDya5paV4QuhbN+q/PUOhsHSYU6DnUnKf1v6UtYwnqjOCxXhuSHlF/LZmF545l36SgThr7y7ifpPFVG2i7bP5LvyRJkiRJE+VNvyRJkiRJE+VNvyRJkiRJE+VNvyRJkiRJE7VwkF+L2uAMCgfsG33nhQsX8LOXLl2qqlG4w1BBJhQKFcFhE1SjtlAtYjxBHxEcWkZ91TcKjNvb28PPUl/1ES43L5or2ZylAEgK8htqXlDQYzY+zpw5U9QoOIYCluh7ukRBkXS8ETyWaM4PFTpKsvFBoUYUutTSlrGsX3TM2ZrbNzr/WdATGdNe2ILGEq3PtGaMZRxlasPJssDZLsPNaP2iWkS/QXV9aRnrtFfQWOp7fabr9ZbAuNprr6yfu3T79u2ilgU90nFTGNwQ15ERfL6ycD6aK3T9RWNuTOGFhI6PrrOzwMsugz5pfmb7Ix3jMvkv/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTZQ3/ZIkSZIkTdRSg/xqw0woOGaIUInseCkcg4IcxhRUlAXBbWxsFLXDw8OiRoFZFG4SUYa63b9//+kHmKAQjixAhYJnqK+G6JdTp04VtSwUZ5EgvyycZKjQmSxEZSxoLGTjg9pCc4Dm1BBjLvvO2mPpMuhmUdn4rw2FrO27iH4D2LJQNKpT+B2tGVm431BBjBRgRMc9RGBvBI+F7BzWhpkNMVeoHdncpjXp/PnzVd8zpnUggq8F6fpkTLI15fr160Vte3u7qC0j7O446vcsfJjGF7l27VpRW0bb6DuyttD42t3dLWpjuU+JyMcX7Zu0RtDP990WWluzPYHGIoUP135PRLfto+PL9hQK8qttSxf8l35JkiRJkibKm35JkiRJkibKm35JkiRJkibKm35JkiRJkibKm35JkiRJkiZqqen9lBBJqeKUOpylOvaZip2lPtJ3ZknQY5ElSVLqJCXekyz9sss+oYTi7Piov+gYa9vXJUpRbXkLAaWUk4ODg6bj6hvNZUq9pfTSMb39IoLXL6oNkbQ8dVkSPc0VSo+nsVT7RowuZftY9iaP42hs9fm2gXnQnnLnzp0BjoTRWkqJ6Rl6u0q2v/aJznN2HUJJ5TTmKF19bOsw7emUiE37/FDXaXR8ETwvxrJ/tFwb1l6zjOltPtlaTEn9Ozs7RW2opP4WdL5r95ohZOOD3s5Bbxnb3NwsakP1U/bWk9q3o/X1dgj/pV+SJEmSpInypl+SJEmSpInypl+SJEmSpInypl+SJEmSpIlamc1m9R9eWflXRJQpBOOyNpvNfvWkD0ylHRG2ZQCOr/H5WbVlKu2ImE5bnpF2REynLY6vcZpKWxxf4/Oz6pOI6bRlKu2IePbb0nTTL0mSJEmSnh0+3i9JkiRJ0kR50y9JkiRJ0kR50y9JkiRJ0kR50y9JkiRJ0kR50y9JkiRJ0kR50y9JkiRJ0kR50y9JkiRJ0kR50y9JkiRJ0kR50y9JkiRJ0kT9f/17uTlXGu2HAAAAAElFTkSuQmCC\n",
 46 |       "text/plain": [
 47 |        "<Figure size 1296x1296 with 100 Axes>"
 48 |       ]
 49 |      },
 50 |      "metadata": {},
 51 |      "output_type": "display_data"
 52 |     }
 53 |    ],
 54 |    "source": [
 55 |     "from sklearn.datasets import load_digits\n",
 56 |     "digits = load_digits()\n",
 57 |     "X=digits.data/16\n",
 58 |     "y=digits.target\n",
 59 |     "plt.rcParams[\"figure.figsize\"] = (18,18)\n",
 60 |     "plt.gray() \n",
 61 |     "for i in range(100):\n",
 62 |     "    plt.subplot(20, 20, i + 1)\n",
 63 |     "    plt.imshow(digits.images[i], cmap=plt.cm.gray, vmax=16, interpolation='nearest')\n",
 64 |     "    plt.xticks(())\n",
 65 |     "    plt.yticks(())\n",
 66 |     "plt.show() "
 67 |    ]
 68 |   },
 69 |   {
 70 |    "cell_type": "markdown",
 71 |    "metadata": {},
 72 |    "source": [
 73 |     "# KD Tree - Build"
 74 |    ]
 75 |   },
 76 |   {
 77 |    "cell_type": "code",
 78 |    "execution_count": 3,
 79 |    "metadata": {},
 80 |    "outputs": [],
 81 |    "source": [
 82 |     "def BuildSubtree(root,points,index,depth):\n",
 83 |     "    if(depth==0):\n",
 84 |     "        return\n",
 85 |     "    length=len(index)\n",
 86 |     "    med=np.median(points[index,:],axis=0)\n",
 87 |     "    BOOL=abs(np.sum(points[index,:]<med,axis=0)-(length/2))\n",
 88 |     "    dim=np.argmin(BOOL)\n",
 89 |     "    median=med[dim]\n",
 90 |     "    left_index=np.intersect1d(np.where(points[:,dim]<median),index)\n",
 91 |     "    right_index=np.intersect1d(np.where(points[:,dim]>=median),index)\n",
 92 |     "    root.dim,root.median=dim,median\n",
 93 |     "    if(len(left_index)==1 and len(right_index)==1):\n",
 94 |     "        root.left=left_index\n",
 95 |     "        root.right=right_index\n",
 96 |     "        return\n",
 97 |     "    elif(len(left_index)==1):\n",
 98 |     "        root.left=left_index\n",
 99 |     "        root.right=Tree()\n",
100 |     "        BuildSubtree(root.right,points,right_index,depth-1)\n",
101 |     "        return\n",
102 |     "    elif(len(right_index)==1):\n",
103 |     "        root.right=right_index\n",
104 |     "        root.left=Tree()\n",
105 |     "        BuildSubtree(root.left,points,left_index,depth-1)\n",
106 |     "        return\n",
107 |     "    else:\n",
108 |     "        root.left=Tree()\n",
109 |     "        BuildSubtree(root.left,points,left_index,depth-1)\n",
110 |     "        root.right=Tree()\n",
111 |     "        BuildSubtree(root.right,points,right_index,depth-1)\n",
112 |     "        return"
113 |    ]
114 |   },
115 |   {
116 |    "cell_type": "markdown",
117 |    "metadata": {},
118 |    "source": [
119 |     "# KD Tree - Search"
120 |    ]
121 |   },
122 |   {
123 |    "cell_type": "code",
124 |    "execution_count": 4,
125 |    "metadata": {},
126 |    "outputs": [],
127 |    "source": [
128 |     "def SearchSubtree(root,data):\n",
129 |     "    if(type(root)==type(np.array(1))):\n",
130 |     "        return int(root)\n",
131 |     "    else:\n",
132 |     "        if(root.median>data[root.dim]):\n",
133 |     "            print(\"left\")\n",
134 |     "            root=SearchSubtree(root.left,data)\n",
135 |     "            return int(root)\n",
136 |     "        else:\n",
137 |     "            print(\"right\")\n",
138 |     "            root=SearchSubtree(root.right,data)\n",
139 |     "            return int(root)"
140 |    ]
141 |   },
142 |   {
143 |    "cell_type": "markdown",
144 |    "metadata": {},
145 |    "source": [
146 |     "# Build and Search"
147 |    ]
148 |   },
149 |   {
150 |    "cell_type": "code",
151 |    "execution_count": 5,
152 |    "metadata": {},
153 |    "outputs": [
154 |     {
155 |      "name": "stdout",
156 |      "output_type": "stream",
157 |      "text": [
158 |       "right\n",
159 |       "right\n",
160 |       "left\n",
161 |       "left\n",
162 |       "right\n",
163 |       "left\n",
164 |       "left\n",
165 |       "right\n",
166 |       "left\n",
167 |       "right\n",
168 |       "left\n",
169 |       "100\n"
170 |      ]
171 |     }
172 |    ],
173 |    "source": [
174 |     "class Tree:\n",
175 |     "    def __init__(self):\n",
176 |     "        self.left=None\n",
177 |     "        self.right=None\n",
178 |     "        self.dim=None\n",
179 |     "        self.median=None\n",
180 |     "root=Tree()\n",
181 |     "N,M=X.shape\n",
182 |     "Index=np.array(range(0,N))\n",
183 |     "BuildSubtree(root,X,Index,15)\n",
184 |     "search_index=SearchSubtree(root,X[100,:])\n",
185 |     "print(search_index)"
186 |    ]
187 |   },
188 |   {
189 |    "cell_type": "code",
190 |    "execution_count": null,
191 |    "metadata": {},
192 |    "outputs": [],
193 |    "source": []
194 |   }
195 |  ],
196 |  "metadata": {
197 |   "kernelspec": {
198 |    "display_name": "Python 3",
199 |    "language": "python",
200 |    "name": "python3"
201 |   },
202 |   "language_info": {
203 |    "codemirror_mode": {
204 |     "name": "ipython",
205 |     "version": 3
206 |    },
207 |    "file_extension": ".py",
208 |    "mimetype": "text/x-python",
209 |    "name": "python",
210 |    "nbconvert_exporter": "python",
211 |    "pygments_lexer": "ipython3",
212 |    "version": "3.7.4"
213 |   }
214 |  },
215 |  "nbformat": 4,
216 |  "nbformat_minor": 2
217 | }
218 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Machine-Learning-Algorithm
2 | I am now challenging myself to write a series of machine learning, deep learning, and artificial intelligence articles. These procject are some of the sample code. I hope you can enjoy in using my project！
3 | 


--------------------------------------------------------------------------------
/k鄰近搜尋(k-Nearest Neighbor Search).ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# k-Nearest Neighbor Search"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "markdown",
 12 |    "metadata": {},
 13 |    "source": [
 14 |     "##### 先引入我們需要的packages"
 15 |    ]
 16 |   },
 17 |   {
 18 |    "cell_type": "code",
 19 |    "execution_count": 1,
 20 |    "metadata": {},
 21 |    "outputs": [],
 22 |    "source": [
 23 |     "import os \n",
 24 |     "import numpy as np\n",
 25 |     "import matplotlib.pyplot as plt\n",
 26 |     "from numpy import random\n",
 27 |     "from tqdm.notebook import tqdm\n",
 28 |     "from random import choices"
 29 |    ]
 30 |   },
 31 |   {
 32 |    "cell_type": "markdown",
 33 |    "metadata": {},
 34 |    "source": [
 35 |     "# MNIST Dataset"
 36 |    ]
 37 |   },
 38 |   {
 39 |    "cell_type": "code",
 40 |    "execution_count": 2,
 41 |    "metadata": {},
 42 |    "outputs": [
 43 |     {
 44 |      "data": {
 45 |       "image/png": "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\n",
 46 |       "text/plain": [
 47 |        "<Figure size 1296x1296 with 100 Axes>"
 48 |       ]
 49 |      },
 50 |      "metadata": {},
 51 |      "output_type": "display_data"
 52 |     }
 53 |    ],
 54 |    "source": [
 55 |     "from sklearn.datasets import load_digits\n",
 56 |     "digits = load_digits()\n",
 57 |     "X=digits.data/16\n",
 58 |     "y=digits.target\n",
 59 |     "plt.rcParams[\"figure.figsize\"] = (18,18)\n",
 60 |     "plt.gray() \n",
 61 |     "for i in range(100):\n",
 62 |     "    plt.subplot(20, 20, i + 1)\n",
 63 |     "    plt.imshow(digits.images[i], cmap=plt.cm.gray, vmax=16, interpolation='nearest')\n",
 64 |     "    plt.xticks(())\n",
 65 |     "    plt.yticks(())\n",
 66 |     "plt.show() "
 67 |    ]
 68 |   },
 69 |   {
 70 |    "cell_type": "markdown",
 71 |    "metadata": {},
 72 |    "source": [
 73 |     "# Ball Tree - Build"
 74 |    ]
 75 |   },
 76 |   {
 77 |    "cell_type": "code",
 78 |    "execution_count": 5,
 79 |    "metadata": {},
 80 |    "outputs": [],
 81 |    "source": [
 82 |     "def BuildSubtree(root,points,index,leaf_size,depth):\n",
 83 |     "    if(depth==0):\n",
 84 |     "        return\n",
 85 |     "    centroid=np.mean(points[index,:],axis=0)\n",
 86 |     "    root.centroid=centroid\n",
 87 |     "    root.radius=np.max(np.sum((points[index,:]-centroid)**2,axis=1))**0.5\n",
 88 |     "    farthest_point_1=np.argmax(np.sum((points[index,:]-centroid)**2,axis=1))\n",
 89 |     "    real_index_1=index[farthest_point_1]\n",
 90 |     "    distance_array_1=np.sum((points[index,:]-points[real_index_1,:])**2,axis=1)\n",
 91 |     "    farthest_point_2=np.argmax(np.sum((points[index,:]-points[real_index_1,:])**2,axis=1))\n",
 92 |     "    real_index_2=index[farthest_point_2]\n",
 93 |     "    distance_array_2=np.sum((points[index,:]-points[real_index_2,:])**2,axis=1)\n",
 94 |     "    BOOL=(distance_array_1<=distance_array_2)\n",
 95 |     "    child1_index,child2_index=index[BOOL],index[~BOOL]\n",
 96 |     "    root.index1,root.index2=real_index_1,real_index_2\n",
 97 |     "    if(len(child1_index)<=leaf_size and len(child2_index)<=leaf_size):\n",
 98 |     "        if(depth==1):\n",
 99 |     "            print(\"tree is not complete\")\n",
100 |     "        root.child1=\"end\"\n",
101 |     "        root.child2=\"end\"\n",
102 |     "    elif(len(child1_index)<=leaf_size):\n",
103 |     "        root.child1=\"end\"\n",
104 |     "        root.child2=Tree()\n",
105 |     "        BuildSubtree(root.child2,points,child2_index,leaf_size,depth-1)\n",
106 |     "    elif(len(child2_index)<=leaf_size):\n",
107 |     "        root.child2=\"end\"\n",
108 |     "        root.child1=Tree()\n",
109 |     "        BuildSubtree(root.child1,points,child1_index,leaf_size,depth-1)\n",
110 |     "    else:\n",
111 |     "        root.child1=Tree()\n",
112 |     "        BuildSubtree(root.child1,points,child1_index,leaf_size,depth-1)\n",
113 |     "        root.child2=Tree()\n",
114 |     "        BuildSubtree(root.child2,points,child2_index,leaf_size,depth-1)\n",
115 |     "    return"
116 |    ]
117 |   },
118 |   {
119 |    "cell_type": "markdown",
120 |    "metadata": {},
121 |    "source": [
122 |     "# kNN Search"
123 |    ]
124 |   },
125 |   {
126 |    "cell_type": "code",
127 |    "execution_count": 3,
128 |    "metadata": {},
129 |    "outputs": [],
130 |    "source": [
131 |     "def check(X,p,k,Q,index):\n",
132 |     "    if(np.sum((p-X[index,:])**2)<np.sum((p-X[Q[0],:])**2)):\n",
133 |     "        Q.append(index)\n",
134 |     "        if(len(Q)>k):\n",
135 |     "            Q=np.array(Q)\n",
136 |     "            Q=list(Q[np.argsort(-1*np.sum((p-X[Q,:])**2,axis=1))])\n",
137 |     "            del Q[0]\n",
138 |     "    return Q\n",
139 |     "def kNN_search(X,p,k,Q,root):\n",
140 |     "    if(np.sqrt(np.sum((p-root.centroid)**2))-root.radius>=np.sqrt(np.sum((p-X[Q[0],:])**2))):\n",
141 |     "        return Q\n",
142 |     "    elif(root.child1==\"end\" and root.child2==\"end\"):\n",
143 |     "        Q=check(X,p,k,Q,root.index1)\n",
144 |     "        Q=check(X,p,k,Q,root.index2)\n",
145 |     "        return Q\n",
146 |     "    elif(root.child1==\"end\"):\n",
147 |     "        Q=check(X,p,k,Q,root.index1)\n",
148 |     "        Q=kNN_search(X,p,k,Q,root.child2)\n",
149 |     "        return Q\n",
150 |     "    elif(root.child2==\"end\"):\n",
151 |     "        Q=check(X,p,k,Q,root.index2)\n",
152 |     "        Q=kNN_search(X,p,k,Q,root.child1)\n",
153 |     "        return Q\n",
154 |     "    else:\n",
155 |     "        Q=kNN_search(X,p,k,Q,root.child1)\n",
156 |     "        Q=kNN_search(X,p,k,Q,root.child2)\n",
157 |     "        return Q    "
158 |    ]
159 |   },
160 |   {
161 |    "cell_type": "markdown",
162 |    "metadata": {},
163 |    "source": [
164 |     "# Build an Search"
165 |    ]
166 |   },
167 |   {
168 |    "cell_type": "code",
169 |    "execution_count": 6,
170 |    "metadata": {},
171 |    "outputs": [
172 |     {
173 |      "data": {
174 |       "application/vnd.jupyter.widget-view+json": {
175 |        "model_id": "073eb26596444239a97cd8be33505df3",
176 |        "version_major": 2,
177 |        "version_minor": 0
178 |       },
179 |       "text/plain": [
180 |        "HBox(children=(IntProgress(value=0, max=1797), HTML(value='')))"
181 |       ]
182 |      },
183 |      "metadata": {},
184 |      "output_type": "display_data"
185 |     },
186 |     {
187 |      "name": "stdout",
188 |      "output_type": "stream",
189 |      "text": [
190 |       "\n",
191 |       "[[0. 0. 0. ... 0. 0. 0.]\n",
192 |       " [0. 0. 0. ... 0. 0. 0.]\n",
193 |       " [0. 0. 0. ... 0. 0. 0.]\n",
194 |       " ...\n",
195 |       " [0. 0. 0. ... 0. 0. 0.]\n",
196 |       " [0. 0. 0. ... 0. 0. 0.]\n",
197 |       " [0. 0. 0. ... 0. 0. 0.]]\n"
198 |      ]
199 |     }
200 |    ],
201 |    "source": [
202 |     "class Tree:\n",
203 |     "    def __init__(self):\n",
204 |     "        self.child1=None\n",
205 |     "        self.child2=None\n",
206 |     "        self.radius=None\n",
207 |     "        self.centroid=None\n",
208 |     "        self.index1=None\n",
209 |     "        self.index2=None\n",
210 |     "root=Tree()\n",
211 |     "N,M=X.shape\n",
212 |     "Index=np.array(range(0,N))\n",
213 |     "BuildSubtree(root,X,Index,1,30)\n",
214 |     "Mat=np.zeros((N,N))\n",
215 |     "for i in tqdm(range(0,N)):\n",
216 |     "    k=5\n",
217 |     "    Q=[]\n",
218 |     "    while(len(Q)!=k):\n",
219 |     "        Q=list(np.random.randint(N,size=1))\n",
220 |     "        Q=kNN_search(X,X[i,:],k,Q,root)\n",
221 |     "    Mat[i,Q]=np.sqrt(np.sum((X[Q,:]-X[i,:])**2,axis=1))\n",
222 |     "print(Mat)"
223 |    ]
224 |   },
225 |   {
226 |    "cell_type": "code",
227 |    "execution_count": null,
228 |    "metadata": {},
229 |    "outputs": [],
230 |    "source": []
231 |   }
232 |  ],
233 |  "metadata": {
234 |   "kernelspec": {
235 |    "display_name": "Python 3",
236 |    "language": "python",
237 |    "name": "python3"
238 |   },
239 |   "language_info": {
240 |    "codemirror_mode": {
241 |     "name": "ipython",
242 |     "version": 3
243 |    },
244 |    "file_extension": ".py",
245 |    "mimetype": "text/x-python",
246 |    "name": "python",
247 |    "nbconvert_exporter": "python",
248 |    "pygments_lexer": "ipython3",
249 |    "version": "3.7.4"
250 |   }
251 |  },
252 |  "nbformat": 4,
253 |  "nbformat_minor": 2
254 | }
255 | 


--------------------------------------------------------------------------------
/半正定嵌入演算法(Semidefinite Embedding).ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# 半正定嵌入演算法(Semidefinite Embedding)"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "markdown",
 12 |    "metadata": {},
 13 |    "source": [
 14 |     "##### 先引入我們需要的packages"
 15 |    ]
 16 |   },
 17 |   {
 18 |    "cell_type": "code",
 19 |    "execution_count": 1,
 20 |    "metadata": {},
 21 |    "outputs": [],
 22 |    "source": [
 23 |     "import os \n",
 24 |     "import numpy as np\n",
 25 |     "import matplotlib.pyplot as plt\n",
 26 |     "from tqdm.notebook import tqdm\n",
 27 |     "import cvxpy as cp\n",
 28 |     "from scipy.io import loadmat  "
 29 |    ]
 30 |   },
 31 |   {
 32 |    "cell_type": "markdown",
 33 |    "metadata": {},
 34 |    "source": [
 35 |     "# MNIST Dataset"
 36 |    ]
 37 |   },
 38 |   {
 39 |    "cell_type": "code",
 40 |    "execution_count": 7,
 41 |    "metadata": {},
 42 |    "outputs": [
 43 |     {
 44 |      "data": {
 45 |       "image/png": "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\n",
 46 |       "text/plain": [
 47 |        "<Figure size 1296x1296 with 100 Axes>"
 48 |       ]
 49 |      },
 50 |      "metadata": {},
 51 |      "output_type": "display_data"
 52 |     }
 53 |    ],
 54 |    "source": [
 55 |     "from sklearn.datasets import load_digits\n",
 56 |     "digits = load_digits()\n",
 57 |     "X=(digits.data/16)[:100]\n",
 58 |     "y=digits.target[:100]\n",
 59 |     "plt.rcParams[\"figure.figsize\"] = (18,18)\n",
 60 |     "plt.gray() \n",
 61 |     "for i in range(100):\n",
 62 |     "    plt.subplot(20, 20, i + 1)\n",
 63 |     "    plt.imshow(digits.images[i], cmap=plt.cm.gray, vmax=16, interpolation='nearest')\n",
 64 |     "    plt.xticks(())\n",
 65 |     "    plt.yticks(())\n",
 66 |     "plt.show() "
 67 |    ]
 68 |   },
 69 |   {
 70 |    "cell_type": "markdown",
 71 |    "metadata": {},
 72 |    "source": [
 73 |     "# Ball Tree"
 74 |    ]
 75 |   },
 76 |   {
 77 |    "cell_type": "code",
 78 |    "execution_count": 8,
 79 |    "metadata": {},
 80 |    "outputs": [],
 81 |    "source": [
 82 |     "def BuildSubtree(root,points,index,leaf_size,depth):\n",
 83 |     "    if(depth==0):\n",
 84 |     "        return\n",
 85 |     "    centroid=np.mean(points[index,:],axis=0)\n",
 86 |     "    root.centroid=centroid\n",
 87 |     "    root.radius=np.max(np.sum((points[index,:]-centroid)**2,axis=1))**0.5\n",
 88 |     "    farthest_point_1=np.argmax(np.sum((points[index,:]-centroid)**2,axis=1))\n",
 89 |     "    real_index_1=index[farthest_point_1]\n",
 90 |     "    distance_array_1=np.sum((points[index,:]-points[real_index_1,:])**2,axis=1)\n",
 91 |     "    farthest_point_2=np.argmax(np.sum((points[index,:]-points[real_index_1,:])**2,axis=1))\n",
 92 |     "    real_index_2=index[farthest_point_2]\n",
 93 |     "    distance_array_2=np.sum((points[index,:]-points[real_index_2,:])**2,axis=1)\n",
 94 |     "    BOOL=(distance_array_1<=distance_array_2)\n",
 95 |     "    child1_index,child2_index=index[BOOL],index[~BOOL]\n",
 96 |     "    root.index1,root.index2=real_index_1,real_index_2\n",
 97 |     "    if(len(child1_index)<=leaf_size and len(child2_index)<=leaf_size):\n",
 98 |     "        if(depth==1):\n",
 99 |     "            print(\"tree is not complete\")\n",
100 |     "        root.child1=\"end\"\n",
101 |     "        root.child2=\"end\"\n",
102 |     "    elif(len(child1_index)<=leaf_size):\n",
103 |     "        root.child1=\"end\"\n",
104 |     "        root.child2=Tree()\n",
105 |     "        BuildSubtree(root.child2,points,child2_index,leaf_size,depth-1)\n",
106 |     "    elif(len(child2_index)<=leaf_size):\n",
107 |     "        root.child2=\"end\"\n",
108 |     "        root.child1=Tree()\n",
109 |     "        BuildSubtree(root.child1,points,child1_index,leaf_size,depth-1)\n",
110 |     "    else:\n",
111 |     "        root.child1=Tree()\n",
112 |     "        BuildSubtree(root.child1,points,child1_index,leaf_size,depth-1)\n",
113 |     "        root.child2=Tree()\n",
114 |     "        BuildSubtree(root.child2,points,child2_index,leaf_size,depth-1)\n",
115 |     "    return"
116 |    ]
117 |   },
118 |   {
119 |    "cell_type": "markdown",
120 |    "metadata": {},
121 |    "source": [
122 |     "# k-Nearest Neighbor Search"
123 |    ]
124 |   },
125 |   {
126 |    "cell_type": "code",
127 |    "execution_count": 9,
128 |    "metadata": {},
129 |    "outputs": [],
130 |    "source": [
131 |     "def check(X,p,k,Q,index):\n",
132 |     "    if(np.sum((p-X[index,:])**2)<np.sum((p-X[Q[0],:])**2)):\n",
133 |     "        Q.append(index)\n",
134 |     "        Q=np.array(Q)\n",
135 |     "        Q=list(Q[np.argsort(-1*np.sum((p-X[Q,:])**2,axis=1))])\n",
136 |     "        if(len(Q)>k):    \n",
137 |     "            del Q[0]\n",
138 |     "    return Q\n",
139 |     "\n",
140 |     "def kNN_search(X,p,k,Q,root):\n",
141 |     "    if(np.sqrt(np.sum((p-root.centroid)**2))-root.radius>=np.sqrt(np.sum((p-X[Q[0],:])**2))):\n",
142 |     "        return Q\n",
143 |     "    elif(root.child1==\"end\" and root.child2==\"end\"):\n",
144 |     "        Q=check(X,p,k,Q,root.index1)\n",
145 |     "        Q=check(X,p,k,Q,root.index2)\n",
146 |     "    elif(root.child1==\"end\"):\n",
147 |     "        Q=check(X,p,k,Q,root.index1)\n",
148 |     "        Q=kNN_search(X,p,k,Q,root.child2)\n",
149 |     "    elif(root.child2==\"end\"):\n",
150 |     "        Q=check(X,p,k,Q,root.index2)\n",
151 |     "        Q=kNN_search(X,p,k,Q,root.child1)\n",
152 |     "    else:\n",
153 |     "        Q=kNN_search(X,p,k,Q,root.child1)\n",
154 |     "        Q=kNN_search(X,p,k,Q,root.child2)\n",
155 |     "    return Q    "
156 |    ]
157 |   },
158 |   {
159 |    "cell_type": "code",
160 |    "execution_count": 10,
161 |    "metadata": {},
162 |    "outputs": [
163 |     {
164 |      "data": {
165 |       "application/vnd.jupyter.widget-view+json": {
166 |        "model_id": "fc65bdf5bd79459fb8415f55e9000dea",
167 |        "version_major": 2,
168 |        "version_minor": 0
169 |       },
170 |       "text/plain": [
171 |        "HBox(children=(IntProgress(value=0), HTML(value='')))"
172 |       ]
173 |      },
174 |      "metadata": {},
175 |      "output_type": "display_data"
176 |     },
177 |     {
178 |      "name": "stdout",
179 |      "output_type": "stream",
180 |      "text": [
181 |       "\n"
182 |      ]
183 |     }
184 |    ],
185 |    "source": [
186 |     "class Tree:\n",
187 |     "    def __init__(self):\n",
188 |     "        self.child1=None\n",
189 |     "        self.child2=None\n",
190 |     "        self.radius=None\n",
191 |     "        self.centroid=None\n",
192 |     "        self.index1=None\n",
193 |     "        self.index2=None\n",
194 |     "root=Tree()\n",
195 |     "N,M=X.shape\n",
196 |     "Index=np.array(range(0,N))\n",
197 |     "BuildSubtree(root,X,Index,1,30)\n",
198 |     "n_neighbors=10\n",
199 |     "neighbors=np.zeros((N,n_neighbors))\n",
200 |     "for i in tqdm(range(N)):\n",
201 |     "    Q=[]\n",
202 |     "    while(len(Q)!=n_neighbors+1):\n",
203 |     "        Q=list(np.random.randint(N,size=1))\n",
204 |     "        Q=kNN_search(X,X[i,:],n_neighbors+1,Q,root)\n",
205 |     "    del Q[n_neighbors]\n",
206 |     "    neighbors[i]=Q"
207 |    ]
208 |   },
209 |   {
210 |    "cell_type": "markdown",
211 |    "metadata": {},
212 |    "source": [
213 |     "# SDE"
214 |    ]
215 |   },
216 |   {
217 |    "cell_type": "code",
218 |    "execution_count": 11,
219 |    "metadata": {},
220 |    "outputs": [
221 |     {
222 |      "data": {
223 |       "application/vnd.jupyter.widget-view+json": {
224 |        "model_id": "456b576893e840e1b6592d0de6cba9b5",
225 |        "version_major": 2,
226 |        "version_minor": 0
227 |       },
228 |       "text/plain": [
229 |        "HBox(children=(IntProgress(value=0), HTML(value='')))"
230 |       ]
231 |      },
232 |      "metadata": {},
233 |      "output_type": "display_data"
234 |     },
235 |     {
236 |      "name": "stdout",
237 |      "output_type": "stream",
238 |      "text": [
239 |       "\n"
240 |      ]
241 |     },
242 |     {
243 |      "data": {
244 |       "text/plain": [
245 |        "10.416963755517614"
246 |       ]
247 |      },
248 |      "execution_count": 11,
249 |      "metadata": {},
250 |      "output_type": "execute_result"
251 |     }
252 |    ],
253 |    "source": [
254 |     "P = cp.Constant(np.dot(X,X.T))\n",
255 |     "Q = cp.Variable((N,N), PSD=True)\n",
256 |     "Q.value = np.zeros((N,N))\n",
257 |     "ONES = cp.Constant(np.ones((N, 1)))\n",
258 |     "T = cp.Constant(N)\n",
259 |     "objective = cp.Maximize(cp.multiply((1 / T),cp.trace(Q))-cp.multiply((1 / (T * T)),cp.trace(cp.matmul(cp.matmul(Q, ONES), ONES.T))))\n",
260 |     "constraints = [Q >> 0, cp.sum(Q, axis=1) == 0]\n",
261 |     "neighbors=neighbors.astype(int)\n",
262 |     "for i in tqdm(range(N)):\n",
263 |     "    for j in  neighbors[i]:\n",
264 |     "        constraints.append((P[i, i] + P[j, j] - P[i, j] - P[j, i]) -\n",
265 |     "                           (Q[i, i] + Q[j, j] - Q[i, j] - Q[j, i]) == 0)\n",
266 |     "problem = cp.Problem(objective, constraints)\n",
267 |     "problem.solve(solver=cp.CVXOPT,eps=1e-2,max_iters=2500,warm_start=False)"
268 |    ]
269 |   },
270 |   {
271 |    "cell_type": "markdown",
272 |    "metadata": {},
273 |    "source": [
274 |     "# LDL Decomposition"
275 |    ]
276 |   },
277 |   {
278 |    "cell_type": "code",
279 |    "execution_count": 12,
280 |    "metadata": {},
281 |    "outputs": [],
282 |    "source": [
283 |     "from scipy.linalg import ldl\n",
284 |     "l, d, perm = ldl(Q.value)\n",
285 |     "X_sub=np.dot(l[:,:2],np.diag(np.diagonal(d)[:2]))"
286 |    ]
287 |   },
288 |   {
289 |    "cell_type": "markdown",
290 |    "metadata": {},
291 |    "source": [
292 |     "# Plot"
293 |    ]
294 |   },
295 |   {
296 |    "cell_type": "code",
297 |    "execution_count": 13,
298 |    "metadata": {},
299 |    "outputs": [
300 |     {
301 |      "data": {
302 |       "image/png": "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\n",
303 |       "text/plain": [
304 |        "<Figure size 1296x1296 with 1 Axes>"
305 |       ]
306 |      },
307 |      "metadata": {
308 |       "needs_background": "light"
309 |      },
310 |      "output_type": "display_data"
311 |     }
312 |    ],
313 |    "source": [
314 |     "color=[\"#FF0000\",\"#FFFF00\",\"#00FF00\",\"#00FFFF\",\"#0000FF\",\n",
315 |     "       \"#FF00FF\",\"#FF0088\",\"#FF8800\",\"#00FF99\",\"#7700FF\"]\n",
316 |     "plt.rcParams[\"figure.figsize\"] = (18,18)\n",
317 |     "for i in range(0,10):\n",
318 |     "    BOOL=(y==i)\n",
319 |     "    plt.scatter(X_sub[BOOL,0],X_sub[BOOL,1],c=color[i],label=i)\n",
320 |     "plt.xticks(fontsize=30)\n",
321 |     "plt.yticks(fontsize=30)\n",
322 |     "plt.legend(fontsize=20)\n",
323 |     "plt.show()"
324 |    ]
325 |   },
326 |   {
327 |    "cell_type": "code",
328 |    "execution_count": null,
329 |    "metadata": {},
330 |    "outputs": [],
331 |    "source": []
332 |   }
333 |  ],
334 |  "metadata": {
335 |   "kernelspec": {
336 |    "display_name": "Python 3",
337 |    "language": "python",
338 |    "name": "python3"
339 |   },
340 |   "language_info": {
341 |    "codemirror_mode": {
342 |     "name": "ipython",
343 |     "version": 3
344 |    },
345 |    "file_extension": ".py",
346 |    "mimetype": "text/x-python",
347 |    "name": "python",
348 |    "nbconvert_exporter": "python",
349 |    "pygments_lexer": "ipython3",
350 |    "version": "3.7.4"
351 |   }
352 |  },
353 |  "nbformat": 4,
354 |  "nbformat_minor": 2
355 | }
356 | 


--------------------------------------------------------------------------------
/球樹(Ball Tree).ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# 球樹(Ball Tree)"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "markdown",
 12 |    "metadata": {},
 13 |    "source": [
 14 |     "##### 先引入我們需要的packages"
 15 |    ]
 16 |   },
 17 |   {
 18 |    "cell_type": "code",
 19 |    "execution_count": 5,
 20 |    "metadata": {},
 21 |    "outputs": [],
 22 |    "source": [
 23 |     "import os \n",
 24 |     "import numpy as np\n",
 25 |     "import matplotlib.pyplot as plt\n",
 26 |     "from numpy import random\n",
 27 |     "from tqdm.notebook import tqdm\n",
 28 |     "from random import choices"
 29 |    ]
 30 |   },
 31 |   {
 32 |    "cell_type": "markdown",
 33 |    "metadata": {},
 34 |    "source": [
 35 |     "# MNIST Dataset"
 36 |    ]
 37 |   },
 38 |   {
 39 |    "cell_type": "code",
 40 |    "execution_count": 6,
 41 |    "metadata": {},
 42 |    "outputs": [
 43 |     {
 44 |      "data": {
 45 |       "image/png": "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\n",
 46 |       "text/plain": [
 47 |        "<Figure size 1296x1296 with 100 Axes>"
 48 |       ]
 49 |      },
 50 |      "metadata": {},
 51 |      "output_type": "display_data"
 52 |     }
 53 |    ],
 54 |    "source": [
 55 |     "from sklearn.datasets import load_digits\n",
 56 |     "digits = load_digits()\n",
 57 |     "X=digits.data/16\n",
 58 |     "y=digits.target\n",
 59 |     "plt.rcParams[\"figure.figsize\"] = (18,18)\n",
 60 |     "plt.gray() \n",
 61 |     "for i in range(100):\n",
 62 |     "    plt.subplot(20, 20, i + 1)\n",
 63 |     "    plt.imshow(digits.images[i], cmap=plt.cm.gray, vmax=16, interpolation='nearest')\n",
 64 |     "    plt.xticks(())\n",
 65 |     "    plt.yticks(())\n",
 66 |     "plt.show() "
 67 |    ]
 68 |   },
 69 |   {
 70 |    "cell_type": "markdown",
 71 |    "metadata": {},
 72 |    "source": [
 73 |     "# Ball Tree - Build"
 74 |    ]
 75 |   },
 76 |   {
 77 |    "cell_type": "code",
 78 |    "execution_count": 7,
 79 |    "metadata": {},
 80 |    "outputs": [],
 81 |    "source": [
 82 |     "def BuildSubtree(root,points,index,leaf_size,depth):\n",
 83 |     "    if(depth==0):\n",
 84 |     "        return\n",
 85 |     "    centroid=np.mean(points[index,:],axis=0)\n",
 86 |     "    farthest_point_1=np.argmax(np.sum((points[index,:]-centroid)**2,axis=1))\n",
 87 |     "    real_index_1=index[farthest_point_1]\n",
 88 |     "    distance_array_1=np.sum((points[index,:]-points[real_index_1,:])**2,axis=1)\n",
 89 |     "    farthest_point_2=np.argmax(np.sum((points[index,:]-points[real_index_1,:])**2,axis=1))\n",
 90 |     "    real_index_2=index[farthest_point_2]\n",
 91 |     "    distance_array_2=np.sum((points[index,:]-points[real_index_2,:])**2,axis=1)\n",
 92 |     "    BOOL=(distance_array_1<=distance_array_2)\n",
 93 |     "    child1_index,child2_index=index[BOOL],index[~BOOL]\n",
 94 |     "    root.index1,root.index2=real_index_1,real_index_2\n",
 95 |     "    if(len(child1_index)<=leaf_size and len(child2_index)<=leaf_size):\n",
 96 |     "        if(depth==1):\n",
 97 |     "            print(\"tree is not complete\")\n",
 98 |     "        root.child1=child1_index\n",
 99 |     "        root.child2=child2_index\n",
100 |     "    elif(len(child1_index)<=leaf_size):\n",
101 |     "        root.child1=child1_index\n",
102 |     "        root.child2=Tree()\n",
103 |     "        BuildSubtree(root.child2,points,child2_index,leaf_size,depth-1)\n",
104 |     "    elif(len(child2_index)<=leaf_size):\n",
105 |     "        root.child2=child2_index\n",
106 |     "        root.child1=Tree()\n",
107 |     "        BuildSubtree(root.child1,points,child1_index,leaf_size,depth-1)\n",
108 |     "    else:\n",
109 |     "        root.child1=Tree()\n",
110 |     "        BuildSubtree(root.child1,points,child1_index,leaf_size,depth-1)\n",
111 |     "        root.child2=Tree()\n",
112 |     "        BuildSubtree(root.child2,points,child2_index,leaf_size,depth-1)\n",
113 |     "    return"
114 |    ]
115 |   },
116 |   {
117 |    "cell_type": "markdown",
118 |    "metadata": {},
119 |    "source": [
120 |     "# Ball Tree - Search"
121 |    ]
122 |   },
123 |   {
124 |    "cell_type": "code",
125 |    "execution_count": 8,
126 |    "metadata": {},
127 |    "outputs": [],
128 |    "source": [
129 |     "def SearchSubtree(root,points,data):\n",
130 |     "    if(type(root)==type(np.array(1))):\n",
131 |     "        return root\n",
132 |     "    else:\n",
133 |     "        distance1=np.sum((points[root.index1,:]-data)**2)\n",
134 |     "        distance2=np.sum((points[root.index2,:]-data)**2)\n",
135 |     "        if(distance1<=distance2):\n",
136 |     "            print(\"child1\")\n",
137 |     "            root=SearchSubtree(root.child1,points,data)\n",
138 |     "            return root\n",
139 |     "        else:\n",
140 |     "            print(\"child2\")\n",
141 |     "            root=SearchSubtree(root.child2,points,data)\n",
142 |     "            return root"
143 |    ]
144 |   },
145 |   {
146 |    "cell_type": "markdown",
147 |    "metadata": {},
148 |    "source": [
149 |     "# Build and Search"
150 |    ]
151 |   },
152 |   {
153 |    "cell_type": "code",
154 |    "execution_count": 9,
155 |    "metadata": {},
156 |    "outputs": [
157 |     {
158 |      "name": "stdout",
159 |      "output_type": "stream",
160 |      "text": [
161 |       "child2\n",
162 |       "child1\n",
163 |       "child2\n",
164 |       "child1\n",
165 |       "child2\n",
166 |       "child2\n",
167 |       "child2\n",
168 |       "child2\n",
169 |       "child2\n",
170 |       "child2\n",
171 |       "child2\n",
172 |       "child2\n",
173 |       "child2\n",
174 |       "[ 24  97 100]\n"
175 |      ]
176 |     }
177 |    ],
178 |    "source": [
179 |     "class Tree:\n",
180 |     "    def __init__(self):\n",
181 |     "        self.child1=None\n",
182 |     "        self.child2=None\n",
183 |     "        self.index1=None\n",
184 |     "        self.index2=None\n",
185 |     "root=Tree()\n",
186 |     "N,M=X.shape\n",
187 |     "Index=np.array(range(0,N))\n",
188 |     "BuildSubtree(root,X,Index,4,18)\n",
189 |     "value=SearchSubtree(root,X,X[100,:])\n",
190 |     "print(value)"
191 |    ]
192 |   },
193 |   {
194 |    "cell_type": "code",
195 |    "execution_count": null,
196 |    "metadata": {},
197 |    "outputs": [],
198 |    "source": []
199 |   }
200 |  ],
201 |  "metadata": {
202 |   "kernelspec": {
203 |    "display_name": "Python 3",
204 |    "language": "python",
205 |    "name": "python3"
206 |   },
207 |   "language_info": {
208 |    "codemirror_mode": {
209 |     "name": "ipython",
210 |     "version": 3
211 |    },
212 |    "file_extension": ".py",
213 |    "mimetype": "text/x-python",
214 |    "name": "python",
215 |    "nbconvert_exporter": "python",
216 |    "pygments_lexer": "ipython3",
217 |    "version": "3.7.4"
218 |   }
219 |  },
220 |  "nbformat": 4,
221 |  "nbformat_minor": 2
222 | }
223 | 


--------------------------------------------------------------------------------
/神經網絡(Neural Network).ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# 神經網絡(Neural Network)"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "markdown",
 12 |    "metadata": {},
 13 |    "source": [
 14 |     "##### 先引入我們需要的packages"
 15 |    ]
 16 |   },
 17 |   {
 18 |    "cell_type": "code",
 19 |    "execution_count": 1,
 20 |    "metadata": {},
 21 |    "outputs": [],
 22 |    "source": [
 23 |     "import os \n",
 24 |     "import numpy as np\n",
 25 |     "import matplotlib.pyplot as plt\n",
 26 |     "from tqdm.notebook import tqdm"
 27 |    ]
 28 |   },
 29 |   {
 30 |    "cell_type": "markdown",
 31 |    "metadata": {},
 32 |    "source": [
 33 |     "# MNIST Dataset"
 34 |    ]
 35 |   },
 36 |   {
 37 |    "cell_type": "code",
 38 |    "execution_count": 2,
 39 |    "metadata": {},
 40 |    "outputs": [
 41 |     {
 42 |      "data": {
 43 |       "image/png": "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\n",
 44 |       "text/plain": [
 45 |        "<Figure size 1296x1296 with 100 Axes>"
 46 |       ]
 47 |      },
 48 |      "metadata": {},
 49 |      "output_type": "display_data"
 50 |     }
 51 |    ],
 52 |    "source": [
 53 |     "from sklearn.datasets import load_digits\n",
 54 |     "digits = load_digits()\n",
 55 |     "X=(digits.data/16)\n",
 56 |     "y=digits.target\n",
 57 |     "plt.rcParams[\"figure.figsize\"] = (18,18)\n",
 58 |     "plt.gray() \n",
 59 |     "for i in range(100):\n",
 60 |     "    plt.subplot(20, 20, i + 1)\n",
 61 |     "    plt.imshow(digits.images[i], cmap=plt.cm.gray, vmax=16, interpolation='nearest')\n",
 62 |     "    plt.xticks(())\n",
 63 |     "    plt.yticks(())\n",
 64 |     "plt.show() "
 65 |    ]
 66 |   },
 67 |   {
 68 |    "cell_type": "markdown",
 69 |    "metadata": {},
 70 |    "source": [
 71 |     "# ReLu and Softmax Function "
 72 |    ]
 73 |   },
 74 |   {
 75 |    "cell_type": "code",
 76 |    "execution_count": 3,
 77 |    "metadata": {},
 78 |    "outputs": [],
 79 |    "source": [
 80 |     "def softmax(s):\n",
 81 |     "    return np.exp(s)/np.sum(np.exp(s),axis=1)[:,None]\n",
 82 |     "def relu(s):\n",
 83 |     "    return np.maximum(s,0)"
 84 |    ]
 85 |   },
 86 |   {
 87 |    "cell_type": "markdown",
 88 |    "metadata": {},
 89 |    "source": [
 90 |     "# Parameter Setting"
 91 |    ]
 92 |   },
 93 |   {
 94 |    "cell_type": "code",
 95 |    "execution_count": 5,
 96 |    "metadata": {},
 97 |    "outputs": [],
 98 |    "source": [
 99 |     "Y=np.zeros((X.shape[0],10),dtype=int)\n",
100 |     "for i in range(10):\n",
101 |     "    Y[y==i,i]=1\n",
102 |     "hidden_layers=[20,30,30,20]\n",
103 |     "n_feature=X.shape[1]\n",
104 |     "n_output=Y.shape[1]\n",
105 |     "W=[np.random.rand(n_feature,hidden_layers[0])-0.5,\n",
106 |     "   np.random.rand(hidden_layers[0],hidden_layers[1])-0.5,\n",
107 |     "   np.random.rand(hidden_layers[1],hidden_layers[2])-0.5,\n",
108 |     "   np.random.rand(hidden_layers[2],hidden_layers[3])-0.5,\n",
109 |     "   np.random.rand(hidden_layers[3],n_output)-0.5]\n",
110 |     "b=[np.random.rand(hidden_layers[0])-0.5,\n",
111 |     "   np.random.rand(hidden_layers[1])-0.5,\n",
112 |     "   np.random.rand(hidden_layers[2])-0.5,\n",
113 |     "   np.random.rand(hidden_layers[3])-0.5,\n",
114 |     "   np.random.rand(n_output)]\n",
115 |     "N=1600\n",
116 |     "O=[np.zeros((N,hidden_layers[0])),\n",
117 |     "   np.zeros((N,hidden_layers[1])),\n",
118 |     "   np.zeros((N,hidden_layers[2])),\n",
119 |     "   np.zeros((N,hidden_layers[3])),\n",
120 |     "   np.zeros((N,n_output))]\n",
121 |     "W_grad=W.copy()\n",
122 |     "b_grad=b.copy()"
123 |    ]
124 |   },
125 |   {
126 |    "cell_type": "markdown",
127 |    "metadata": {},
128 |    "source": [
129 |     "# Feed Forward"
130 |    ]
131 |   },
132 |   {
133 |    "cell_type": "code",
134 |    "execution_count": 6,
135 |    "metadata": {},
136 |    "outputs": [],
137 |    "source": [
138 |     "def feedforward(X,W,b,O):\n",
139 |     "    temp=X.copy()\n",
140 |     "    for i in range(len(W)):\n",
141 |     "        if(i==4):\n",
142 |     "            temp=softmax(np.dot(temp,W[i]))\n",
143 |     "            O[i]=temp\n",
144 |     "        else:\n",
145 |     "            temp=relu(np.dot(temp,W[i]))\n",
146 |     "            O[i]=temp\n",
147 |     "    return O"
148 |    ]
149 |   },
150 |   {
151 |    "cell_type": "markdown",
152 |    "metadata": {},
153 |    "source": [
154 |     "# BackPropagation"
155 |    ]
156 |   },
157 |   {
158 |    "cell_type": "code",
159 |    "execution_count": 7,
160 |    "metadata": {},
161 |    "outputs": [],
162 |    "source": [
163 |     "def backpropagation(X,Y,W,O,W_grad,b_grad):\n",
164 |     "    for i in range(len(W)-1,-1,-1):\n",
165 |     "        if(i==4):\n",
166 |     "            delta=O[i]-Y\n",
167 |     "        else:\n",
168 |     "            delta=np.sign(O[i])*(np.dot(W[i+1],delta.T).T)\n",
169 |     "        if(i==0):\n",
170 |     "            W_grad[i]=np.mean(X[:,:,None]*delta[:,None,:],axis=0)\n",
171 |     "        else:\n",
172 |     "            W_grad[i]=np.mean(O[i-1][:,:,None]*delta[:,None,:],axis=0)\n",
173 |     "        b_grad[i]=np.mean(delta,axis=0)\n",
174 |     "    return W_grad,b_grad"
175 |    ]
176 |   },
177 |   {
178 |    "cell_type": "markdown",
179 |    "metadata": {},
180 |    "source": [
181 |     "# Neural Network"
182 |    ]
183 |   },
184 |   {
185 |    "cell_type": "code",
186 |    "execution_count": 8,
187 |    "metadata": {},
188 |    "outputs": [
189 |     {
190 |      "data": {
191 |       "application/vnd.jupyter.widget-view+json": {
192 |        "model_id": "9aada26068ed46e0aa694576dd23b02d",
193 |        "version_major": 2,
194 |        "version_minor": 0
195 |       },
196 |       "text/plain": [
197 |        "HBox(children=(IntProgress(value=0, max=500), HTML(value='')))"
198 |       ]
199 |      },
200 |      "metadata": {},
201 |      "output_type": "display_data"
202 |     },
203 |     {
204 |      "name": "stdout",
205 |      "output_type": "stream",
206 |      "text": [
207 |       "\n"
208 |      ]
209 |     }
210 |    ],
211 |    "source": [
212 |     "max_iter=500\n",
213 |     "alpha=0.3\n",
214 |     "n_sample=X.shape[0]\n",
215 |     "train_index=np.random.choice(n_sample,N,replace=False)\n",
216 |     "test_index=np.setdiff1d(np.array(range(n_sample)),train_index)\n",
217 |     "X_train,Y_train=X[train_index],Y[train_index]\n",
218 |     "X_test,Y_test=X[test_index],Y[test_index]\n",
219 |     "for itr in tqdm(range(max_iter)):\n",
220 |     "    O=feedforward(X_train,W,b,O)\n",
221 |     "    W_grad,b_grad=backpropagation(X_train,Y_train,W,O,W_grad,b_grad)\n",
222 |     "    for i in range(len(W)):\n",
223 |     "        W[i]-=alpha*W_grad[i]\n",
224 |     "        b[i]-=alpha*b_grad[i]"
225 |    ]
226 |   },
227 |   {
228 |    "cell_type": "markdown",
229 |    "metadata": {},
230 |    "source": [
231 |     "# Result"
232 |    ]
233 |   },
234 |   {
235 |    "cell_type": "code",
236 |    "execution_count": 9,
237 |    "metadata": {},
238 |    "outputs": [
239 |     {
240 |      "name": "stdout",
241 |      "output_type": "stream",
242 |      "text": [
243 |       "the traning set error rate: 0.0 %\n",
244 |       "the testing set error rate: 5.58375634517766 %\n"
245 |      ]
246 |     }
247 |    ],
248 |    "source": [
249 |     "temp=X.copy()\n",
250 |     "for i in range(len(W)):\n",
251 |     "    if(i==4):\n",
252 |     "        temp=softmax(np.dot(temp,W[i]))\n",
253 |     "    else:\n",
254 |     "        temp=relu(np.dot(temp,W[i]))\n",
255 |     "print(\"the traning set error rate:\",\n",
256 |     "      (1-np.sum(np.argmax(temp[train_index],axis=1)==y[train_index])/N)*100,\"%\")\n",
257 |     "print(\"the testing set error rate:\",\n",
258 |     "      (1-np.sum(np.argmax(temp[test_index],axis=1)==y[test_index])/(n_sample-N))*100,\"%\")"
259 |    ]
260 |   },
261 |   {
262 |    "cell_type": "code",
263 |    "execution_count": null,
264 |    "metadata": {},
265 |    "outputs": [],
266 |    "source": []
267 |   }
268 |  ],
269 |  "metadata": {
270 |   "kernelspec": {
271 |    "display_name": "Python 3",
272 |    "language": "python",
273 |    "name": "python3"
274 |   },
275 |   "language_info": {
276 |    "codemirror_mode": {
277 |     "name": "ipython",
278 |     "version": 3
279 |    },
280 |    "file_extension": ".py",
281 |    "mimetype": "text/x-python",
282 |    "name": "python",
283 |    "nbconvert_exporter": "python",
284 |    "pygments_lexer": "ipython3",
285 |    "version": "3.7.4"
286 |   }
287 |  },
288 |  "nbformat": 4,
289 |  "nbformat_minor": 2
290 | }
291 | 


--------------------------------------------------------------------------------