{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#导入包\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练测试集分割\n",
    "def train_test_split(X, y, train_size=None ,seed=None):\n",
    "    \"\"\"将数据 X 和 y 按照test_ratio分割成X_train, X_test, y_train, y_test\"\"\"\n",
    "    assert X.shape[0] == y.shape[0], \\\n",
    "        \"the size of X must be equal to the size of y\"\n",
    "\n",
    "    if seed:\n",
    "        np.random.seed(seed)\n",
    "\n",
    "    shuffled_indexes = np.random.permutation(len(X))\n",
    "\n",
    "#     test_size = int(450)\n",
    "    test_indexes = shuffled_indexes[train_size:]\n",
    "    train_indexes = shuffled_indexes[:train_size]\n",
    "\n",
    "    X_train = X[train_indexes]\n",
    "    y_train = y[train_indexes]\n",
    "\n",
    "    X_test = X[test_indexes]\n",
    "    y_test = y[test_indexes]\n",
    "\n",
    "    return X_train, X_test, y_train, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 实现 LDA 算法\n",
    "\n",
    "class LinearDiscrtAnays(object):\n",
    "    def __init__(self):\n",
    "        self.Xi_means = 0               #每个类别的均值向量\n",
    "        self.Xbar = 0                   #整体的均值向量\n",
    "        self.covMatrix = []             #每个类别的协方差矩阵\n",
    "        self.covariance_ = 0            #整体的协方差矩阵\n",
    "        self.X = 0                      #训练数据\n",
    "        self.y = 0                      #训练数据的分类标签\n",
    "        self.classes_ = 0               #具体类别\n",
    "        self.priors_ = 0                #每个类别的先验概率\n",
    "        self.n_samples = 0              #训练数据的样本数\n",
    "        self.n_features = 0             #训练数据的特征数\n",
    "        self.n_components = 0           #特征数\n",
    "        self.w = 0                      #特征向量\n",
    "    \n",
    "    #初始化特征    \n",
    "    \"\"\"calculate params, including:\n",
    "        0. X, y\n",
    "        1. n_samples, n_features;\n",
    "        2. classer, priors_;\n",
    "        3. Xi_means, Xbar, covMatrix;\n",
    "    \n",
    "    \"\"\"\n",
    "    def _params_init(self, X, y):\n",
    "        #0、赋值X和y\n",
    "        self.X, self.y = X, y\n",
    "        #1、计算样本数量和特征数量\n",
    "        self.n_samples, self.n_features = X.shape\n",
    "        #2、计算类别值、每个类别的先验概率\n",
    "        self.classes_, yidx = np.unique(y, return_inverse=True)\n",
    "        self.priors_ = np.bincount(y) / self.n_samples\n",
    "        #3、计算每类的均值\n",
    "        means = np.zeros((len(self.classes_), self.n_features))\n",
    "        np.add.at(means, yidx, X)\n",
    "        self.Xi_means = means / np.expand_dims(np.bincount(y), 1)\n",
    "        #4、计算每类的协方差矩阵、整体的协方差矩阵\n",
    "        self.covMatrix = [np.cov(X[y == group].T) \\\n",
    "                          for idx, group in enumerate(self.classes_)]\n",
    "        self.covariance_ = sum(self.covMatrix) / len(self.covMatrix)\n",
    "        #5、计算总体均值向量\n",
    "        self.Xbar = np.dot(np.expand_dims(self.priors_, axis=0), self.Xi_means)\n",
    "        return \n",
    "    \n",
    "    #训练\n",
    "    def train(self, X, y, n_components=None):\n",
    "        #初始化一些参数\n",
    "        self._params_init(X, y)\n",
    "        #求类内平均散度\n",
    "        Sw = self.covariance_\n",
    "        #求类间平均散度\n",
    "        Sb = sum([sum(y == group)*np.dot((self.Xi_means[idx,None] - self.Xbar).T, (self.Xi_means[idx,None] - self.Xbar)) \\\n",
    "                  for idx, group in enumerate(self.classes_)]) / (self.n_samples - 1)\n",
    "        #SVD求Sw的逆矩阵\n",
    "        U,S,V = np.linalg.svd(Sw)\n",
    "        Sn = np.linalg.inv(np.diag(S))\n",
    "        Swn = np.dot(np.dot(V.T,Sn),U.T)\n",
    "        SwnSb = np.dot(Swn,Sb)\n",
    "        #求特征值和特征向量，并取实数部分\n",
    "        la,vectors = np.linalg.eig(SwnSb)\n",
    "        la = np.real(la)\n",
    "        vectors = np.real(vectors)\n",
    "        #特征值的下标从大到小排列\n",
    "        laIdx = np.argsort(-la)\n",
    "        #默认选取(N-1)个特征值的下标\n",
    "        if n_components == None:\n",
    "            n_components = len(self.classes_)-1\n",
    "        #选取特征值和向量\n",
    "        lambda_index = laIdx[:n_components]\n",
    "        w = vectors[:,lambda_index]\n",
    "        self.w = w\n",
    "        self.n_components = n_components\n",
    "        return\n",
    "    \n",
    "    #求出投影后的矩阵\n",
    "    def transform(self, X):\n",
    "        return np.dot(X, self.w)\n",
    "    \n",
    "    #预测分类情况，出分类概率\n",
    "    def predict_prob(self, X):\n",
    "        #求整体协方差的逆\n",
    "        Sigma = self.covariance_\n",
    "        U,S,V = np.linalg.svd(Sigma)\n",
    "        Sn = np.linalg.inv(np.diag(S))\n",
    "        Sigman = np.dot(np.dot(V.T,Sn),U.T)\n",
    "        #线性判别函数值\n",
    "        value = np.log(np.expand_dims(self.priors_, axis=0)) - \\\n",
    "        0.5*np.multiply(np.dot(self.Xi_means, Sigman).T, self.Xi_means.T).sum(axis=0).reshape(1,-1) + \\\n",
    "        np.dot(np.dot(X, Sigman), self.Xi_means.T)\n",
    "        return value/np.expand_dims(value.sum(axis=1),1)\n",
    "    \n",
    "    #预测分类情况，出具体分类值\n",
    "    def predict(self, X):\n",
    "        pValue = self.predict_prob(X)\n",
    "        return np.argmax(pValue, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   R   F      M   T  A\n",
      "0  2  50  12500  98  1\n",
      "1  0  13   3250  28  1\n",
      "2  1  16   4000  35  1\n",
      "3  2  20   5000  45  1\n",
      "4  1  24   6000  77  0\n",
      "(748, 5)\n"
     ]
    }
   ],
   "source": [
    "#导入数据并给每一维属性命名\n",
    "df = pd.read_csv(\"./blood_data.txt\",sep=',',encoding='utf-8',header=None,)\n",
    "df.columns = ['R','F','M','T','A']\n",
    "print(df.head())\n",
    "print(df.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(748, 4)\n",
      "(748,)\n",
      "训练数据集 (598, 4) (598,)\n",
      "测试数据集 (150, 4) (150,)\n"
     ]
    }
   ],
   "source": [
    "cols=['R','F','M','T']\n",
    "x = df[cols].values\n",
    "y = df['A'].values\n",
    "print(x.shape)\n",
    "print(y.shape)\n",
    "\n",
    "#8:2 训练:测试\n",
    "x_train,x_test,y_train,y_test = train_test_split(x,y, train_size=int(748*0.8),seed=1)\n",
    "\n",
    "# from LinearRegression import LinearRegression\n",
    "\n",
    "print(\"训练数据集\",x_train.shape,y_train.shape)\n",
    "print(\"测试数据集\",x_test.shape,y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "lda= LinearDiscrtAnays()\n",
    "lda.train(x_train,y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0 1 1 1 0 1 0 0 0 0 1 0 0 1 1 0 0 1 0 0 0 0 0 1 1 0 1 1 0 0 1 0 0 0 0\n",
      " 0 0 0 1 0 0 1 0 0 0 0 1 0 0 1 1 1 1 0 1 0 0 0 0 0 0 0 1 0 0 1 1 0 1 0 0 0\n",
      " 0 0 1 1 0 1 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 1 0 1 1 1 0 1 0 0 0 0 1 0 0 0\n",
      " 0 1 1 0 1 0 1 1 1 0 1 0 0 1 0 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0\n",
      " 0 1]\n",
      "[0 0 0 1 0 1 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 1 0 0 1 0 0 0 0 1 1 1 0 0 0 1 0 1 0 0 1 0\n",
      " 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 1 0 0 0 1 1 0 1 0 1 1 0 0 1\n",
      " 0 1]\n",
      "lda‘s accurancy is 0.620\n"
     ]
    }
   ],
   "source": [
    "#分类情况\n",
    "pre_y = lda.predict(x_test)\n",
    "print(pre_y)\n",
    "print(y_test)\n",
    "print(\"lda‘s accurancy is %.3f\"%(sum(pre_y==y_test)/pre_y.shape[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 降维后的数据集画图\n",
    "X_self = lda.transform(x_test)\n",
    "# 自编码的LDA降维后数据\n",
    "fig = plt.figure(figsize=(12,12)) \n",
    "ax1 = fig.add_subplot(1,1,1)\n",
    "ax1.scatter(X_self[pre_y==0],X_self[pre_y==0],c='r',marker='+')\n",
    "ax1.scatter(X_self[pre_y==1],X_self[pre_y==1],c='b',marker='o')\n",
    "ax1.set_title(\"LDA\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lda_sklearn‘s accurancy is 0.633\n"
     ]
    }
   ],
   "source": [
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n",
    "lda_sklearn = LDA(solver=\"eigen\", n_components=2)\n",
    "lda_sklearn.fit(x_train, y_train)\n",
    "pre_sklearn = lda_sklearn.predict(x_test)\n",
    "print(\"lda_sklearn‘s accurancy is %.3f\"%(sum(pre_sklearn==y_test)/pre_sklearn.shape[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_sklearn = lda_sklearn.transform(x_test)\n",
    "fig = plt.figure(figsize=(12,12)) \n",
    "ax2 = fig.add_subplot(1,1,1)    \n",
    "ax2.scatter(X_sklearn[pre_sklearn==0],X_sklearn[pre_sklearn==0],c='r',marker='+')\n",
    "ax2.scatter(X_sklearn[pre_sklearn==1],X_sklearn[pre_sklearn==1],c='b',marker='o')\n",
    "ax2.set_title(\"LDA_sklearn\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}