├── .gitignore ├── 0-BasicConcept └── note │ ├── chapter09.ipynb │ ├── chapter10.ipynb │ ├── chapter11.ipynb │ ├── probability_theory.ipynb │ ├── sn07.ipynb │ └── sn08.ipynb ├── 1-LinearRegression ├── AndrewNg_MechineLearning │ ├── ex1.pdf │ ├── ex1data1.txt │ ├── ex1data2.txt │ └── linear_regression.ipynb ├── LinearRegression.ipynb ├── LinearRegression_sklearn.ipynb ├── NOTE-linear_regression.ipynb ├── linear_regression_mxnet.ipynb └── note │ ├── LSJU-chapter03_01.ipynb │ ├── LSJU_chapter02.ipynb │ ├── LSJU_chapter04.ipynb │ └── NOTE-linear_regression.ipynb ├── 2-LogisticRegression ├── AndrewNg-MechineLearning │ ├── ex2.pdf │ ├── ex2data1.txt │ ├── ex2data2.txt │ ├── logical_regression.py │ └── logistic_regression.ipynb ├── LogisticRegression.ipynb ├── LogisticRegression_OneVsAll.ipynb ├── LogisticRegression_OneVsAll_scikit-learn.ipynb ├── LogisticRegression_scikit-learn.ipynb ├── note │ ├── LSJU-chapter03_2.ipynb │ └── NOTE-logistic_regression.ipynb └── predict.csv ├── 3-NeuralNetwok ├── AndrewNg_MechineLearning │ ├── ex3.pdf │ ├── ex3data1.mat │ ├── ex3weights.mat │ └── neural_network.ipynb ├── NeuralNetwork.ipynb ├── note │ └── NOTE-neural_network.md └── predict.csv ├── 4-SVM ├── AndrewNg_MechineLearning │ ├── data │ │ ├── emailSample1.txt │ │ ├── emailSample2.txt │ │ ├── ex6data1.mat │ │ ├── ex6data2.mat │ │ ├── ex6data3.mat │ │ ├── spamSample1.txt │ │ ├── spamSample2.txt │ │ ├── spamTest.mat │ │ ├── spamTrain.mat │ │ └── vocab.txt │ ├── ex6.pdf │ └── linear SVM.ipynb ├── SVM_scikit-learn.ipynb └── note │ ├── LSJU-SVM-01.ipynb │ ├── LSJU-SVM-02.ipynb │ ├── LSJU-SVM-03.ipynb │ └── NOTE-SVM.md ├── 5-K-Means ├── K-Means-sklearn.ipynb ├── K-Means.ipynb └── note │ ├── LSJU-chapter12.ipynb │ ├── LSJU-chapter13.ipynb │ ├── LSJU-chapter14.ipynb │ └── NOTE-K-Means.md ├── 6-PCA ├── NOTE-PCA.md ├── PCA.ipynb ├── PCA_sklearn.ipynb └── note │ └── LSJU----NOTE-PCA.ipynb ├── 7-AnomalyDetection ├── AnomalyDetection.ipynb └── note │ └── NOTE-anomaly_detection.md ├── 8-HMM ├── NOTE_HMM.ipynb └── note │ ├── LSJU-HMM.ipynb │ ├── LSJU-chapter17.ipynb │ ├── LSJU-chapter18.ipynb │ └── sn06.ipynb ├── 9-NaiveBayer └── note │ ├── LSJU-NaiveBayer-02.ipynb │ └── LSJU-chapter05.ipynb ├── LICENSE ├── code ├── 1-LinearRegression │ ├── LinearRegression.py │ └── LinearRegression_scikit-learn.py ├── 2-LogisticRegression │ ├── LogisticRegression.py │ ├── LogisticRegression_OneVsAll.py │ ├── LogisticRegression_OneVsAll_scikit-learn.py │ ├── LogisticRegression_scikit-learn.py │ └── predict.csv ├── 3-NeuralNetwok │ ├── NeuralNetwork.py │ └── predict.csv ├── 4-SVM │ └── SVM_scikit-learn.py ├── 5-K-Means │ ├── K-Means.py │ └── K-Means_scikit-learn.py ├── 6-PCA │ ├── PCA.py │ └── PCA_scikit-learn.py └── 7-AnomalyDetection │ └── AnomalyDetection.py ├── data ├── 1-linear_regression │ ├── data.csv │ ├── data.npy │ └── data.txt ├── 2-logistic_regression │ ├── class_y.csv │ ├── data1.npy │ ├── data1.txt │ ├── data2.txt │ └── data_digits.mat ├── 3-neural_network │ └── data_digits.mat ├── 4-SVM │ ├── data.txt │ ├── data1.mat │ ├── data2.mat │ └── data3.mat ├── 5-K-Means │ ├── bird.mat │ ├── bird.png │ └── data.mat ├── 6-PCA │ ├── data.mat │ └── data_faces.mat └── 7-anomaly_detection │ ├── data1.mat │ └── data2.mat ├── formula ├── AnomalyDetection.wmf ├── K-Means.wmf ├── LinearRegression_01.wmf ├── LogisticRegression_01.wmf ├── NeuralNetwork.wmf ├── PCA.wmf └── SVM.wmf ├── images ├── AnomalyDetection_01.png ├── AnomalyDetection_02.png ├── AnomalyDetection_03.png ├── AnomalyDetection_04.png ├── AnomalyDetection_05.png ├── AnomalyDetection_06.png ├── AnomalyDetection_07.png ├── AnomalyDetection_08.png ├── AnomalyDetection_09.png ├── AnomalyDetection_10.png ├── K-Means_01.png ├── K-Means_02.png ├── K-Means_03.png ├── K-Means_04.png ├── K-Means_05.png ├── K-Means_06.png ├── K-Means_07.png ├── LinearRegression_01.png ├── LogisticRegression_01.png ├── LogisticRegression_02.png ├── LogisticRegression_03.jpg ├── LogisticRegression_04.png ├── LogisticRegression_05.png ├── LogisticRegression_06.png ├── LogisticRegression_07.png ├── LogisticRegression_08.png ├── LogisticRegression_09.png ├── LogisticRegression_10.png ├── LogisticRegression_11.png ├── LogisticRegression_12.png ├── LogisticRegression_13.png ├── NeuralNetwork_01.png ├── NeuralNetwork_02.png ├── NeuralNetwork_03.jpg ├── NeuralNetwork_04.png ├── NeuralNetwork_05.png ├── NeuralNetwork_06.png ├── NeuralNetwork_07.png ├── NeuralNetwork_08.png ├── NeuralNetwork_09.png ├── PCA_01.png ├── PCA_02.png ├── PCA_03.png ├── PCA_04.png ├── PCA_05.png ├── PCA_06.png ├── PCA_07.png ├── PCA_08.png ├── SVM_01.png ├── SVM_02.png ├── SVM_03.png ├── SVM_04.png ├── SVM_05.png ├── SVM_06.png ├── SVM_07.png ├── SVM_08.png ├── SVM_09.png ├── SVM_10.png └── nn_model.png ├── other └── note │ ├── LSJU-chapter06-01.ipynb │ ├── LSJU-chapter19.ipynb │ └── LSJU-chapter20.ipynb ├── readme.ipynb └── readme.md /.gitignore: -------------------------------------------------------------------------------- 1 | # IntelliJ IDEA Project files 2 | .idea 3 | *.iml 4 | *.ipr 5 | *.iws 6 | *.xml 7 | out 8 | 9 | # Prerequisites 10 | *.d 11 | 12 | # Compiled Object files 13 | *.slo 14 | *.lo 15 | *.o 16 | *.obj 17 | .ipynb_checkpoints 18 | */.ipynb_checkpoints 19 | */**/.ipynb_checkpoints 20 | 21 | # Compiled Dynamic libraries 22 | *.so 23 | *.dylib 24 | *.dll 25 | 26 | 27 | # Compiled Static libraries 28 | */*.pyc 29 | */**/*.pyc 30 | */**/**/*.pyc 31 | */**/**/**/*.pyc 32 | */**/**/**/**/*.pyc 33 | 34 | # Executables 35 | *.exe 36 | *.out 37 | *.app 38 | 39 | 40 | -------------------------------------------------------------------------------- /1-LinearRegression/AndrewNg_MechineLearning/ex1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/1-LinearRegression/AndrewNg_MechineLearning/ex1.pdf -------------------------------------------------------------------------------- /1-LinearRegression/AndrewNg_MechineLearning/ex1data1.txt: -------------------------------------------------------------------------------- 1 | 6.1101,17.592 2 | 5.5277,9.1302 3 | 8.5186,13.662 4 | 7.0032,11.854 5 | 5.8598,6.8233 6 | 8.3829,11.886 7 | 7.4764,4.3483 8 | 8.5781,12 9 | 6.4862,6.5987 10 | 5.0546,3.8166 11 | 5.7107,3.2522 12 | 14.164,15.505 13 | 5.734,3.1551 14 | 8.4084,7.2258 15 | 5.6407,0.71618 16 | 5.3794,3.5129 17 | 6.3654,5.3048 18 | 5.1301,0.56077 19 | 6.4296,3.6518 20 | 7.0708,5.3893 21 | 6.1891,3.1386 22 | 20.27,21.767 23 | 5.4901,4.263 24 | 6.3261,5.1875 25 | 5.5649,3.0825 26 | 18.945,22.638 27 | 12.828,13.501 28 | 10.957,7.0467 29 | 13.176,14.692 30 | 22.203,24.147 31 | 5.2524,-1.22 32 | 6.5894,5.9966 33 | 9.2482,12.134 34 | 5.8918,1.8495 35 | 8.2111,6.5426 36 | 7.9334,4.5623 37 | 8.0959,4.1164 38 | 5.6063,3.3928 39 | 12.836,10.117 40 | 6.3534,5.4974 41 | 5.4069,0.55657 42 | 6.8825,3.9115 43 | 11.708,5.3854 44 | 5.7737,2.4406 45 | 7.8247,6.7318 46 | 7.0931,1.0463 47 | 5.0702,5.1337 48 | 5.8014,1.844 49 | 11.7,8.0043 50 | 5.5416,1.0179 51 | 7.5402,6.7504 52 | 5.3077,1.8396 53 | 7.4239,4.2885 54 | 7.6031,4.9981 55 | 6.3328,1.4233 56 | 6.3589,-1.4211 57 | 6.2742,2.4756 58 | 5.6397,4.6042 59 | 9.3102,3.9624 60 | 9.4536,5.4141 61 | 8.8254,5.1694 62 | 5.1793,-0.74279 63 | 21.279,17.929 64 | 14.908,12.054 65 | 18.959,17.054 66 | 7.2182,4.8852 67 | 8.2951,5.7442 68 | 10.236,7.7754 69 | 5.4994,1.0173 70 | 20.341,20.992 71 | 10.136,6.6799 72 | 7.3345,4.0259 73 | 6.0062,1.2784 74 | 7.2259,3.3411 75 | 5.0269,-2.6807 76 | 6.5479,0.29678 77 | 7.5386,3.8845 78 | 5.0365,5.7014 79 | 10.274,6.7526 80 | 5.1077,2.0576 81 | 5.7292,0.47953 82 | 5.1884,0.20421 83 | 6.3557,0.67861 84 | 9.7687,7.5435 85 | 6.5159,5.3436 86 | 8.5172,4.2415 87 | 9.1802,6.7981 88 | 6.002,0.92695 89 | 5.5204,0.152 90 | 5.0594,2.8214 91 | 5.7077,1.8451 92 | 7.6366,4.2959 93 | 5.8707,7.2029 94 | 5.3054,1.9869 95 | 8.2934,0.14454 96 | 13.394,9.0551 97 | 5.4369,0.61705 98 | -------------------------------------------------------------------------------- /1-LinearRegression/AndrewNg_MechineLearning/ex1data2.txt: -------------------------------------------------------------------------------- 1 | 2104,3,399900 2 | 1600,3,329900 3 | 2400,3,369000 4 | 1416,2,232000 5 | 3000,4,539900 6 | 1985,4,299900 7 | 1534,3,314900 8 | 1427,3,198999 9 | 1380,3,212000 10 | 1494,3,242500 11 | 1940,4,239999 12 | 2000,3,347000 13 | 1890,3,329999 14 | 4478,5,699900 15 | 1268,3,259900 16 | 2300,4,449900 17 | 1320,2,299900 18 | 1236,3,199900 19 | 2609,4,499998 20 | 3031,4,599000 21 | 1767,3,252900 22 | 1888,2,255000 23 | 1604,3,242900 24 | 1962,4,259900 25 | 3890,3,573900 26 | 1100,3,249900 27 | 1458,3,464500 28 | 2526,3,469000 29 | 2200,3,475000 30 | 2637,3,299900 31 | 1839,2,349900 32 | 1000,1,169900 33 | 2040,4,314900 34 | 3137,3,579900 35 | 1811,4,285900 36 | 1437,3,249900 37 | 1239,3,229900 38 | 2132,4,345000 39 | 4215,4,549000 40 | 2162,4,287000 41 | 1664,2,368500 42 | 2238,3,329900 43 | 2567,4,314000 44 | 1200,3,299000 45 | 852,2,179900 46 | 1852,4,299900 47 | 1203,3,239500 48 | -------------------------------------------------------------------------------- /1-LinearRegression/LinearRegression_sklearn.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## 使用sklearn 模块 " 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": { 14 | "collapsed": true 15 | }, 16 | "outputs": [], 17 | "source": [ 18 | "#-*- coding: utf-8 -*-\n", 19 | "import numpy as np\n", 20 | "from sklearn import linear_model\n", 21 | "from matplotlib import pyplot as plt\n", 22 | "from sklearn.preprocessing import StandardScaler #引入归一化的包\n", 23 | "% matplotlib inline" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 2, 29 | "metadata": {}, 30 | "outputs": [ 31 | { 32 | "name": "stdout", 33 | "output_type": "stream", 34 | "text": [ 35 | "加载数据...\n", 36 | "\n" 37 | ] 38 | }, 39 | { 40 | "data": { 41 | "text/plain": [ 42 | "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)" 43 | ] 44 | }, 45 | "execution_count": 2, 46 | "metadata": {}, 47 | "output_type": "execute_result" 48 | }, 49 | { 50 | "data": { 51 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n", 52 | "text/plain": [ 53 | "" 54 | ] 55 | }, 56 | "metadata": {}, 57 | "output_type": "display_data" 58 | } 59 | ], 60 | "source": [ 61 | "print u\"加载数据...\\n\"\n", 62 | "data = np.loadtxt(\"../data/1-linear_regression/data.txt\",delimiter=\",\",dtype=np.float64) #读取数据\n", 63 | "X = np.array(data[:,0:-1],dtype=np.float64) # X对应0到倒数第2列 \n", 64 | "y = np.array(data[:,-1],dtype=np.float64) # y对应最后一列 \n", 65 | "\n", 66 | "plt.scatter(X[:,0],X[:,1])\n", 67 | "\n", 68 | "# 归一化操作\n", 69 | "scaler = StandardScaler() \n", 70 | "scaler.fit(X)\n", 71 | "\n", 72 | "\n", 73 | "x_train = scaler.transform(X)\n", 74 | "x_test = scaler.transform(np.array([1650.0,3.0]).reshape(1,-1))\n", 75 | "\n", 76 | "# 线性模型拟合\n", 77 | "model = linear_model.LinearRegression()\n", 78 | "model.fit(x_train, y)" 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": {}, 84 | "source": [ 85 | "### 预测结果" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 3, 91 | "metadata": {}, 92 | "outputs": [ 93 | { 94 | "name": "stdout", 95 | "output_type": "stream", 96 | "text": [ 97 | "[ 109447.79646964 -6578.35485416]\n", 98 | "340412.659574\n", 99 | "[ 293081.4643349]\n" 100 | ] 101 | } 102 | ], 103 | "source": [ 104 | "#预测结果\n", 105 | "result = model.predict(x_test)\n", 106 | "print model.coef_ # Coefficient of the features 决策函数中的特征系数\n", 107 | "print model.intercept_ # 又名bias偏置,若设置为False，则为0\n", 108 | "print result # 预测结果" 109 | ] 110 | } 111 | ], 112 | "metadata": { 113 | "kernelspec": { 114 | "display_name": "Python 2", 115 | "language": "python", 116 | "name": "python2" 117 | }, 118 | "language_info": { 119 | "codemirror_mode": { 120 | "name": "ipython", 121 | "version": 2 122 | }, 123 | "file_extension": ".py", 124 | "mimetype": "text/x-python", 125 | "name": "python", 126 | "nbconvert_exporter": "python", 127 | "pygments_lexer": "ipython2", 128 | "version": "2.7.13" 129 | } 130 | }, 131 | "nbformat": 4, 132 | "nbformat_minor": 2 133 | } 134 | -------------------------------------------------------------------------------- /1-LinearRegression/NOTE-linear_regression.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## 一、[线性回归](code/1-LinearRegression)\n", 8 | "- [全部代码](../code/1-LinearRegression/LinearRegression.py)\n", 9 | "\n", 10 | "### 1、代价函数\n", 11 | "- ![J(\\theta ) = \\frac{1}{{2{\\text{m}}}}\\sum\\limits_{i = 1}^m {{{({h_\\theta }({x^{(i)}}) - {y^{(i)}})}^2}} ](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=J%28%5Ctheta%20%29%20%3D%20%5Cfrac%7B1%7D%7B%7B2%7B%5Ctext%7Bm%7D%7D%7D%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%7B%7B%28%7Bh_%5Ctheta%20%7D%28%7Bx%5E%7B%28i%29%7D%7D%29%20-%20%7By%5E%7B%28i%29%7D%7D%29%7D%5E2%7D%7D%20)\n", 12 | "- 其中：\n", 13 | "![{h_\\theta }(x) = {\\theta _0} + {\\theta _1}{x_1} + {\\theta _2}{x_2} + ...](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7Bh_%5Ctheta%20%7D%28x%29%20%3D%20%7B%5Ctheta%20_0%7D%20%2B%20%7B%5Ctheta%20_1%7D%7Bx_1%7D%20%2B%20%7B%5Ctheta%20_2%7D%7Bx_2%7D%20%2B%20...)\n", 14 | "\n", 15 | "- 下面就是要求出theta，使代价最小，即代表我们拟合出来的方程距离真实值最近\n", 16 | "- 共有m条数据，其中![{{{({h_\\theta }({x^{(i)}}) - {y^{(i)}})}^2}}](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7B%7B%7B%28%7Bh_%5Ctheta%20%7D%28%7Bx%5E%7B%28i%29%7D%7D%29%20-%20%7By%5E%7B%28i%29%7D%7D%29%7D%5E2%7D%7D)代表我们要拟合出来的方程到真实值距离的平方，平方的原因是因为可能有负值，正负可能会抵消\n", 17 | "- 前面有系数`2`的原因是下面求梯度是对每个变量求偏导，`2`可以消去\n", 18 | "\n", 19 | "- 实现代码：" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": null, 25 | "metadata": { 26 | "collapsed": true 27 | }, 28 | "outputs": [], 29 | "source": [ 30 | "# 计算代价函数\n", 31 | "def computerCost(X,y,theta):\n", 32 | " m = len(y)\n", 33 | " J = 0\n", 34 | " \n", 35 | " J = (np.transpose(X*theta-y))*(X*theta-y)/(2*m) #计算代价J\n", 36 | " return J" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "- 注意这里的X是真实数据前加了一列1，因为有theta(0)\n", 44 | "\n", 45 | "### 2、梯度下降算法\n", 46 | "- 代价函数对![{{\\theta _j}}](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7B%7B%5Ctheta%20_j%7D%7D)求偏导得到： \n", 47 | "![\\frac{{\\partial J(\\theta )}}{{\\partial {\\theta _j}}} = \\frac{1}{m}\\sum\\limits_{i = 1}^m {[({h_\\theta }({x^{(i)}}) - {y^{(i)}})x_j^{(i)}]} ](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%5Cfrac%7B%7B%5Cpartial%20J%28%5Ctheta%20%29%7D%7D%7B%7B%5Cpartial%20%7B%5Ctheta%20_j%7D%7D%7D%20%3D%20%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%5B%28%7Bh_%5Ctheta%20%7D%28%7Bx%5E%7B%28i%29%7D%7D%29%20-%20%7By%5E%7B%28i%29%7D%7D%29x_j%5E%7B%28i%29%7D%5D%7D%20)\n", 48 | "- 所以对theta的更新可以写为： \n", 49 | "![{\\theta _j} = {\\theta _j} - \\alpha \\frac{1}{m}\\sum\\limits_{i = 1}^m {[({h_\\theta }({x^{(i)}}) - {y^{(i)}})x_j^{(i)}]} ](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7B%5Ctheta%20_j%7D%20%3D%20%7B%5Ctheta%20_j%7D%20-%20%5Calpha%20%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%5B%28%7Bh_%5Ctheta%20%7D%28%7Bx%5E%7B%28i%29%7D%7D%29%20-%20%7By%5E%7B%28i%29%7D%7D%29x_j%5E%7B%28i%29%7D%5D%7D%20)\n", 50 | "- 其中![\\alpha ](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%5Calpha%20)为学习速率，控制梯度下降的速度，一般取**0.01,0.03,0.1,0.3.....**\n", 51 | "- 为什么梯度下降可以逐步减小代价函数\n", 52 | " - 假设函数`f(x)`\n", 53 | " - 泰勒展开：`f(x+△x)=f(x)+f'(x)*△x+o(△x)`\n", 54 | " - 令：`△x=-α*f'(x)` ,即负梯度方向乘以一个很小的步长`α`\n", 55 | " - 将`△x`代入泰勒展开式中：`f(x+x)=f(x)-α*[f'(x)]²+o(△x)`\n", 56 | " - 可以看出，`α`是取得很小的正数，`[f'(x)]²`也是正数，所以可以得出：`f(x+△x)<=f(x)`\n", 57 | " - 所以沿着**负梯度**放下，函数在减小，多维情况一样。\n", 58 | "- 实现代码" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": { 65 | "collapsed": true 66 | }, 67 | "outputs": [], 68 | "source": [ 69 | "# 梯度下降算法\n", 70 | "def gradientDescent(X,y,theta,alpha,num_iters):\n", 71 | " m = len(y) \n", 72 | " n = len(theta)\n", 73 | " \n", 74 | " temp = np.matrix(np.zeros((n,num_iters))) # 暂存每次迭代计算的theta，转化为矩阵形式\n", 75 | " \n", 76 | " \n", 77 | " J_history = np.zeros((num_iters,1)) #记录每次迭代计算的代价值\n", 78 | " \n", 79 | " for i in range(num_iters): # 遍历迭代次数 \n", 80 | " h = np.dot(X,theta) # 计算内积，matrix可以直接乘\n", 81 | " temp[:,i] = theta - ((alpha/m)*(np.dot(np.transpose(X),h-y))) #梯度的计算\n", 82 | " theta = temp[:,i]\n", 83 | " J_history[i] = computerCost(X,y,theta) #调用计算代价函数\n", 84 | " print '.', \n", 85 | " return theta,J_history " 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "### 3、均值归一化\n", 93 | "- 目的是使数据都缩放到一个范围内，便于使用梯度下降算法\n", 94 | "- ![{x_i} = \\frac{{{x_i} - {\\mu _i}}}{{{s_i}}}](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7Bx_i%7D%20%3D%20%5Cfrac%7B%7B%7Bx_i%7D%20-%20%7B%5Cmu%20_i%7D%7D%7D%7B%7B%7Bs_i%7D%7D%7D)\n", 95 | "- 其中 ![{{\\mu _i}}](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7B%7B%5Cmu%20_i%7D%7D) 为所有此feture数据的平均值\n", 96 | "- ![{{s_i}}](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7B%7Bs_i%7D%7D)可以是**最大值-最小值**，也可以是这个feature对应的数据的**标准差**\n", 97 | "- 实现代码：" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "metadata": { 104 | "collapsed": true 105 | }, 106 | "outputs": [], 107 | "source": [ 108 | "# 归一化feature\n", 109 | "def featureNormaliza(X):\n", 110 | " X_norm = np.array(X) #将X转化为numpy数组对象，才可以进行矩阵的运算\n", 111 | " #定义所需变量\n", 112 | " mu = np.zeros((1,X.shape[1])) \n", 113 | " sigma = np.zeros((1,X.shape[1]))\n", 114 | " \n", 115 | " mu = np.mean(X_norm,0) # 求每一列的平均值（0指定为列，1代表行）\n", 116 | " sigma = np.std(X_norm,0) # 求每一列的标准差\n", 117 | " for i in range(X.shape[1]): # 遍历列\n", 118 | " X_norm[:,i] = (X_norm[:,i]-mu[i])/sigma[i] # 归一化\n", 119 | " \n", 120 | " return X_norm,mu,sigma" 121 | ] 122 | }, 123 | { 124 | "cell_type": "markdown", 125 | "metadata": {}, 126 | "source": [ 127 | "- 注意预测的时候也需要均值归一化数据\n", 128 | "\n", 129 | "### 4、最终运行结果\n", 130 | "- 代价随迭代次数的变化 \n", 131 | "![enter description here](../images/LinearRegression_01.png)\n", 132 | "\n", 133 | "\n", 134 | "### 5、使用scikit-learn库中的线性模型实现\n", 135 | "- [全部代码](../code/1-LinearRegression/LinearRegression_scikit-learn.py)\n", 136 | "- 导入包" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": { 143 | "collapsed": true 144 | }, 145 | "outputs": [], 146 | "source": [ 147 | "from sklearn import linear_model\n", 148 | "from sklearn.preprocessing import StandardScaler #引入缩放的包" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "- 归一化" 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": null, 161 | "metadata": { 162 | "collapsed": true 163 | }, 164 | "outputs": [], 165 | "source": [ 166 | " # 归一化操作\n", 167 | "scaler = StandardScaler() \n", 168 | "scaler.fit(X)\n", 169 | "x_train = scaler.transform(X)\n", 170 | "x_test = scaler.transform(np.array([1650,3]))" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "- 线性模型拟合" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": null, 183 | "metadata": { 184 | "collapsed": true 185 | }, 186 | "outputs": [], 187 | "source": [ 188 | "# 线性模型拟合\n", 189 | "model = linear_model.LinearRegression()\n", 190 | "model.fit(x_train, y)" 191 | ] 192 | } 193 | ], 194 | "metadata": { 195 | "kernelspec": { 196 | "display_name": "Python 2", 197 | "language": "python", 198 | "name": "python2" 199 | }, 200 | "language_info": { 201 | "codemirror_mode": { 202 | "name": "ipython", 203 | "version": 2 204 | }, 205 | "file_extension": ".py", 206 | "mimetype": "text/x-python", 207 | "name": "python", 208 | "nbconvert_exporter": "python", 209 | "pygments_lexer": "ipython2", 210 | "version": "2.7.13" 211 | } 212 | }, 213 | "nbformat": 4, 214 | "nbformat_minor": 2 215 | } 216 | -------------------------------------------------------------------------------- /1-LinearRegression/note/LSJU-chapter03_01.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 第三讲：线性回归的概率解释、局部加权回归、逻辑回归\n", 8 | "\n", 9 | "我们先来回顾一下上一讲中的内容。\n", 10 | "\n", 11 | "* 我们用$\\left(x^{(i)},\\ y^{(i)}\\right)$表示训练集中的第$i$个样本；\n", 12 | "* 用向量$\\vec\\theta=(\\theta_0,\\ \\cdots,\\ \\theta_n)$表示特征值的系数向量；\n", 13 | "* 接着用$h_\\theta\\left(x^{(i)}\\right)$表示用于拟合训练集中样本的假设函数（假设函数基于参数$\\vec\\theta$），并定义$h_\\theta\\left(x^{(i)}\\right)=\\displaystyle\\sum_{j=0}^n\\theta_jx_j^{(i)}=\\theta^Tx$，$j$表示训练集中各样本的特征值$(x_1,\\ \\cdots,\\ x_n)$的序号，共有$n$个特征值，而$x_0=1$，此为常数项$\\theta_0$（即截距项）；\n", 14 | "* 最后定义了成本函数$J(\\theta)=\\frac{1}{2}\\left(\\displaystyle\\sum_{i=1}^mh_\\theta\\left(x^{(i)}\\right)-y^{(i)}\\right)^2$，其中$m$表示训练集中共有$m$个训练样本，其形式化描述为$\\theta=\\left(X^TX\\right)^{-1}X^Ty$。\n", 15 | "\n", 16 | "下面我们将接着上一讲的内容，从概率解释的角度介绍最小二乘的合理性。\n", 17 | "\n", 18 | "## 3. 线性模型的概率解释\n", 19 | "\n", 20 | "当我们遇到一个回归问题时，可能会有疑问，为什么使用线性回归？更具体的可能会问，为什么使用最小二乘成本函数$J$？这样合理吗？有那么多别的指标，比如预测值与实际值之差的绝对值、四次方等，为什么偏偏选择差的平方作为优化指标？在这一节我们将从一系列基于概率的假设中推出最小二乘回归的合理性。\n", 21 | "\n", 22 | "仍旧使用“公寓租金”例子，我们假设价格是一些特征的线性函数加上$\\epsilon^{(i)}$，于是有下面的式子将目标值与输入向量联系起来：\n", 23 | "\n", 24 | "$$y^{(i)}=\\theta^Tx^{(i)}+\\epsilon^{(i)}$$\n", 25 | "\n", 26 | "式中的$\\epsilon^{(i)}$是误差项，它捕获了可能的未建模影响因素（比如我们的回归算法并没有纳入某个影响公寓租金的关键因素），也可能包含了存在于样本中的随机噪音。我们做出进一步假设，$\\epsilon^{(i)}$是独立同分布（IDD: independently and identically distributed）的，服从期望为$0$方差为$\\sigma^2$的高斯分布（或自然分布，Gaussian distribution/Normal distribution），即$\\epsilon^{(i)}\\sim N\\left(0,\\sigma^2\\right)$，即$\\epsilon^{(i)}$的概率密度函数为：\n", 27 | "\n", 28 | "$$p\\left(\\epsilon^{(i)}\\right)=\\frac{1}{\\sqrt{2\\pi}\\sigma}\\exp\\left(-\\frac{\\left(\\epsilon^{(i)}\\right)^2}{2\\sigma^2}\\right)$$\n", 29 | "\n", 30 | "则可以得到：\n", 31 | "\n", 32 | "$$p\\left(y^{(i)}\\mid x^{(i)};\\theta\\right)=\\frac{1}{\\sqrt{2\\pi}\\sigma}\\exp\\left(-\\frac{\\left(y^{(i)}-\\theta^Tx^{(i)}\\right)^2}{2\\sigma^2}\\right)$$\n", 33 | "\n", 34 | "（这里教授简要说明了为什么使用高斯分布，一个原因是因为高斯分布便于计算；另一个原因是在处理实际问题的过程中，如果我们使用线性回归让后尝试测量误差的分布，大多情况下误差都服从高斯分布。高斯模型对于这类对于这类回归问题中的误差来说是一个很好的假设。另外，许多随机变量之和趋于服从高斯分布，如果误差是有许多效应共同导致的，例如卖家的情绪、买家的情绪、房子是否有花园、房间的壁炉数量等等，所有这些效应都是独立的，那么根据中心极限定理，这些效应的总和会近似的服从高斯分布。）\n", 35 | "\n", 36 | "$p\\left(y^{(i)}\\mid x^{(i)};\\theta\\right)$表示以$\\theta$为参数的对于给定$x^{(i)}$下$Y$的条件概率。我们不能将$\\theta$也纳入条件（即不能记为$p\\left(y^{(i)}\\mid x^{(i)},\\theta\\right)$，这表示$y$是以$\\theta,\\ X$的为条件的概率，属于贝叶斯学派的观点），因为$\\theta$并不是一个随机变量（频率学派的观点，我们不把$\\theta$当做随机变量，我们认为$\\theta$确有其值，但是我们现在不知道是多少）。我们也可以将$y^{(i)}$的分别表示为$y^{(i)}\\mid x^{(i)};\\theta\\sim N\\left(\\theta^Tx^{(i)},\\sigma^2\\right)$。（即在给定$x^{(i)}$下假设函数的期望是$\\theta^Tx^{(i)}$。）\n", 37 | "\n", 38 | "现在，已知$X$（包含所有训练样本$x^{(i)}$的设计矩阵）和$\\theta$，求$y^{(i)}$的分布。概率由$p\\left(\\vec y\\mid X;\\theta\\right)$给出，这个量通常被视为一个关于$\\vec y$（也可能关于$X$）的函数，有着固定参数$\\theta$。现在我们明确的将这个量视为一个关于$\\theta$的函数，我们仍叫它**似然函数（likelihood function）**（$\\theta$的似然性是关于给定$X$下数据$Y$以$\\theta$作为参数的概率，虽然$\\theta$的似然性与数据$Y$的概率是一样的，而且尽管似然性和概率几乎是一样的意义，然而我们在这里使用似然性这个词是想强调，我们想要把$p\\left(\\vec y\\mid X;\\theta\\right)$看做是在$\\vec y,\\ X$确定时关于$\\theta$的函数，以后我们也会继续使用“参数的似然性”和“数据的概率”这种称谓，而不是“数据的似然性”和“参数的概率”这种说法。）：\n", 39 | "\n", 40 | "$$L(\\theta)=L\\left(\\theta;X,\\vec y\\right)=p\\left(\\vec y\\mid X;\\theta\\right)$$\n", 41 | "\n", 42 | "利用$\\epsilon^{(i)}$独立的假设（也因为$y^{(i)}$是对于给定$x^{(i)}$的），上式可以写为：\n", 43 | "\n", 44 | "$$\\begin{align}L(\\theta)&=\\prod_{i=1}^mp\\left(y^{(i)}\\mid x^{(i)};\\theta\\right)\\\\&=\\prod_{i=1}^m\\frac{1}{\\sqrt{2\\pi}\\sigma}\\exp\\left(-\\frac{\\left(y^{(i)}-\\theta^Tx^{(i)}\\right)^2}{2\\sigma^2}\\right)\\end{align}$$\n", 45 | "\n", 46 | "我们现在推出了将$x^{(i)}$与$y^{(i)}$联系在一起的概率模型，接下来需要考虑如何合理的对参数$\\theta$做出猜测？最大似然估计告诉我们，应该选择使数据概率尽可能大的$\\theta$，于是，我们应该选择能够使$L(\\theta)$取最大值的$\\theta$。\n", 47 | "\n", 48 | "比起最大化$L(\\theta)$，我们也可以选择最大化任意关于$L(\\theta)$的严格增函数。因此，为了便于求导，我们可以最大化**对数似然估计（log likelihood）**$\\mathscr{l}(\\theta)$：\n", 49 | "\n", 50 | "$$\\begin{align}\\mathscr{l}(\\theta)&=\\log L(\\theta)\\\\&=\\log \\prod_{i=1}^m\\frac{1}{\\sqrt{2\\pi}\\sigma}\\exp\\left(-\\frac{\\left(y^{(i)}-\\theta^Tx^{(i)}\\right)^2}{2\\sigma^2}\\right)\\\\&=\\sum_{i=1}^m\\frac{1}{\\sqrt{2\\pi}\\sigma}\\exp\\left(-\\frac{\\left(y^{(i)}-\\theta^Tx^{(i)}\\right)^2}{2\\sigma^2}\\right)\\\\&=m\\log \\frac{1}{\\sqrt{2\\pi}\\sigma}-\\frac{1}{\\sigma^2}\\cdot\\frac{1}{2}\\sum_{i=1}^m\\left(y^{(i)}-\\theta^Tx^{(i)}\\right)^2\\end{align}$$\n", 51 | "\n", 52 | "于是，我们发现，最大化$\\mathscr{l}(\\theta)$的过程变成了最小化$\\frac{1}{2}\\sum_{i=1}^m\\left(y^{(i)}-\\theta^Tx^{(i)}\\right)^2$，这个式子正是成本函数$J(\\theta)$的定义式。\n", 53 | "\n", 54 | "综上，可以看出，在关于训练数据的概率假设中，最小二乘回归与$\\theta$的最大似然估计一致。也正是因为最小二乘回归其实是再做最大似然估计，所以我们才会强调最小二乘是一种“很自然”的方法。（不过，概率假设并不是证明“最小二乘是一种非常易用的、合理的求解过程”这一结论的*必要条件*，这只是众多假设中的一种，最小二乘在这种假设下合理，除此之外还有其他假设也可以证明这一结论。）\n", 55 | "\n", 56 | "还需要注意的是，我们对$\\theta$的求解并不依赖与$\\sigma^2$，即使不知道$\\sigma$我们依然完成了运算。我们将在后面关于指数族和一般线性模型的课程中使用这一结论。\n", 57 | "\n", 58 | "## 欠拟合和过拟合\n", 59 | "\n", 60 | "继续使用上一讲的例子，当我们考虑使用特征变量$x\\in\\mathbb{R}$来预测$y$，下图最左为使用直线$y=\\theta_0+\\theta_1x$拟合训练集，可以发现得到的直线并不能较为准确的描述训练数据的形态，我们说这不是一个良好的拟合。\n", 61 | "\n", 62 | "\"\"\n", 63 | "\n", 64 | "如果我们再加入一个特征值$x^2$，然后对$y=\\theta_0+\\theta_1x+\\theta_2x^2$做拟合，于是我们得到一个稍好的拟合，如中图所示。看上去似乎是特征值取的越多越好，其实不然，取的过多也会有问题。如图中最右所示，这是用五阶多项式$y=\\displaystyle\\sum_{j=0}^5\\theta_jx_j$得到的结果，可以看出曲线恰好能够经过每一个训练样本，但这并不是我们期望的良好的拟合，比如在“公寓租金”的例子中，这个曲线并不能良好的反映面积$x$对租金$y$的影响。我们将在后面的课程中形式化定义这个现象，并告诉大家如何鉴定什么才是一个“良好的”假设，现在大家只需要了解，左图叫做**欠拟合（underfitting）**，表示数据的特征并没有被拟合曲线良好的表达出来；而右图叫做**过拟合（overfitting）**。\n", 65 | "\n", 66 | "从上面的例子，我们可以清楚的认识到，对特征的选择会在很大程度上影响学习算法的表现。（当学到模型选择时，我们也会见到自动选择“好”特征值的算法。）\n", 67 | "\n", 68 | "## 4. 局部加权回归（LWR: locally weighted linear regression）\n", 69 | "\n", 70 | "如果我们有足够的训练数据，特征值的选择就没那么重要了。在前面学到的线性回归中，为了查询$x$（即得到$h(x)$），我们将执行下面的步骤：\n", 71 | "\n", 72 | "1. 寻找使$\\sum_i\\left(y^{(i)}-\\theta^Tx^{(i)}\\right)^2$取最小的$\\theta$；\n", 73 | "2. 给出预测结果$\\theta^Tx$。\n", 74 | "\n", 75 | "相比上面的过程，局部加权回归执行以下步骤：\n", 76 | "\n", 77 | "1. 针对给定的查询点$x$，寻找使$\\sum_i\\omega^{(i)}\\left(y^{(i)}-\\theta^Tx^{(i)}\\right)^2$取最小的$\\theta$；\n", 78 | "2. 给出预测结果$\\theta^Tx$。\n", 79 | "\n", 80 | "这里的$\\omega$称为权值，是一个非负数。直观上看，如果对于某个$i$，$\\omega^{(i)}$取值较大，则在计算$\\theta$取值时，我们将尽可能的减小$\\left(y^{(i)}-\\theta^Tx^{(i)}\\right)^2$项的取值（精确拟合）；反之，如果$\\omega^{(i)}$取值较小，则$\\left(y^{(i)}-\\theta^Tx^{(i)}\\right)^2$所得到的的误差项将足够小而忽略不计。\n", 81 | "\n", 82 | "一种较为合理的权值设置（这里我们使用指数衰减函数，exponential decay function，权值的设置还有很多其他选择）：\n", 83 | "\n", 84 | "$$\\omega^{(i)}=exp\\left(-\\frac{\\left(x^{(i)}-x\\right)^2}{2\\tau^2}\\right)$$\n", 85 | "\n", 86 | "易看出，对于给定的查询点$x$，权值的大小与训练样本$x^{(i)}$相对于$x$的位置密切相关：\n", 87 | "\n", 88 | "* 如果$x^{(i)}$距离$x$很近，则$\\omega^{(i)}$将取靠近$1$的值；\n", 89 | "* 如果$x^{(i)}$距离$x$很远，则$\\omega^{(i)}$将取到$0$附近。\n", 90 | "\n", 91 | "因此，通过这种方法得到的$\\theta$将更注重查询点$x$附近的训练样本（权重较高）的精确拟合，而忽略那些距离较远的训练样本（权重较低）。（尽管权值函数的样子看起来很像高斯分布的概率密度函数，但是这个函数跟高斯分布并没有直接联系，另外$\\omega^{(i)}$并不是随机变量，也并不服从高斯分布，它只是一个样子恰好类似钟形的曲线。）\n", 92 | "\n", 93 | "函数中的$\\tau$称作**带宽（bandwidth）**（或波长）参数，它控制了权值随距离下降的速率。如果$\\tau$取值较小，则会得到一个较窄的钟形曲线，这意味着离给定查询点$x$较远的训练样本$x^{(i)}$的权值（对查询点$x$附近训练样本的拟合的影响）将下降的非常快；而$\\tau$较大时，则会得到一个较为平缓的曲线，于是查询点附近的训练样本的权重随距离而下降的速度就会相对比较慢。\n", 94 | "\n", 95 | "值得注意的是，这是一个非参数算法，我们在使用这个方法时，是针对给定的查询点$x$进行计算，也就是每当我们对于一个给定的$x$做出预测时，都需要根据整个训练集重新进行拟合运算，如果训练集很大而查询很频繁的话，这个算法的代价将非常高。关于提高这个算法的效率，可以参考Andrew Moore关于KD-Tree的工作。\n" 96 | ] 97 | } 98 | ], 99 | "metadata": { 100 | "anaconda-cloud": {}, 101 | "kernelspec": { 102 | "display_name": "Python 2", 103 | "language": "python", 104 | "name": "python2" 105 | }, 106 | "language_info": { 107 | "codemirror_mode": { 108 | "name": "ipython", 109 | "version": 2 110 | }, 111 | "file_extension": ".py", 112 | "mimetype": "text/x-python", 113 | "name": "python", 114 | "nbconvert_exporter": "python", 115 | "pygments_lexer": "ipython2", 116 | "version": "2.7.13" 117 | } 118 | }, 119 | "nbformat": 4, 120 | "nbformat_minor": 1 121 | } 122 | -------------------------------------------------------------------------------- /1-LinearRegression/note/NOTE-linear_regression.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## 一、[线性回归](code/1-LinearRegression)\n", 8 | "- [全部代码](../code/1-LinearRegression/LinearRegression.py)\n", 9 | "\n", 10 | "### 1、代价函数\n", 11 | "- ![J(\\theta ) = \\frac{1}{{2{\\text{m}}}}\\sum\\limits_{i = 1}^m {{{({h_\\theta }({x^{(i)}}) - {y^{(i)}})}^2}} ](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=J%28%5Ctheta%20%29%20%3D%20%5Cfrac%7B1%7D%7B%7B2%7B%5Ctext%7Bm%7D%7D%7D%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%7B%7B%28%7Bh_%5Ctheta%20%7D%28%7Bx%5E%7B%28i%29%7D%7D%29%20-%20%7By%5E%7B%28i%29%7D%7D%29%7D%5E2%7D%7D%20)\n", 12 | "- 其中：\n", 13 | "![{h_\\theta }(x) = {\\theta _0} + {\\theta _1}{x_1} + {\\theta _2}{x_2} + ...](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7Bh_%5Ctheta%20%7D%28x%29%20%3D%20%7B%5Ctheta%20_0%7D%20%2B%20%7B%5Ctheta%20_1%7D%7Bx_1%7D%20%2B%20%7B%5Ctheta%20_2%7D%7Bx_2%7D%20%2B%20...)\n", 14 | "\n", 15 | "- 下面就是要求出theta，使代价最小，即代表我们拟合出来的方程距离真实值最近\n", 16 | "- 共有m条数据，其中![{{{({h_\\theta }({x^{(i)}}) - {y^{(i)}})}^2}}](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7B%7B%7B%28%7Bh_%5Ctheta%20%7D%28%7Bx%5E%7B%28i%29%7D%7D%29%20-%20%7By%5E%7B%28i%29%7D%7D%29%7D%5E2%7D%7D)代表我们要拟合出来的方程到真实值距离的平方，平方的原因是因为可能有负值，正负可能会抵消\n", 17 | "- 前面有系数`2`的原因是下面求梯度是对每个变量求偏导，`2`可以消去\n", 18 | "\n", 19 | "- 实现代码：" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": null, 25 | "metadata": { 26 | "collapsed": true 27 | }, 28 | "outputs": [], 29 | "source": [ 30 | "# 计算代价函数\n", 31 | "def computerCost(X,y,theta):\n", 32 | " m = len(y)\n", 33 | " J = 0\n", 34 | " \n", 35 | " J = (np.transpose(X*theta-y))*(X*theta-y)/(2*m) #计算代价J\n", 36 | " return J" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "- 注意这里的X是真实数据前加了一列1，因为有theta(0)\n", 44 | "\n", 45 | "### 2、梯度下降算法\n", 46 | "- 代价函数对![{{\\theta _j}}](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7B%7B%5Ctheta%20_j%7D%7D)求偏导得到： \n", 47 | "![\\frac{{\\partial J(\\theta )}}{{\\partial {\\theta _j}}} = \\frac{1}{m}\\sum\\limits_{i = 1}^m {[({h_\\theta }({x^{(i)}}) - {y^{(i)}})x_j^{(i)}]} ](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%5Cfrac%7B%7B%5Cpartial%20J%28%5Ctheta%20%29%7D%7D%7B%7B%5Cpartial%20%7B%5Ctheta%20_j%7D%7D%7D%20%3D%20%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%5B%28%7Bh_%5Ctheta%20%7D%28%7Bx%5E%7B%28i%29%7D%7D%29%20-%20%7By%5E%7B%28i%29%7D%7D%29x_j%5E%7B%28i%29%7D%5D%7D%20)\n", 48 | "- 所以对theta的更新可以写为： \n", 49 | "![{\\theta _j} = {\\theta _j} - \\alpha \\frac{1}{m}\\sum\\limits_{i = 1}^m {[({h_\\theta }({x^{(i)}}) - {y^{(i)}})x_j^{(i)}]} ](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7B%5Ctheta%20_j%7D%20%3D%20%7B%5Ctheta%20_j%7D%20-%20%5Calpha%20%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%5B%28%7Bh_%5Ctheta%20%7D%28%7Bx%5E%7B%28i%29%7D%7D%29%20-%20%7By%5E%7B%28i%29%7D%7D%29x_j%5E%7B%28i%29%7D%5D%7D%20)\n", 50 | "- 其中![\\alpha ](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%5Calpha%20)为学习速率，控制梯度下降的速度，一般取**0.01,0.03,0.1,0.3.....**\n", 51 | "- 为什么梯度下降可以逐步减小代价函数\n", 52 | " - 假设函数`f(x)`\n", 53 | " - 泰勒展开：`f(x+△x)=f(x)+f'(x)*△x+o(△x)`\n", 54 | " - 令：`△x=-α*f'(x)` ,即负梯度方向乘以一个很小的步长`α`\n", 55 | " - 将`△x`代入泰勒展开式中：`f(x+x)=f(x)-α*[f'(x)]²+o(△x)`\n", 56 | " - 可以看出，`α`是取得很小的正数，`[f'(x)]²`也是正数，所以可以得出：`f(x+△x)<=f(x)`\n", 57 | " - 所以沿着**负梯度**放下，函数在减小，多维情况一样。\n", 58 | "- 实现代码" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": { 65 | "collapsed": true 66 | }, 67 | "outputs": [], 68 | "source": [ 69 | "# 梯度下降算法\n", 70 | "def gradientDescent(X,y,theta,alpha,num_iters):\n", 71 | " m = len(y) \n", 72 | " n = len(theta)\n", 73 | " \n", 74 | " temp = np.matrix(np.zeros((n,num_iters))) # 暂存每次迭代计算的theta，转化为矩阵形式\n", 75 | " \n", 76 | " \n", 77 | " J_history = np.zeros((num_iters,1)) #记录每次迭代计算的代价值\n", 78 | " \n", 79 | " for i in range(num_iters): # 遍历迭代次数 \n", 80 | " h = np.dot(X,theta) # 计算内积，matrix可以直接乘\n", 81 | " temp[:,i] = theta - ((alpha/m)*(np.dot(np.transpose(X),h-y))) #梯度的计算\n", 82 | " theta = temp[:,i]\n", 83 | " J_history[i] = computerCost(X,y,theta) #调用计算代价函数\n", 84 | " print '.', \n", 85 | " return theta,J_history " 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "### 3、均值归一化\n", 93 | "- 目的是使数据都缩放到一个范围内，便于使用梯度下降算法\n", 94 | "- ![{x_i} = \\frac{{{x_i} - {\\mu _i}}}{{{s_i}}}](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7Bx_i%7D%20%3D%20%5Cfrac%7B%7B%7Bx_i%7D%20-%20%7B%5Cmu%20_i%7D%7D%7D%7B%7B%7Bs_i%7D%7D%7D)\n", 95 | "- 其中 ![{{\\mu _i}}](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7B%7B%5Cmu%20_i%7D%7D) 为所有此feture数据的平均值\n", 96 | "- ![{{s_i}}](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7B%7Bs_i%7D%7D)可以是**最大值-最小值**，也可以是这个feature对应的数据的**标准差**\n", 97 | "- 实现代码：" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "metadata": { 104 | "collapsed": true 105 | }, 106 | "outputs": [], 107 | "source": [ 108 | "# 归一化feature\n", 109 | "def featureNormaliza(X):\n", 110 | " X_norm = np.array(X) #将X转化为numpy数组对象，才可以进行矩阵的运算\n", 111 | " #定义所需变量\n", 112 | " mu = np.zeros((1,X.shape[1])) \n", 113 | " sigma = np.zeros((1,X.shape[1]))\n", 114 | " \n", 115 | " mu = np.mean(X_norm,0) # 求每一列的平均值（0指定为列，1代表行）\n", 116 | " sigma = np.std(X_norm,0) # 求每一列的标准差\n", 117 | " for i in range(X.shape[1]): # 遍历列\n", 118 | " X_norm[:,i] = (X_norm[:,i]-mu[i])/sigma[i] # 归一化\n", 119 | " \n", 120 | " return X_norm,mu,sigma" 121 | ] 122 | }, 123 | { 124 | "cell_type": "markdown", 125 | "metadata": {}, 126 | "source": [ 127 | "- 注意预测的时候也需要均值归一化数据\n", 128 | "\n", 129 | "### 4、最终运行结果\n", 130 | "- 代价随迭代次数的变化 \n", 131 | "![enter description here](../../images/LinearRegression_01.png)\n", 132 | "\n", 133 | "\n", 134 | "### 5、使用scikit-learn库中的线性模型实现\n", 135 | "- [全部代码](../../code/1-LinearRegression/LinearRegression_scikit-learn.py)\n", 136 | "- 导入包" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": { 143 | "collapsed": true 144 | }, 145 | "outputs": [], 146 | "source": [ 147 | "from sklearn import linear_model\n", 148 | "from sklearn.preprocessing import StandardScaler #引入缩放的包" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "- 归一化" 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": null, 161 | "metadata": { 162 | "collapsed": true 163 | }, 164 | "outputs": [], 165 | "source": [ 166 | " # 归一化操作\n", 167 | "scaler = StandardScaler() \n", 168 | "scaler.fit(X)\n", 169 | "x_train = scaler.transform(X)\n", 170 | "x_test = scaler.transform(np.array([1650,3]))" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "- 线性模型拟合" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": null, 183 | "metadata": { 184 | "collapsed": true 185 | }, 186 | "outputs": [], 187 | "source": [ 188 | "# 线性模型拟合\n", 189 | "model = linear_model.LinearRegression()\n", 190 | "model.fit(x_train, y)" 191 | ] 192 | } 193 | ], 194 | "metadata": { 195 | "kernelspec": { 196 | "display_name": "Python 2", 197 | "language": "python", 198 | "name": "python2" 199 | }, 200 | "language_info": { 201 | "codemirror_mode": { 202 | "name": "ipython", 203 | "version": 2 204 | }, 205 | "file_extension": ".py", 206 | "mimetype": "text/x-python", 207 | "name": "python", 208 | "nbconvert_exporter": "python", 209 | "pygments_lexer": "ipython2", 210 | "version": "2.7.13" 211 | } 212 | }, 213 | "nbformat": 4, 214 | "nbformat_minor": 2 215 | } 216 | -------------------------------------------------------------------------------- /2-LogisticRegression/AndrewNg-MechineLearning/ex2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/2-LogisticRegression/AndrewNg-MechineLearning/ex2.pdf -------------------------------------------------------------------------------- /2-LogisticRegression/AndrewNg-MechineLearning/ex2data1.txt: -------------------------------------------------------------------------------- 1 | 34.62365962451697,78.0246928153624,0 2 | 30.28671076822607,43.89499752400101,0 3 | 35.84740876993872,72.90219802708364,0 4 | 60.18259938620976,86.30855209546826,1 5 | 79.0327360507101,75.3443764369103,1 6 | 45.08327747668339,56.3163717815305,0 7 | 61.10666453684766,96.51142588489624,1 8 | 75.02474556738889,46.55401354116538,1 9 | 76.09878670226257,87.42056971926803,1 10 | 84.43281996120035,43.53339331072109,1 11 | 95.86155507093572,38.22527805795094,0 12 | 75.01365838958247,30.60326323428011,0 13 | 82.30705337399482,76.48196330235604,1 14 | 69.36458875970939,97.71869196188608,1 15 | 39.53833914367223,76.03681085115882,0 16 | 53.9710521485623,89.20735013750205,1 17 | 69.07014406283025,52.74046973016765,1 18 | 67.94685547711617,46.67857410673128,0 19 | 70.66150955499435,92.92713789364831,1 20 | 76.97878372747498,47.57596364975532,1 21 | 67.37202754570876,42.83843832029179,0 22 | 89.67677575072079,65.79936592745237,1 23 | 50.534788289883,48.85581152764205,0 24 | 34.21206097786789,44.20952859866288,0 25 | 77.9240914545704,68.9723599933059,1 26 | 62.27101367004632,69.95445795447587,1 27 | 80.1901807509566,44.82162893218353,1 28 | 93.114388797442,38.80067033713209,0 29 | 61.83020602312595,50.25610789244621,0 30 | 38.78580379679423,64.99568095539578,0 31 | 61.379289447425,72.80788731317097,1 32 | 85.40451939411645,57.05198397627122,1 33 | 52.10797973193984,63.12762376881715,0 34 | 52.04540476831827,69.43286012045222,1 35 | 40.23689373545111,71.16774802184875,0 36 | 54.63510555424817,52.21388588061123,0 37 | 33.91550010906887,98.86943574220611,0 38 | 64.17698887494485,80.90806058670817,1 39 | 74.78925295941542,41.57341522824434,0 40 | 34.1836400264419,75.2377203360134,0 41 | 83.90239366249155,56.30804621605327,1 42 | 51.54772026906181,46.85629026349976,0 43 | 94.44336776917852,65.56892160559052,1 44 | 82.36875375713919,40.61825515970618,0 45 | 51.04775177128865,45.82270145776001,0 46 | 62.22267576120188,52.06099194836679,0 47 | 77.19303492601364,70.45820000180959,1 48 | 97.77159928000232,86.7278223300282,1 49 | 62.07306379667647,96.76882412413983,1 50 | 91.56497449807442,88.69629254546599,1 51 | 79.94481794066932,74.16311935043758,1 52 | 99.2725269292572,60.99903099844988,1 53 | 90.54671411399852,43.39060180650027,1 54 | 34.52451385320009,60.39634245837173,0 55 | 50.2864961189907,49.80453881323059,0 56 | 49.58667721632031,59.80895099453265,0 57 | 97.64563396007767,68.86157272420604,1 58 | 32.57720016809309,95.59854761387875,0 59 | 74.24869136721598,69.82457122657193,1 60 | 71.79646205863379,78.45356224515052,1 61 | 75.3956114656803,85.75993667331619,1 62 | 35.28611281526193,47.02051394723416,0 63 | 56.25381749711624,39.26147251058019,0 64 | 30.05882244669796,49.59297386723685,0 65 | 44.66826172480893,66.45008614558913,0 66 | 66.56089447242954,41.09209807936973,0 67 | 40.45755098375164,97.53518548909936,1 68 | 49.07256321908844,51.88321182073966,0 69 | 80.27957401466998,92.11606081344084,1 70 | 66.74671856944039,60.99139402740988,1 71 | 32.72283304060323,43.30717306430063,0 72 | 64.0393204150601,78.03168802018232,1 73 | 72.34649422579923,96.22759296761404,1 74 | 60.45788573918959,73.09499809758037,1 75 | 58.84095621726802,75.85844831279042,1 76 | 99.82785779692128,72.36925193383885,1 77 | 47.26426910848174,88.47586499559782,1 78 | 50.45815980285988,75.80985952982456,1 79 | 60.45555629271532,42.50840943572217,0 80 | 82.22666157785568,42.71987853716458,0 81 | 88.9138964166533,69.80378889835472,1 82 | 94.83450672430196,45.69430680250754,1 83 | 67.31925746917527,66.58935317747915,1 84 | 57.23870631569862,59.51428198012956,1 85 | 80.36675600171273,90.96014789746954,1 86 | 68.46852178591112,85.59430710452014,1 87 | 42.0754545384731,78.84478600148043,0 88 | 75.47770200533905,90.42453899753964,1 89 | 78.63542434898018,96.64742716885644,1 90 | 52.34800398794107,60.76950525602592,0 91 | 94.09433112516793,77.15910509073893,1 92 | 90.44855097096364,87.50879176484702,1 93 | 55.48216114069585,35.57070347228866,0 94 | 74.49269241843041,84.84513684930135,1 95 | 89.84580670720979,45.35828361091658,1 96 | 83.48916274498238,48.38028579728175,1 97 | 42.2617008099817,87.10385094025457,1 98 | 99.31500880510394,68.77540947206617,1 99 | 55.34001756003703,64.9319380069486,1 100 | 74.77589300092767,89.52981289513276,1 101 | -------------------------------------------------------------------------------- /2-LogisticRegression/AndrewNg-MechineLearning/ex2data2.txt: -------------------------------------------------------------------------------- 1 | 0.051267,0.69956,1 2 | -0.092742,0.68494,1 3 | -0.21371,0.69225,1 4 | -0.375,0.50219,1 5 | -0.51325,0.46564,1 6 | -0.52477,0.2098,1 7 | -0.39804,0.034357,1 8 | -0.30588,-0.19225,1 9 | 0.016705,-0.40424,1 10 | 0.13191,-0.51389,1 11 | 0.38537,-0.56506,1 12 | 0.52938,-0.5212,1 13 | 0.63882,-0.24342,1 14 | 0.73675,-0.18494,1 15 | 0.54666,0.48757,1 16 | 0.322,0.5826,1 17 | 0.16647,0.53874,1 18 | -0.046659,0.81652,1 19 | -0.17339,0.69956,1 20 | -0.47869,0.63377,1 21 | -0.60541,0.59722,1 22 | -0.62846,0.33406,1 23 | -0.59389,0.005117,1 24 | -0.42108,-0.27266,1 25 | -0.11578,-0.39693,1 26 | 0.20104,-0.60161,1 27 | 0.46601,-0.53582,1 28 | 0.67339,-0.53582,1 29 | -0.13882,0.54605,1 30 | -0.29435,0.77997,1 31 | -0.26555,0.96272,1 32 | -0.16187,0.8019,1 33 | -0.17339,0.64839,1 34 | -0.28283,0.47295,1 35 | -0.36348,0.31213,1 36 | -0.30012,0.027047,1 37 | -0.23675,-0.21418,1 38 | -0.06394,-0.18494,1 39 | 0.062788,-0.16301,1 40 | 0.22984,-0.41155,1 41 | 0.2932,-0.2288,1 42 | 0.48329,-0.18494,1 43 | 0.64459,-0.14108,1 44 | 0.46025,0.012427,1 45 | 0.6273,0.15863,1 46 | 0.57546,0.26827,1 47 | 0.72523,0.44371,1 48 | 0.22408,0.52412,1 49 | 0.44297,0.67032,1 50 | 0.322,0.69225,1 51 | 0.13767,0.57529,1 52 | -0.0063364,0.39985,1 53 | -0.092742,0.55336,1 54 | -0.20795,0.35599,1 55 | -0.20795,0.17325,1 56 | -0.43836,0.21711,1 57 | -0.21947,-0.016813,1 58 | -0.13882,-0.27266,1 59 | 0.18376,0.93348,0 60 | 0.22408,0.77997,0 61 | 0.29896,0.61915,0 62 | 0.50634,0.75804,0 63 | 0.61578,0.7288,0 64 | 0.60426,0.59722,0 65 | 0.76555,0.50219,0 66 | 0.92684,0.3633,0 67 | 0.82316,0.27558,0 68 | 0.96141,0.085526,0 69 | 0.93836,0.012427,0 70 | 0.86348,-0.082602,0 71 | 0.89804,-0.20687,0 72 | 0.85196,-0.36769,0 73 | 0.82892,-0.5212,0 74 | 0.79435,-0.55775,0 75 | 0.59274,-0.7405,0 76 | 0.51786,-0.5943,0 77 | 0.46601,-0.41886,0 78 | 0.35081,-0.57968,0 79 | 0.28744,-0.76974,0 80 | 0.085829,-0.75512,0 81 | 0.14919,-0.57968,0 82 | -0.13306,-0.4481,0 83 | -0.40956,-0.41155,0 84 | -0.39228,-0.25804,0 85 | -0.74366,-0.25804,0 86 | -0.69758,0.041667,0 87 | -0.75518,0.2902,0 88 | -0.69758,0.68494,0 89 | -0.4038,0.70687,0 90 | -0.38076,0.91886,0 91 | -0.50749,0.90424,0 92 | -0.54781,0.70687,0 93 | 0.10311,0.77997,0 94 | 0.057028,0.91886,0 95 | -0.10426,0.99196,0 96 | -0.081221,1.1089,0 97 | 0.28744,1.087,0 98 | 0.39689,0.82383,0 99 | 0.63882,0.88962,0 100 | 0.82316,0.66301,0 101 | 0.67339,0.64108,0 102 | 1.0709,0.10015,0 103 | -0.046659,-0.57968,0 104 | -0.23675,-0.63816,0 105 | -0.15035,-0.36769,0 106 | -0.49021,-0.3019,0 107 | -0.46717,-0.13377,0 108 | -0.28859,-0.060673,0 109 | -0.61118,-0.067982,0 110 | -0.66302,-0.21418,0 111 | -0.59965,-0.41886,0 112 | -0.72638,-0.082602,0 113 | -0.83007,0.31213,0 114 | -0.72062,0.53874,0 115 | -0.59389,0.49488,0 116 | -0.48445,0.99927,0 117 | -0.0063364,0.99927,0 118 | 0.63265,-0.030612,0 119 | -------------------------------------------------------------------------------- /2-LogisticRegression/AndrewNg-MechineLearning/logical_regression.py: -------------------------------------------------------------------------------- 1 | # coding: utf-8 2 | # logical_regression/logical_regression.py 3 | import numpy as np 4 | import time 5 | 6 | def exeTime(func): 7 | """耗时计算装饰器 8 | 9 | Args: 10 | func 待装饰函数 11 | Returns: 12 | newFunc 装饰后的函数 13 | """ 14 | def newFunc(*args, **args2): 15 | t0 = time.time() 16 | back = func(*args, **args2) 17 | return back, time.time() - t0 18 | return newFunc 19 | 20 | def loadDataSet(filename): 21 | """读取数据集 22 | 数据以TAB进行分割 23 | 24 | Args: 25 | filename 文件名 26 | Returns: 27 | X 训练样本集矩阵 28 | y 标签集矩阵 29 | """ 30 | numFeat = len(open(filename).readline().split('\t')) - 1 31 | X = [] 32 | y = [] 33 | file = open(filename) 34 | for line in file.readlines(): 35 | lineArr = [] 36 | curLine = line.strip().split('\t') 37 | for i in range(numFeat): 38 | lineArr.append(float(curLine[i])) 39 | X.append([1.0, float(lineArr[0]), float(lineArr[1])]) 40 | y.append(float(curLine[-1])) 41 | return np.mat(X), np.mat(y).T 42 | 43 | def sigmoid(z): 44 | """sigmoid函数 45 | """ 46 | return 1.0/(1.0+np.exp(-z)) 47 | 48 | def J(theta, X, y, theLambda=0): 49 | """预测代价函数 50 | """ 51 | m, n = X.shape 52 | h = sigmoid(X.dot(theta)) 53 | J = (-1.0/m)*(np.log(h).T.dot(y)+np.log(1-h).T.dot(1-y)) + (theLambda/(2.0*m))*np.sum(np.square(theta[1:])) 54 | if np.isnan(J[0]): 55 | return(np.inf) 56 | return J.flatten()[0,0] 57 | 58 | @exeTime 59 | def gradient(X, y, options): 60 | """随机梯度下降法 61 | Args: 62 | X 样本矩阵 63 | y 标签矩阵 64 | rate 学习率 65 | options.theLambda 正规参数 66 | options.maxLoop 最大迭代次数 67 | options.epsilon 收敛精度 68 | options.method 69 | - 'sgd' 随机梯度下降法 70 | - 'bgd' 批量梯度下降法 71 | Returns: 72 | (thetas, errors), timeConsumed 73 | """ 74 | m,n = X.shape 75 | # 初始化参数矩阵 76 | theta = np.ones((n,1)) 77 | count = 0 # 迭代次数 78 | # 初始化误差无限大 79 | error = float('inf') 80 | # 保存误差变化状况 81 | errors = [] 82 | # 保存参数的变化状况 83 | thetas = [] 84 | rate = options.get('rate', 0.01) 85 | epsilon = options.get('epsilon', 0.1) 86 | maxLoop = options.get('maxLoop', 1000) 87 | theLambda = options.get('theLambda', 0) 88 | method = options['method'] 89 | def _sgd(theta): 90 | converged = False 91 | for i in range(maxLoop): 92 | if converged: 93 | break 94 | for j in range(m): 95 | h = sigmoid(X[j] *theta) 96 | diff = h - y[j] 97 | theta = theta - rate*(1.0/m)*X[j].T*diff 98 | error = J(theta, X, y) 99 | errors.append(error) 100 | if error < epsilon: 101 | converged = True 102 | break 103 | thetas.append(theta) 104 | return thetas, errors, i+1 105 | def _bgd(theta): 106 | for i in range(maxLoop): 107 | h = sigmoid(X.dot(theta)) 108 | diff = h - y 109 | # theta0 should not be regularized 110 | theta = theta - rate*((1.0/m)*X.T*diff + (theLambda/m)*np.r_[[[0]], theta[1:]]) 111 | error = J(theta, X, y, theLambda) 112 | errors.append(error) 113 | if error < epsilon: 114 | break 115 | thetas.append(theta) 116 | return thetas, errors, i+1 117 | methods = { 118 | 'sgd': _sgd, 119 | 'bgd': _bgd 120 | } 121 | return methods[method](theta) 122 | 123 | def oneVsAll(X, y, options): 124 | """One-vs-All 多分类 125 | 126 | Args: 127 | X 样本 128 | y 标签 129 | options 训练配置 130 | Returns: 131 | Thetas 权值矩阵 132 | """ 133 | # 类型数 134 | classes = set(np.ravel(y)) 135 | # 决策边界矩阵 136 | Thetas = np.zeros((len(classes), X.shape[1])) 137 | # 一次选定每种分类对应的样本为正样本，其他样本标识为负样本，进行逻辑回归 138 | for idx, c in enumerate(classes): 139 | newY = np.zeros(y.shape) 140 | newY[np.where(y == c)] = 1 141 | result, timeConsumed = gradient(X, newY, options) 142 | thetas,errors,iterations = result 143 | Thetas[idx] = thetas[-1].ravel() 144 | return Thetas 145 | 146 | def predictOneVsAll(X,Thetas): 147 | """One-vs-All下的多分类预测 148 | 149 | Args: 150 | X 样本 151 | Thetas 权值矩阵 152 | Returns： 153 | H 预测结果 154 | """ 155 | H = sigmoid(Thetas * X.T) 156 | return H 157 | -------------------------------------------------------------------------------- /2-LogisticRegression/LogisticRegression_OneVsAll_scikit-learn.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "这里显示 数字识别 使用scikit-learn" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": { 14 | "collapsed": true 15 | }, 16 | "outputs": [], 17 | "source": [ 18 | "from scipy import io as spio\n", 19 | "import numpy as np\n", 20 | "from sklearn.linear_model import LogisticRegression" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 2, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "name": "stdout", 30 | "output_type": "stream", 31 | "text": [ 32 | "预测准确度为：94.380000%\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "data = spio.loadmat(\"../data/2-logistic_regression/data_digits.mat\")\n", 38 | "X = data['X'] # 获取X数据，每一行对应一个数字20x20px\n", 39 | "y = data['y'] # 这里读取mat文件y的shape=(5000, 1)\n", 40 | "y = np.ravel(y) # 调用sklearn需要转化成一维的(5000,)\n", 41 | "\n", 42 | "model = LogisticRegression()\n", 43 | "model.fit(X, y) # 拟合\n", 44 | "\n", 45 | "predict = model.predict(X) # 预测\n", 46 | "\n", 47 | "print (u\"预测准确度为：%f%%\" % np.mean((predict == y)*100))" 48 | ] 49 | } 50 | ], 51 | "metadata": { 52 | "kernelspec": { 53 | "display_name": "Python 2", 54 | "language": "python", 55 | "name": "python2" 56 | }, 57 | "language_info": { 58 | "codemirror_mode": { 59 | "name": "ipython", 60 | "version": 2 61 | }, 62 | "file_extension": ".py", 63 | "mimetype": "text/x-python", 64 | "name": "python", 65 | "nbconvert_exporter": "python", 66 | "pygments_lexer": "ipython2", 67 | "version": "2.7.13" 68 | } 69 | }, 70 | "nbformat": 4, 71 | "nbformat_minor": 2 72 | } 73 | -------------------------------------------------------------------------------- /2-LogisticRegression/LogisticRegression_scikit-learn.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "这里用来显示 调用scikit-learn实现逻辑回归" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": { 14 | "collapsed": true 15 | }, 16 | "outputs": [], 17 | "source": [ 18 | "from sklearn.linear_model import LogisticRegression\n", 19 | "from sklearn.preprocessing import StandardScaler\n", 20 | "from sklearn.model_selection import train_test_split\n", 21 | "import numpy as np" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 2, 27 | "metadata": {}, 28 | "outputs": [ 29 | { 30 | "name": "stdout", 31 | "output_type": "stream", 32 | "text": [ 33 | "[[ 0. 1.]\n", 34 | " [ 1. 1.]\n", 35 | " [ 1. 1.]\n", 36 | " [ 1. 1.]\n", 37 | " [ 1. 1.]\n", 38 | " [ 1. 1.]\n", 39 | " [ 0. 0.]\n", 40 | " [ 1. 1.]\n", 41 | " [ 1. 1.]\n", 42 | " [ 0. 0.]\n", 43 | " [ 1. 1.]\n", 44 | " [ 1. 1.]\n", 45 | " [ 0. 0.]\n", 46 | " [ 0. 0.]\n", 47 | " [ 0. 1.]\n", 48 | " [ 0. 0.]\n", 49 | " [ 0. 0.]\n", 50 | " [ 1. 1.]\n", 51 | " [ 1. 1.]\n", 52 | " [ 0. 0.]]\n", 53 | "测试集准确率：90.000000%\n" 54 | ] 55 | } 56 | ], 57 | "source": [ 58 | "data = np.loadtxt(\"../data/2-logistic_regression/data1.txt\", delimiter=\",\",dtype= np.float64)\n", 59 | "X = data[:, 0:-1]\n", 60 | "y = data[:, -1]\n", 61 | "\n", 62 | "# 划分为训练集和测试集\n", 63 | "x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n", 64 | "\n", 65 | "# 归一化\n", 66 | "scaler = StandardScaler()\n", 67 | "scaler.fit(x_train)\n", 68 | "x_train = scaler.fit_transform(x_train)\n", 69 | "x_test = scaler.fit_transform(x_test)\n", 70 | "\n", 71 | "# 逻辑回归\n", 72 | "model = LogisticRegression()\n", 73 | "model.fit(x_train, y_train)\n", 74 | "\n", 75 | "# 预测\n", 76 | "predict = model.predict(x_test)\n", 77 | "right = sum(predict == y_test)\n", 78 | "\n", 79 | "predict = np.hstack((predict.reshape(-1, 1), y_test.reshape(-1, 1))) # 将预测值和真实值放在一块，好观察\n", 80 | "print(predict)\n", 81 | "print('测试集准确率：%f%%' % (right * 100.0 / predict.shape[0])) # 计算在测试集上的准确度\n" 82 | ] 83 | } 84 | ], 85 | "metadata": { 86 | "kernelspec": { 87 | "display_name": "Python 2", 88 | "language": "python", 89 | "name": "python2" 90 | }, 91 | "language_info": { 92 | "codemirror_mode": { 93 | "name": "ipython", 94 | "version": 2 95 | }, 96 | "file_extension": ".py", 97 | "mimetype": "text/x-python", 98 | "name": "python", 99 | "nbconvert_exporter": "python", 100 | "pygments_lexer": "ipython2", 101 | "version": "2.7.13" 102 | } 103 | }, 104 | "nbformat": 4, 105 | "nbformat_minor": 2 106 | } 107 | -------------------------------------------------------------------------------- /2-LogisticRegression/note/LSJU-chapter03_2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 第二部分：分类问题（Classification）和逻辑回归（Logistic regression）\n", 8 | "\n", 9 | "在前面的回归问题中，我们尝试预测的变量$y$是连续变量，现在我们来讨论分类问题。分类问题与回归问题不同之处在于，$y$的取值是少量的离散值。现在，我们先介绍**二元分类（binary classification）**，也就是$y$只能取$0$或$1$。（在二元分类中介绍的很多方法也可以推广至多元情况。）比如，我们尝试实现一个垃圾邮件分类器，用$x^{(i)}$表示邮件的某些特征，通过分类算法预测得到：如果该邮件是垃圾邮件时$y=1$，反之$y=0$。我们也把$0$称为**negative class**，把$1$称为**positive class**，我们有时也使用$-,\\ +$作为标记。对于给定的$x^{(i)}$，$y^{(i)}$也称作训练样本的**label**。\n", 10 | "\n", 11 | "## 5. 逻辑回归\n", 12 | "\n", 13 | "对于分类问题，我们也可以无视$y$是取离散值的特征而继续使用线性回归，使用老办法通过$x$预测$y$的取值。然而，强行使用线性回归的方法处理分类问题通常会得到很糟糕的预测结果。况且，在我们已经明确知道$y\\in\\{0,\\ 1\\}$的情况下仍旧使用线性回归的$h_\\theta(x)\\in\\mathbb{R}$是不合逻辑的。\n", 14 | "\n", 15 | "所以，我们应该对原来的假设函数做出修改：\n", 16 | "\n", 17 | "$$h_\\theta(x)=g\\left(\\theta^Tx\\right)=\\frac{1}{1+e^{-\\theta^Tx}}$$\n", 18 | "\n", 19 | "这里的$g(z)=\\frac{1}{1+e^{-z}}$，也叫作**逻辑函数（logistic function）**或**S型函数（sigmoid function）**，图像如下图所示：\n", 20 | "\n", 21 | "\"\"\n", 22 | "\n", 23 | "在$z\\to\\infty$时函数$g(z)$趋近于$1$，而$z\\to-\\infty$是函数$g(z)$趋近于$0$。而且不光是$g(z)$，包括上面的$h(x)$都在$(0, 1)$之间取值。有$\\theta^Tx=\\theta_0+\\displaystyle\\sum_{j=0}^n\\theta_jx_j$，这里我们依然令$x_0=1$。\n", 24 | "\n", 25 | "其它的在$(-\\infty,\\ \\infty)$上能够从$0$取到$1$的可导的连续函数也可以使用，但是因为一些原因（我们将在后面的关于GLM、生成学习法的课程中了解），选择上面的逻辑函数是一种“自然”的结果。再继续前，我们先来看一下逻辑函数求导的优良性质：\n", 26 | "\n", 27 | "$$\\begin{align}g'(z)&=\\frac{\\mathrm d}{\\mathrm dz}\\frac{1}{1+e^{-z}}\\\\&=\\frac{1}{\\left(1+e^{-z}\\right)^2}\\left(e^{-z}\\right)\\\\&=\\frac{1}{1+e^{-z}}\\cdot\\left(1-\\frac{1}{1+e^{-z}}\\right)\\\\&=g(z)(1-g(z))\\end{align}$$\n", 28 | "\n", 29 | "接下来，我们应该如何用$\\theta$拟合逻辑回归模型呢？在线性回归中我们知道了，从一些列假设下的最大似然估计可以推导出最小二乘回归的合理性，所以，我们也可以按照这个思路，给我们的分类模型赋予一些列概率假设，然后通过最大似然估计拟合参数。假设：\n", 30 | "\n", 31 | "$$\\begin{align}P(y=1\\mid x;\\theta)&=h_\\theta(x)\\\\P(y=0\\mid x;\\theta)&=1-h_\\theta(x)\\end{align}$$\n", 32 | "\n", 33 | "当然，我们也可以将这两个假设合入一个简洁的式子：\n", 34 | "\n", 35 | "$$p(y\\mid x;\\theta)=(h_\\theta(x))^y(1-h_\\theta(x))^{(1-y)}$$\n", 36 | "\n", 37 | "假设训练集中的$m$个训练样本是相互独立的，我们就可以这样写出参数的似然估计：\n", 38 | "\n", 39 | "$$\\begin{align}L(\\theta)&=p\\left(\\vec y\\mid X;\\theta\\right)\\\\&=\\prod_{i=1}^m p\\left(y^{(i)}\\mid x^{(i)};\\theta\\right)\\\\&=\\prod_{i=1}^m\\left(h_\\theta\\left(x^{(i)}\\right)\\right)^{y^{(i)}}\\left(1-h_\\theta\\left(x^{(i)}\\right)\\right)^{1-y^{(i)}}\\end{align}$$\n", 40 | "\n", 41 | "跟线性回归中的运算一样，我们取对数便于求导：\n", 42 | "\n", 43 | "$$\\begin{align}\\mathscr{l}(\\theta)&=\\log L(\\theta)\\\\&=\\sum_{i=1}^my^{(i)}\\log h_\\theta\\left(x^{(i)}\\right)+\\left(1-y^{(i)}\\right)\\log\\left(1-h_\\theta\\left(x^{(i)}\\right)\\right)\\end{align}$$\n", 44 | "\n", 45 | "我们依然沿用线性回归中的思路，通过求导发现最大化似然函数的极值点，这次我们使用梯度上升法。我们使用矢量记法，则有更新规则为$\\theta:=\\theta+\\alpha\\nabla_\\theta\\mathscr{l}(\\theta)$。（因为想要求函数的最大值，所以我们在更新规则里使用了加号。）我们现在假设训练集中只有一个训练样本$(x,\\ y)$，对其求导，希望能导出适用于随机梯度上升更新规则：\n", 46 | "\n", 47 | "$$\\begin{align}\\frac{\\partial}{\\partial\\theta_j}\\mathscr{l}(\\theta)&=\\left(y\\frac{1}{g\\left(\\theta^Tx\\right)}-(1-y)\\frac{1}{1-g\\left(\\theta^Tx\\right)}\\right)\\frac{\\partial}{\\partial\\theta_j}g\\left(\\theta^Tx\\right)\\\\&=\\left(y\\frac{1}{g\\left(\\theta^Tx\\right)}-(1-y)\\frac{1}{1-g\\left(\\theta^Tx\\right)}\\right)g\\left(\\theta^Tx\\right)\\left(1-g\\left(\\theta^Tx\\right)\\right)\\frac{\\partial}{\\partial\\theta_j}\\theta^Tx\\\\&=\\left(y\\left(1-g\\left(\\theta^Tx\\right)\\right)-(1-y)g\\left(\\theta^Tx\\right)\\right)x_j\\\\&=(y-h_\\theta(x))x_j\\end{align}$$\n", 48 | "\n", 49 | "在上面的求导中，从第一步到第二步我们使用了逻辑函数求导性质$g'(z)=g(z)(1-g(z))$。这样，我们也就得到了适用于随机梯度上升的更新规则：\n", 50 | "\n", 51 | "$$\\theta_j:=\\theta_j+\\alpha\\left(y^{(i)}-h_\\theta\\left(x^{(i)}\\right)\\right)x_j$$\n", 52 | "\n", 53 | "如果使用批量梯度上升则是：\n", 54 | "\n", 55 | "$$\\theta_j:=\\theta_j+\\alpha\\sum_{i=1}^m\\left(y^{(i)}-h_\\theta\\left(x^{(i)}\\right)\\right)x_j$$\n", 56 | "\n", 57 | "回顾上一讲的最小均方法法，我们会发现上面这条更新规则和以前的更新规则一模一样，我们在这里必须说明，$h_\\theta(x)$已经变为关于$\\theta^Tx^{(i)}$的非线性函数，所以这并不是同一个算法。尽管如此，对于不同的算法得到同样形式的更新规则，我们还是感到很惊讶。对于这个现象，我们会在后面关于GLM模型的课程中给出解释。\n", 58 | "\n", 59 | "## 6. 感知算法（perceptron learning algorithm）\n", 60 | "\n", 61 | "最后，我们来简要的介绍一下感知算法，我们以后在介绍学习理论是还会继续讨论这个算法。对于上面的逻辑回归，我们如何“强迫”算法只输出$0$或$1$？我们会自然的想到改变$g$的定义，使其变为一个阈函数：\n", 62 | "\n", 63 | "$$g(z)=\\begin{cases}1\\quad z\\geq 0\\\\0\\quad z\\lt 0\\end{cases}$$\n", 64 | "\n", 65 | "如果我们依然令$h_\\theta(x)=g\\left(\\theta^Tx\\right)$，并将$g$修改为上面的阈函数，然后使用$\\theta_j:=\\theta_j+\\alpha\\displaystyle\\sum_{i=1}^m\\left(y^{(i)}-h_\\theta\\left(x^{(i)}\\right)\\right)x_j$或$\\theta_j:=\\theta_j+\\alpha\\left(y^{(i)}-h_\\theta\\left(x^{(i)}\\right)\\right)x_j$作为学习规则，那么我们就实现了一个**感知算法（perceptron learning algorithm）**。\n", 66 | "\n", 67 | "在六十年代，这个感知算法被认为是一种粗略的描述脑中独立神经元工作方式的模型。该模型很简单，所以我们也将它作为日后讨论学习理论的起点。需要注意的是，尽管这个算法看起来并不特殊，但实际上，与其前面的逻辑回归、最小二乘线性回归比起来，这是一个非常不同的算法：比如，我们很难赋予它一个在概率上有意义的解释，也很难从最大似然估计推导出感知算法。" 68 | ] 69 | } 70 | ], 71 | "metadata": { 72 | "kernelspec": { 73 | "display_name": "Python 2", 74 | "language": "python", 75 | "name": "python2" 76 | }, 77 | "language_info": { 78 | "codemirror_mode": { 79 | "name": "ipython", 80 | "version": 2 81 | }, 82 | "file_extension": ".py", 83 | "mimetype": "text/x-python", 84 | "name": "python", 85 | "nbconvert_exporter": "python", 86 | "pygments_lexer": "ipython2", 87 | "version": "2.7.13" 88 | } 89 | }, 90 | "nbformat": 4, 91 | "nbformat_minor": 2 92 | } 93 | -------------------------------------------------------------------------------- /3-NeuralNetwok/AndrewNg_MechineLearning/ex3.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/3-NeuralNetwok/AndrewNg_MechineLearning/ex3.pdf -------------------------------------------------------------------------------- /3-NeuralNetwok/AndrewNg_MechineLearning/ex3data1.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/3-NeuralNetwok/AndrewNg_MechineLearning/ex3data1.mat -------------------------------------------------------------------------------- /3-NeuralNetwok/AndrewNg_MechineLearning/ex3weights.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/3-NeuralNetwok/AndrewNg_MechineLearning/ex3weights.mat -------------------------------------------------------------------------------- /4-SVM/AndrewNg_MechineLearning/data/emailSample1.txt: -------------------------------------------------------------------------------- 1 | > Anyone knows how much it costs to host a web portal ? 2 | > 3 | Well, it depends on how many visitors you're expecting. 4 | This can be anywhere from less than 10 bucks a month to a couple of $100. 5 | You should checkout http://www.rackspace.com/ or perhaps Amazon EC2 6 | if youre running something big.. 7 | 8 | To unsubscribe yourself from this mailing list, send an email to: 9 | groupname-unsubscribe@egroups.com 10 | 11 | -------------------------------------------------------------------------------- /4-SVM/AndrewNg_MechineLearning/data/emailSample2.txt: -------------------------------------------------------------------------------- 1 | Folks, 2 | 3 | my first time posting - have a bit of Unix experience, but am new to Linux. 4 | 5 | 6 | Just got a new PC at home - Dell box with Windows XP. Added a second hard disk 7 | for Linux. Partitioned the disk and have installed Suse 7.2 from CD, which went 8 | fine except it didn't pick up my monitor. 9 | 10 | I have a Dell branded E151FPp 15" LCD flat panel monitor and a nVidia GeForce4 11 | Ti4200 video card, both of which are probably too new to feature in Suse's default 12 | set. I downloaded a driver from the nVidia website and installed it using RPM. 13 | Then I ran Sax2 (as was recommended in some postings I found on the net), but 14 | it still doesn't feature my video card in the available list. What next? 15 | 16 | Another problem. I have a Dell branded keyboard and if I hit Caps-Lock twice, 17 | the whole machine crashes (in Linux, not Windows) - even the on/off switch is 18 | inactive, leaving me to reach for the power cable instead. 19 | 20 | If anyone can help me in any way with these probs., I'd be really grateful - 21 | I've searched the 'net but have run out of ideas. 22 | 23 | Or should I be going for a different version of Linux such as RedHat? Opinions 24 | welcome. 25 | 26 | Thanks a lot, 27 | Peter 28 | 29 | -- 30 | Irish Linux Users' Group: ilug@linux.ie 31 | http://www.linux.ie/mailman/listinfo/ilug for (un)subscription information. 32 | List maintainer: listmaster@linux.ie 33 | 34 | 35 | -------------------------------------------------------------------------------- /4-SVM/AndrewNg_MechineLearning/data/ex6data1.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/4-SVM/AndrewNg_MechineLearning/data/ex6data1.mat -------------------------------------------------------------------------------- /4-SVM/AndrewNg_MechineLearning/data/ex6data2.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/4-SVM/AndrewNg_MechineLearning/data/ex6data2.mat -------------------------------------------------------------------------------- /4-SVM/AndrewNg_MechineLearning/data/ex6data3.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/4-SVM/AndrewNg_MechineLearning/data/ex6data3.mat -------------------------------------------------------------------------------- /4-SVM/AndrewNg_MechineLearning/data/spamSample1.txt: -------------------------------------------------------------------------------- 1 | Do You Want To Make $1000 Or More Per Week? 2 | 3 | 4 | 5 | If you are a motivated and qualified individual - I 6 | will personally demonstrate to you a system that will 7 | make you $1,000 per week or more! This is NOT mlm. 8 | 9 | 10 | 11 | Call our 24 hour pre-recorded number to get the 12 | details. 13 | 14 | 15 | 16 | 000-456-789 17 | 18 | 19 | 20 | I need people who want to make serious money. Make 21 | the call and get the facts. 22 | 23 | Invest 2 minutes in yourself now! 24 | 25 | 26 | 27 | 000-456-789 28 | 29 | 30 | 31 | Looking forward to your call and I will introduce you 32 | to people like yourself who 33 | are currently making $10,000 plus per week! 34 | 35 | 36 | 37 | 000-456-789 38 | 39 | 40 | 41 | 3484lJGv6-241lEaN9080lRmS6-271WxHo7524qiyT5-438rjUv5615hQcf0-662eiDB9057dMtVl72 42 | 43 | -------------------------------------------------------------------------------- /4-SVM/AndrewNg_MechineLearning/data/spamSample2.txt: -------------------------------------------------------------------------------- 1 | Best Buy Viagra Generic Online 2 | 3 | Viagra 100mg x 60 Pills $125, Free Pills & Reorder Discount, Top Selling 100% Quality & Satisfaction guaranteed! 4 | 5 | We accept VISA, Master & E-Check Payments, 90000+ Satisfied Customers! 6 | http://medphysitcstech.ru 7 | 8 | 9 | -------------------------------------------------------------------------------- /4-SVM/AndrewNg_MechineLearning/data/spamTest.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/4-SVM/AndrewNg_MechineLearning/data/spamTest.mat -------------------------------------------------------------------------------- /4-SVM/AndrewNg_MechineLearning/data/spamTrain.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/4-SVM/AndrewNg_MechineLearning/data/spamTrain.mat -------------------------------------------------------------------------------- /4-SVM/AndrewNg_MechineLearning/ex6.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/4-SVM/AndrewNg_MechineLearning/ex6.pdf -------------------------------------------------------------------------------- /4-SVM/note/LSJU-SVM-01.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 第五部分：支持向量机\n", 8 | "\n", 9 | "接下来的几个掌机会介绍支持向量机学习算法（SVM），它通常被认为是最好的现成监督学习算法之一（很多人认为它是最好的）。为了详细介绍支持向量机，我们需要先了解间隔（margin）的概念，以及使用大间隙（gap）分割数据的想法。接着我们将介绍优化间隔分类器，进而讨论一下语言歧义（language duality）现象。然后介绍支持向量机的核心——如何在一个极高维特征值向量空间（比如无限维）上高效的应用支持向量机算法。最后我们将介绍序列最小优化算法（SMO: sequential minimal optimization）算法——一个更优化的支持向量机的实现。\n", 10 | "\n", 11 | "## 1. 间隔：直观概念\n", 12 | "\n", 13 | "我们从间隔开始讨论支持向量机算法，本节将给出“间隔”以及算法对预测的“信心”的直观概念，在第三节我们会进一步形式化这些概念。\n", 14 | "\n", 15 | "回顾前面的逻辑回归，假设函数的模型$h_\\theta(x)=g\\left(\\theta^Tx\\right)$将给出关于$p(y=1\\mid x;\\theta)$的概率预测。当且仅当$h_\\theta(x)\\geq 0.5$即输入满足$\\theta^Tx\\geq 0$时，模型给出关于输入的预测为$1$。对于一个正训练样本（即$y=1$），$\\theta^Tx$越大，则$h_\\theta(x)=p(y=1\\mid x;w,b)$，也就意味着我们将其预测为$1$的“信心”越高。因此，严谨的说，如果$\\theta^Tx\\gg 0$，则算法预测其为$1$的信心就会非常大。同样的，对于逻辑回归，如果$\\theta^Tx\\ll 0$，则算法预测其为$0$的信心就会非常大。对于给定的训练集，我们可以说，如果拟合参数$\\theta$能够使得所有$y^{(i)}=1$的样本满足$\\theta^Tx^{(i)}\\gg0$，使所有$y^{(i)}=0$的样本满足$y^{(i)}=0$，则称这是一个良好的拟合，因为这反映出该拟合对分类结果的“信心”很足。所以，“信心”是一个很好的指标，后面我们将使用函数间隔形式化这个指标。\n", 16 | "\n", 17 | "另一种直观的表达，如下图，其中x代表正训练样本，o代表负训练样本，直线就是判别边界（由$\\theta^Tx=0$给出，也叫**分类超平面（separating hyperplane）**）。\n", 18 | "\n", 19 | "\"\"\n", 20 | "\n", 21 | "图中的三个点A、B、C，点A距离判别边界非常远，如果求关于点A的预测，我们会非常确定其值为$y=1$。相反，点C距离判别边界很近，虽然它在判别边界$y=1$一侧，但是如果判别边界稍有变动，它就有可能被放在$y=0$一侧。因此，我们对点A预测的信心强于点C。而点B则在两者之间，通常来说，如果点距离判别边界越远，模型做出预测的信心就越强。也就是说，如果对于给定训练集，可以找到一条能够准确并可信（即样本距离边界很远）的预测所有训练样本的判别边界，则称这个拟合是良好的。我们在后面将使用几何间隔形式化这个概念。\n", 22 | "\n", 23 | "## 2. 标记法\n", 24 | "\n", 25 | "为了更加简洁的介绍支持向量机，我们需要先引入一种新的标记。考虑使用线性分类器解决“特征为$x$目标为$y$”的二元分类问题。这次，我们使用$y\\in\\{-1,1\\}$来标记两个分类（而不是之前的$y\\in\\{0,1\\}$），再使用参数向量$w,b$代替之前的参数向量$\\theta$，于是我们现在将分类器写为：\n", 26 | "\n", 27 | "$$h_{w,b}(x)=g\\left(w^Tx+b\\right)$$\n", 28 | "\n", 29 | "此处，$g(z)=\\begin{cases}1 &z\\gt 0\\\\-1 &z\\lt 0\\end{cases}$，而$w,b$的记法可以将截距项与特征值的系数分开来记（也不再向特征值向量$x$中添加$x_0=1$分量），即$b$用来代替原来的$\\theta_0$，而$w$用来代替原来的$\\begin{bmatrix}\\theta_1&\\cdots&\\theta_n\\end{bmatrix}^T$。\n", 30 | "\n", 31 | "还需要注意的是，根据函数$g$的定义，分类器将直接给出$-1$或$1$的结果（类似感知算法），省略了估计$y=1$的概率的步骤。\n", 32 | "\n", 33 | "## 3. 函数间隔及几何间隔\n", 34 | "\n", 35 | "本节将形式化函数间隔及几何间隔。对于给定的训练样本$\\left(x^{(i)},y^{(i)}\\right)$，我们定义关于此训练样本函数间隔的超平面$(w,b)$为：\n", 36 | "\n", 37 | "$$\\hat{\\gamma}^{(i)}=y^{(i)}\\left(w^Tx^{(i)}+b\\right)$$\n", 38 | "\n", 39 | "上式可以解释为，当$y^{(i)}=1$时，为了得到一个较大的函数间隔（即为了使预测有较高的的可信度及准确性），我们需要$w^Tx+b$取一个较大的正数（$w^Tx+b\\gg 0$）；反之，当$y^{(i)}=-1$时，我摸需要$w^Tx+b$取一个较大的负数（$w^Tx+b\\ll 0$）。此外，如果$y^{(i)}\\left(w^Tx+b\\right)\\gt 0$，则说明关于此样本的预测是正确的。因此，较大的函数间隔意味着较高的可信度和准确性。\n", 40 | "\n", 41 | "对于一个在$g\\in\\{-1,1\\}$取值的线性分类器，有一个性质导致其函数间隔不能有效的反映预测的可信度：对于给定的$g$，如果将$(w,b)$替换为$(2w,2b)$，即$g\\left(w^Tx+b\\right)$变为$g\\left(2w^Tx+2b\\right)$，我们会发现分类超平面$h_{w,b}(x)$并不会改变，也就是说$h_{w,b}(x)$只关心$w^Tx+b$的正负，而不关心其大小。但是将$(w,b)$变为$(2w,2b)$相当于给函数间隔乘了系数$2$，于是我们发现，如果通过改变$w,b$的取值，我们可以让函数间隔变得很大，然而分类超平面并没有改变，所以单纯的通过这种方式改变函数间隔的大小没有什么实质意义。直觉告诉我们，应该引入一种标准化条件，比如令$\\lVert w\\rVert_2=1$，即把$(w,b)$变为$\\left(\\frac{w}{\\lVert w\\rVert_2},\\frac{b}{\\lVert w\\rVert_2}\\right)$，我们在后面会继续讨论这种方法。\n", 42 | "\n", 43 | "对于给定的训练集$S=\\left\\{\\left(x^{(i)},y^{(i)}\\right);i=1,\\cdots,m\\right\\}$，关于$S$以$(w,b)$为参数的函数间隔$\\hat\\gamma$定义为取所以独立的训练样本中最小的那个函数间隔（即取最坏的一个样本的情况）：\n", 44 | "\n", 45 | "$$\\hat\\gamma=\\operatorname*{min}_{i=1,\\cdots,m}\\hat\\gamma^{(i)}$$\n", 46 | "\n", 47 | "接下来我们讨论几何间隔，考虑下图：\n", 48 | "\n", 49 | "\"\"\n", 50 | "\n", 51 | "直线为$(w,b)$确定的判定边界（即超平面$w^Tx+b=0$），向量$w$正交于分类超平面（在超平面上任取两点$P_1=(x_1,\\cdots,x_n), P_2==(x'_1,\\cdots,x'_n)$，则两点满足平面方程组$\\begin{cases}w^TP_1+b=0\\\\w^TP_2+b=0\\end{cases}$，两式相减得$w^T(P_1-P_2)=0$，即$w^T$正交于该超平面上任意向量，所以$w^T$为超平面法向量）。观察点$A$，设点$A$为训练样本$(x^{(i)},y^{(i)}=1)$，它到判定边界的距离$\\gamma^{(i)}$即为线段$AB$的长度。\n", 52 | "\n", 53 | "如何计算$\\gamma^{(i)}$？注意到$\\frac{w}{\\lVert w\\rVert}$是标准化后的$w$向量，点$A$为$x^{(i)}$，则点$B$为$x^{(i)}-\\gamma^{(i)}\\cdot\\frac{w}{\\lVert w\\rVert}$。点$B$在判定边界上，而判定边界上的所有点都满足方程$w^Tx+b=0$，则：\n", 54 | "\n", 55 | "$$w^T\\left(x^{(i)}-\\gamma^{(i)}\\frac{w}{\\lVert w\\rVert}\\right)+b=0$$\n", 56 | "\n", 57 | "解出$\\gamma^{(i)}$得：（注：$w^Tw=\\lVert w\\rVert^2$）\n", 58 | "\n", 59 | "$$\\gamma^{(i)}=\\frac{w^Tx^{(i)}+b}{\\lVert w\\rVert}=\\left(\\frac{w}{\\lVert w\\rVert}\\right)^Tx^{(i)}+\\frac{b}{\\lVert w\\rVert}$$\n", 60 | "\n", 61 | "这就是正训练样本$A$被正确的分在判别边界$y=1$一侧的情形，更一般的，我们定义关于样本$\\left(x^{(i)},y^{(i)}\\right)$以$(w,b)$为参数的函数间隔为：\n", 62 | "\n", 63 | "$$\\gamma^{(i)}=y^{(i)}\\left(\\left(\\frac{w}{\\lVert w\\rVert}\\right)^Tx^{(i)}+\\frac{b}{\\lVert w\\rVert}\\right)$$\n", 64 | "\n", 65 | "可以看出，如果$\\lVert w\\rVert=1$，则函数间隔等于几何间隔（$\\hat\\gamma^{(i)}=\\gamma^{(i)}$），这就是两种间隔的关系（$\\hat\\gamma^{(i)}=\\frac{\\gamma^{(i)}}{\\Vert w\\Vert}$）。与函数间隔一样，如果改变参数$(w,b)$为$(2w,2b)$，则几何间隔不会改变。这个性质在后面会很方便，利用改变参数$(w,b)$的大小不影响间隔，我们可以在拟合参数时引入$w$的限制条件，比如令$\\lVert w\\rVert=1$，或$\\lvert w_1\\rvert=5$，或$\\lvert w+b\\rvert+\\lvert b\\rvert=2$，诸如这种限制条件都可以通过给参数$(w,b)$乘以一个适当的系数得到。\n", 66 | "\n", 67 | "对于给定的训练集$S=\\left\\{\\left(x^{(i)},y^{(i)}\\right);i=1,\\cdots,m\\right\\}$，也有关于$S$以$(w,b)$为参数的几何间隔$\\gamma$定义为取所以独立的训练样本中最小的那个几何间隔（即取最坏的一个样本的情况）：\n", 68 | "\n", 69 | "$$\\gamma=\\operatorname*{min}_{i=1,\\cdots,m}\\gamma^{(i)}$$\n", 70 | "\n", 71 | "另外，几何间隔实际上就是点到超平面的距离，高中时学过的点$\\left(x^{(i)},y^{(i)}\\right)$到直线$ax+by+c=0$的距离为：\n", 72 | "\n", 73 | "$$d\\left(x^{(i)},y^{(i)}\\right)=\\frac{\\lvert ax^{(i)}+by^{(i)}+c\\rvert}{\\sqrt{a^2+b^2}}$$\n", 74 | "\n", 75 | "推广到高维就是上面的几何间隔，而函数间隔就是未标准化的几何间隔。\n", 76 | "\n", 77 | "最后，最大间隔分类器（maximum margin classifier，可以被看做是支持向量机的前身），实际上就选择特定的$w,b$使几何间隔最大化：\n", 78 | "\n", 79 | "$$\\begin{align}\\displaystyle\\operatorname*{max}_{w,b}&\\quad\\gamma\\\\\\mathrm{s.t.}&\\quad y^{(i)}\\left(\\left(\\frac{w}{\\lVert w\\rVert}\\right)^Tx^{(i)}+\\frac{b}{\\lVert w\\rVert}\\right)\\end{align}$$\n", 80 | "\n", 81 | "注：$\\mathrm{s.t.}$是“subject to”的缩写，意为“受限于”。" 82 | ] 83 | } 84 | ], 85 | "metadata": { 86 | "kernelspec": { 87 | "display_name": "Python 2", 88 | "language": "python", 89 | "name": "python2" 90 | }, 91 | "language_info": { 92 | "codemirror_mode": { 93 | "name": "ipython", 94 | "version": 2 95 | }, 96 | "file_extension": ".py", 97 | "mimetype": "text/x-python", 98 | "name": "python", 99 | "nbconvert_exporter": "python", 100 | "pygments_lexer": "ipython2", 101 | "version": "2.7.13" 102 | } 103 | }, 104 | "nbformat": 4, 105 | "nbformat_minor": 2 106 | } 107 | -------------------------------------------------------------------------------- /5-K-Means/note/NOTE-K-Means.md: -------------------------------------------------------------------------------- 1 | ## 五、K-Means聚类算法 2 | - [全部代码](../../code/5-K-Means/K-Means.py) 3 | 4 | ### 1、聚类过程 5 | - 聚类属于无监督学习，不知道y的标记分为K类 6 | - K-Means算法分为两个步骤 7 | - 第一步：簇分配，随机选`K`个点作为中心，计算到这`K`个点的距离，分为`K`个簇 8 | - 第二步：移动聚类中心：重新计算每个**簇**的中心，移动中心，重复以上步骤。 9 | - 如下图所示： 10 | - 随机分配的聚类中心 11 | ![enter description here](../../images/K-Means_01.png) 12 | - 重新计算聚类中心，移动一次 13 | ![enter description here][35] 14 | - 最后`10`步之后的聚类中心 15 | ![enter description here][36] 16 | 17 | - 计算每条数据到哪个中心最近实现代码： 18 | ``` 19 | # 找到每条数据距离哪个类中心最近 20 | def findClosestCentroids(X,initial_centroids): 21 | m = X.shape[0] # 数据条数 22 | K = initial_centroids.shape[0] # 类的总数 23 | dis = np.zeros((m,K)) # 存储计算每个点分别到K个类的距离 24 | idx = np.zeros((m,1)) # 要返回的每条数据属于哪个类 25 | 26 | '''计算每个点到每个类中心的距离''' 27 | for i in range(m): 28 | for j in range(K): 29 | dis[i,j] = np.dot((X[i,:]-initial_centroids[j,:]).reshape(1,-1),(X[i,:]-initial_centroids[j,:]).reshape(-1,1)) 30 | 31 | '''返回dis每一行的最小值对应的列号，即为对应的类别 32 | - np.min(dis, axis=1)返回每一行的最小值 33 | - np.where(dis == np.min(dis, axis=1).reshape(-1,1)) 返回对应最小值的坐标 34 | - 注意：可能最小值对应的坐标有多个，where都会找出来，所以返回时返回前m个需要的即可（因为对于多个最小值，属于哪个类别都可以） 35 | ''' 36 | dummy,idx = np.where(dis == np.min(dis, axis=1).reshape(-1,1)) 37 | return idx[0:dis.shape[0]] # 注意截取一下 38 | ``` 39 | - 计算类中心实现代码： 40 | ``` 41 | # 计算类中心 42 | def computerCentroids(X,idx,K): 43 | n = X.shape[1] 44 | centroids = np.zeros((K,n)) 45 | for i in range(K): 46 | centroids[i,:] = np.mean(X[np.ravel(idx==i),:], axis=0).reshape(1,-1) # 索引要是一维的,axis=0为每一列，idx==i一次找出属于哪一类的，然后计算均值 47 | return centroids 48 | ``` 49 | 50 | ### 2、目标函数 51 | - 也叫做**失真代价函数** 52 | - ![J({c^{(1)}}, \cdots ,{c^{(m)}},{u_1}, \cdots ,{u_k}) = \frac{1}{m}\sum\limits_{i = 1}^m {||{x^{(i)}} - {u_{{c^{(i)}}}}|{|^2}} ](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=J%28%7Bc%5E%7B%281%29%7D%7D%2C%20%5Ccdots%20%2C%7Bc%5E%7B%28m%29%7D%7D%2C%7Bu_1%7D%2C%20%5Ccdots%20%2C%7Bu_k%7D%29%20%3D%20%5Cfrac%7B1%7D%7Bm%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%7C%7C%7Bx%5E%7B%28i%29%7D%7D%20-%20%7Bu_%7B%7Bc%5E%7B%28i%29%7D%7D%7D%7D%7C%7B%7C%5E2%7D%7D%20) 53 | - 最后我们想得到： 54 | ![enter description here][37] 55 | - 其中![{c^{(i)}}](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7Bc%5E%7B%28i%29%7D%7D)表示第`i`条数据距离哪个类中心最近， 56 | - 其中![{u_i}](http://chart.apis.google.com/chart?cht=tx&chs=1x0&chf=bg,s,FFFFFF00&chco=000000&chl=%7Bu_i%7D)即为聚类的中心 57 | 58 | ### 3、聚类中心的选择 59 | - 随机初始化，从给定的数据中随机抽取K个作为聚类中心 60 | - 随机一次的结果可能不好，可以随机多次，最后取使代价函数最小的作为中心 61 | - 实现代码：(这里随机一次) 62 | ``` 63 | # 初始化类中心--随机取K个点作为聚类中心 64 | def kMeansInitCentroids(X,K): 65 | m = X.shape[0] 66 | m_arr = np.arange(0,m) # 生成0-m-1 67 | centroids = np.zeros((K,X.shape[1])) 68 | np.random.shuffle(m_arr) # 打乱m_arr顺序 69 | rand_indices = m_arr[:K] # 取前K个 70 | centroids = X[rand_indices,:] 71 | return centroids 72 | ``` 73 | 74 | ### 4、聚类个数K的选择 75 | - 聚类是不知道y的label的，所以不知道真正的聚类个数 76 | - 肘部法则（Elbow method） 77 | - 作代价函数`J`和`K`的图，若是出现一个拐点，如下图所示，`K`就取拐点处的值，下图此时`K=3` 78 | ![enter description here][38] 79 | - 若是很平滑就不明确，人为选择。 80 | - 第二种就是人为观察选择 81 | 82 | ### 5、应用——图片压缩 83 | - 将图片的像素分为若干类，然后用这个类代替原来的像素值 84 | - 执行聚类的算法代码： 85 | ``` 86 | # 聚类算法 87 | def runKMeans(X,initial_centroids,max_iters,plot_process): 88 | m,n = X.shape # 数据条数和维度 89 | K = initial_centroids.shape[0] # 类数 90 | centroids = initial_centroids # 记录当前类中心 91 | previous_centroids = centroids # 记录上一次类中心 92 | idx = np.zeros((m,1)) # 每条数据属于哪个类 93 | 94 | for i in range(max_iters): # 迭代次数 95 | print u'迭代计算次数：%d'%(i+1) 96 | idx = findClosestCentroids(X, centroids) 97 | if plot_process: # 如果绘制图像 98 | plt = plotProcessKMeans(X,centroids,previous_centroids) # 画聚类中心的移动过程 99 | previous_centroids = centroids # 重置 100 | centroids = computerCentroids(X, idx, K) # 重新计算类中心 101 | if plot_process: # 显示最终的绘制结果 102 | plt.show() 103 | return centroids,idx # 返回聚类中心和数据属于哪个类 104 | ``` 105 | 106 | ### 6、使用scikit-learn库中的线性模型实现聚类 107 | - [全部代码](../../code/5-K-Means/K-Means_scikit-learn.py) 108 | 109 | - 导入包 110 | ``` 111 | from sklearn.cluster import KMeans 112 | ``` 113 | - 使用模型拟合数据 114 | ``` 115 | model = KMeans(n_clusters=3).fit(X) # n_clusters指定3类，拟合数据 116 | ``` 117 | - 聚类中心 118 | ``` 119 | centroids = model.cluster_centers_ # 聚类中心 120 | ``` 121 | 122 | ### 7、运行结果 123 | - 二维数据类中心的移动 124 | ![enter description here][39] 125 | - 图片压缩 126 | ![enter description here][40] 127 | 128 | 129 | ---------------------- 130 | 131 | [34]: ../../images/K-Means_01.png "K-Means_01.png" 132 | [35]: ../../images/K-Means_02.png "K-Means_02.png" 133 | [36]: ../../images/K-Means_03.png "K-Means_03.png" 134 | [37]: ../../images/K-Means_07.png "K-Means_07.png" 135 | [38]: ../../images/K-Means_04.png "K-Means_04.png" 136 | [39]: ../../images/K-Means_05.png "K-Means_05.png" 137 | [40]: ../../images/K-Means_06.png "K-Means_06.png" 138 | 139 | -------------------------------------------------------------------------------- /6-PCA/NOTE-PCA.md: -------------------------------------------------------------------------------- 1 | ## 六、PCA主成分分析（降维） 2 | - [全部代码](../code/6-PCA/PCA.py) 3 | 4 | ### 1、用处 5 | - 数据压缩（Data Compression）,使程序运行更快 6 | - 可视化数据，例如`3D-->2D`等 7 | - ...... 8 | 9 | ### 2、2D-->1D，nD-->kD 10 | - 如下图所示，所有数据点可以投影到一条直线，是**投影距离的平方和**（投影误差）最小 11 | ![enter description here][41] 12 | - 注意数据需要`归一化`处理 13 | - 思路是找`1`个`向量u`,所有数据投影到上面使投影距离最小 14 | - 那么`nD-->kD`就是找`k`个向量![$${u^{(1)}},{u^{(2)}} \ldots {u^{(k)}}$$](http://latex.codecogs.com/gif.latex?%24%24%7Bu%5E%7B%281%29%7D%7D%2C%7Bu%5E%7B%282%29%7D%7D%20%5Cldots%20%7Bu%5E%7B%28k%29%7D%7D%24%24)，所有数据投影到上面使投影误差最小 15 | - eg:3D-->2D,2个向量![$${u^{(1)}},{u^{(2)}}$$](http://latex.codecogs.com/gif.latex?%24%24%7Bu%5E%7B%281%29%7D%7D%2C%7Bu%5E%7B%282%29%7D%7D%24%24)就代表一个平面了，所有点投影到这个平面的投影误差最小即可 16 | 17 | ### 3、主成分分析PCA与线性回归的区别 18 | - 线性回归是找`x`与`y`的关系，然后用于预测`y` 19 | - `PCA`是找一个投影面，最小化data到这个投影面的投影误差 20 | 21 | ### 4、PCA降维过程 22 | - 数据预处理（均值归一化） 23 | - 公式：![$${\rm{x}}_j^{(i)} = {{{\rm{x}}_j^{(i)} - {u_j}} \over {{s_j}}}$$](http://latex.codecogs.com/gif.latex?%24%24%7B%5Crm%7Bx%7D%7D_j%5E%7B%28i%29%7D%20%3D%20%7B%7B%7B%5Crm%7Bx%7D%7D_j%5E%7B%28i%29%7D%20-%20%7Bu_j%7D%7D%20%5Cover%20%7B%7Bs_j%7D%7D%7D%24%24) 24 | - 就是减去对应feature的均值，然后除以对应特征的标准差（也可以是最大值-最小值） 25 | - 实现代码： 26 | ``` 27 | # 归一化数据 28 | def featureNormalize(X): 29 | '''（每一个数据-当前列的均值）/当前列的标准差''' 30 | n = X.shape[1] 31 | mu = np.zeros((1,n)); 32 | sigma = np.zeros((1,n)) 33 | 34 | mu = np.mean(X,axis=0) 35 | sigma = np.std(X,axis=0) 36 | for i in range(n): 37 | X[:,i] = (X[:,i]-mu[i])/sigma[i] 38 | return X,mu,sigma 39 | ``` 40 | - 计算`协方差矩阵Σ`（Covariance Matrix）：![$$\Sigma = {1 \over m}\sum\limits_{i = 1}^n {{x^{(i)}}{{({x^{(i)}})}^T}} $$](http://latex.codecogs.com/gif.latex?%24%24%5CSigma%20%3D%20%7B1%20%5Cover%20m%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5En%20%7B%7Bx%5E%7B%28i%29%7D%7D%7B%7B%28%7Bx%5E%7B%28i%29%7D%7D%29%7D%5ET%7D%7D%20%24%24) 41 | - 注意这里的`Σ`和求和符号不同 42 | - 协方差矩阵`对称正定`（不理解正定的看看线代） 43 | - 大小为`nxn`,`n`为`feature`的维度 44 | - 实现代码： 45 | ``` 46 | Sigma = np.dot(np.transpose(X_norm),X_norm)/m # 求Sigma 47 | ``` 48 | - 计算`Σ`的特征值和特征向量 49 | - 可以是用`svd`奇异值分解函数：`U,S,V = svd(Σ)` 50 | - 返回的是与`Σ`同样大小的对角阵`S`（由`Σ`的特征值组成）[**注意**：`matlab`中函数返回的是对角阵，在`python`中返回的是一个向量，节省空间] 51 | - 还有两个**酉矩阵**U和V，且![$$\Sigma = US{V^T}$$](http://latex.codecogs.com/gif.latex?%24%24%5CSigma%20%3D%20US%7BV%5ET%7D%24%24) 52 | - ![enter description here][42] 53 | - **注意**：`svd`函数求出的`S`是按特征值降序排列的，若不是使用`svd`,需要按**特征值**大小重新排列`U` 54 | - 降维 55 | - 选取`U`中的前`K`列（假设要降为`K`维） 56 | - ![enter description here][43] 57 | - `Z`就是对应降维之后的数据 58 | - 实现代码： 59 | ``` 60 | # 映射数据 61 | def projectData(X_norm,U,K): 62 | Z = np.zeros((X_norm.shape[0],K)) 63 | 64 | U_reduce = U[:,0:K] # 取前K个 65 | Z = np.dot(X_norm,U_reduce) 66 | return Z 67 | ``` 68 | - 过程总结： 69 | - `Sigma = X'*X/m` 70 | - `U,S,V = svd(Sigma)` 71 | - `Ureduce = U[:,0:k]` 72 | - `Z = Ureduce'*x` 73 | 74 | ### 5、数据恢复 75 | - 因为：![$${Z^{(i)}} = U_{reduce}^T*{X^{(i)}}$$](http://latex.codecogs.com/gif.latex?%5Cfn_cm%20%24%24%7BZ%5E%7B%28i%29%7D%7D%20%3D%20U_%7Breduce%7D%5ET*%7BX%5E%7B%28i%29%7D%7D%24%24) 76 | - 所以：![$${X_{approx}} = {(U_{reduce}^T)^{ - 1}}Z$$](http://latex.codecogs.com/gif.latex?%5Cfn_cm%20%24%24%7BX_%7Bapprox%7D%7D%20%3D%20%7B%28U_%7Breduce%7D%5ET%29%5E%7B%20-%201%7D%7DZ%24%24) （注意这里是X的近似值） 77 | - 又因为`Ureduce`为正定矩阵，【正定矩阵满足：![$$A{A^T} = {A^T}A = E$$](http://latex.codecogs.com/gif.latex?%5Cfn_cm%20%24%24A%7BA%5ET%7D%20%3D%20%7BA%5ET%7DA%20%3D%20E%24%24)，所以：![$${A^{ - 1}} = {A^T}$$](http://latex.codecogs.com/gif.latex?%5Cfn_cm%20%24%24%7BA%5E%7B%20-%201%7D%7D%20%3D%20%7BA%5ET%7D%24%24)】，所以这里： 78 | - ![$${X_{approx}} = {(U_{reduce}^{ - 1})^{ - 1}}Z = {U_{reduce}}Z$$](http://latex.codecogs.com/gif.latex?%5Cfn_cm%20%24%24%7BX_%7Bapprox%7D%7D%20%3D%20%7B%28U_%7Breduce%7D%5E%7B%20-%201%7D%29%5E%7B%20-%201%7D%7DZ%20%3D%20%7BU_%7Breduce%7D%7DZ%24%24) 79 | - 实现代码： 80 | ``` 81 | # 恢复数据 82 | def recoverData(Z,U,K): 83 | X_rec = np.zeros((Z.shape[0],U.shape[0])) 84 | U_recude = U[:,0:K] 85 | X_rec = np.dot(Z,np.transpose(U_recude)) # 还原数据（近似） 86 | return X_rec 87 | ``` 88 | 89 | ### 6、主成分个数的选择（即要降的维度） 90 | - 如何选择 91 | - **投影误差**（project error）：![$${1 \over m}\sum\limits_{i = 1}^m {||{x^{(i)}} - x_{approx}^{(i)}|{|^2}} $$](http://latex.codecogs.com/gif.latex?%5Cfn_cm%20%24%24%7B1%20%5Cover%20m%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%7C%7C%7Bx%5E%7B%28i%29%7D%7D%20-%20x_%7Bapprox%7D%5E%7B%28i%29%7D%7C%7B%7C%5E2%7D%7D%20%24%24) 92 | - **总变差**（total variation）:![$${1 \over m}\sum\limits_{i = 1}^m {||{x^{(i)}}|{|^2}} $$](http://latex.codecogs.com/gif.latex?%5Cfn_cm%20%24%24%7B1%20%5Cover%20m%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%7C%7C%7Bx%5E%7B%28i%29%7D%7D%7C%7B%7C%5E2%7D%7D%20%24%24) 93 | - 若**误差率**（error ratio）：![$${{{1 \over m}\sum\limits_{i = 1}^m {||{x^{(i)}} - x_{approx}^{(i)}|{|^2}} } \over {{1 \over m}\sum\limits_{i = 1}^m {||{x^{(i)}}|{|^2}} }} \le 0.01$$](http://latex.codecogs.com/gif.latex?%5Cfn_cm%20%24%24%7B%7B%7B1%20%5Cover%20m%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%7C%7C%7Bx%5E%7B%28i%29%7D%7D%20-%20x_%7Bapprox%7D%5E%7B%28i%29%7D%7C%7B%7C%5E2%7D%7D%20%7D%20%5Cover%20%7B%7B1%20%5Cover%20m%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%7C%7C%7Bx%5E%7B%28i%29%7D%7D%7C%7B%7C%5E2%7D%7D%20%7D%7D%20%5Cle%200.01%24%24)，则称`99%`保留差异性 94 | - 误差率一般取`1%，5%，10%`等 95 | - 如何实现 96 | - 若是一个个试的话代价太大 97 | - 之前`U,S,V = svd(Sigma)`,我们得到了`S`，这里误差率error ratio: 98 | ![$$error{\kern 1pt} \;ratio = 1 - {{\sum\limits_{i = 1}^k {{S_{ii}}} } \over {\sum\limits_{i = 1}^n {{S_{ii}}} }} \le threshold$$](http://latex.codecogs.com/gif.latex?%5Cfn_cm%20%24%24error%7B%5Ckern%201pt%7D%20%5C%3Bratio%20%3D%201%20-%20%7B%7B%5Csum%5Climits_%7Bi%20%3D%201%7D%5Ek%20%7B%7BS_%7Bii%7D%7D%7D%20%7D%20%5Cover%20%7B%5Csum%5Climits_%7Bi%20%3D%201%7D%5En%20%7B%7BS_%7Bii%7D%7D%7D%20%7D%7D%20%5Cle%20threshold%24%24) 99 | - 可以一点点增加`K`尝试。 100 | 101 | ### 7、使用建议 102 | - 不要使用PCA去解决过拟合问题`Overfitting`，还是使用正则化的方法（如果保留了很高的差异性还是可以的） 103 | - 只有在原数据上有好的结果，但是运行很慢，才考虑使用PCA 104 | 105 | ### 8、运行结果 106 | - 2维数据降为1维 107 | - 要投影的方向 108 | ![enter description here][44] 109 | - 2D降为1D及对应关系 110 | ![enter description here][45] 111 | - 人脸数据降维 112 | - 原始数据 113 | ![enter description here][46] 114 | - 可视化部分`U`矩阵信息 115 | ![enter description here][47] 116 | - 恢复数据 117 | ![enter description here][48] 118 | 119 | ### 9、使用scikit-learn库中的PCA实现降维 120 | - [全部代码](../code/6-PCA/PCA.py_scikit-learn.py) 121 | - 导入需要的包： 122 | ``` 123 | #-*- coding: utf-8 -*- 124 | # Author:bob 125 | # Date:2016.12.22 126 | import numpy as np 127 | from matplotlib import pyplot as plt 128 | from scipy import io as spio 129 | from sklearn.decomposition import pca 130 | from sklearn.preprocessing import StandardScaler 131 | ``` 132 | - 归一化数据 133 | ``` 134 | '''归一化数据并作图''' 135 | scaler = StandardScaler() 136 | scaler.fit(X) 137 | x_train = scaler.transform(X) 138 | ``` 139 | - 使用PCA模型拟合数据，并降维 140 | - `n_components`对应要将的维度 141 | ``` 142 | '''拟合数据''' 143 | K=1 # 要降的维度 144 | model = pca.PCA(n_components=K).fit(x_train) # 拟合数据，n_components定义要降的维度 145 | Z = model.transform(x_train) # transform就会执行降维操作 146 | ``` 147 | 148 | - 数据恢复 149 | - `model.components_`会得到降维使用的`U`矩阵 150 | ``` 151 | '''数据恢复并作图''' 152 | Ureduce = model.components_ # 得到降维用的Ureduce 153 | x_rec = np.dot(Z,Ureduce) # 数据恢复 154 | ``` 155 | 156 | 157 | 158 | --------------------------------------------------------------- 159 | 160 | 161 | [41]: ./../images/PCA_01.png "PCA_01.png" 162 | [42]: ./../images/PCA_02.png "PCA_02.png" 163 | [43]: ./../images/PCA_03.png "PCA_03.png" 164 | [44]: ./../images/PCA_04.png "PCA_04.png" 165 | [45]: ./../images/PCA_05.png "PCA_05.png" 166 | [46]: ./../images/PCA_06.png "PCA_06.png" 167 | [47]: ./../images/PCA_07.png "PCA_07.png" 168 | [48]: ./../images/PCA_08.png "PCA_08.png" 169 | 170 | -------------------------------------------------------------------------------- /7-AnomalyDetection/note/NOTE-anomaly_detection.md: -------------------------------------------------------------------------------- 1 | ## 七、异常检测 Anomaly Detection 2 | - [全部代码](../../code/7-AnomalyDetection/AnomalyDetection.py) 3 | 4 | ### 1、高斯分布（正态分布）`Gaussian distribution` 5 | - 分布函数：![$$p(x) = {1 \over {\sqrt {2\pi } \sigma }}{e^{ - {{{{(x - u)}^2}} \over {2{\sigma ^2}}}}}$$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24p%28x%29%20%3D%20%7B1%20%5Cover%20%7B%5Csqrt%20%7B2%5Cpi%20%7D%20%5Csigma%20%7D%7D%7Be%5E%7B%20-%20%7B%7B%7B%7B%28x%20-%20u%29%7D%5E2%7D%7D%20%5Cover%20%7B2%7B%5Csigma%20%5E2%7D%7D%7D%7D%7D%24%24) 6 | - 其中，`u`为数据的**均值**，`σ`为数据的**标准差** 7 | - `σ`越**小**，对应的图像越**尖** 8 | - 参数估计（`parameter estimation`） 9 | - ![$$u = {1 \over m}\sum\limits_{i = 1}^m {{x^{(i)}}} $$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24u%20%3D%20%7B1%20%5Cover%20m%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%7Bx%5E%7B%28i%29%7D%7D%7D%20%24%24) 10 | - ![$${\sigma ^2} = {1 \over m}\sum\limits_{i = 1}^m {{{({x^{(i)}} - u)}^2}} $$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24%7B%5Csigma%20%5E2%7D%20%3D%20%7B1%20%5Cover%20m%7D%5Csum%5Climits_%7Bi%20%3D%201%7D%5Em%20%7B%7B%7B%28%7Bx%5E%7B%28i%29%7D%7D%20-%20u%29%7D%5E2%7D%7D%20%24%24) 11 | 12 | ### 2、异常检测算法 13 | - 例子 14 | - 训练集：![$$\{ {x^{(1)}},{x^{(2)}}, \cdots {x^{(m)}}\} $$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24%5C%7B%20%7Bx%5E%7B%281%29%7D%7D%2C%7Bx%5E%7B%282%29%7D%7D%2C%20%5Ccdots%20%7Bx%5E%7B%28m%29%7D%7D%5C%7D%20%24%24),其中![$$x \in {R^n}$$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24x%20%5Cin%20%7BR%5En%7D%24%24) 15 | - 假设![$${x_1},{x_2} \cdots {x_n}$$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24%7Bx_1%7D%2C%7Bx_2%7D%20%5Ccdots%20%7Bx_n%7D%24%24)相互独立，建立model模型：![$$p(x) = p({x_1};{u_1},\sigma _1^2)p({x_2};{u_2},\sigma _2^2) \cdots p({x_n};{u_n},\sigma _n^2) = \prod\limits_{j = 1}^n {p({x_j};{u_j},\sigma _j^2)} $$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24p%28x%29%20%3D%20p%28%7Bx_1%7D%3B%7Bu_1%7D%2C%5Csigma%20_1%5E2%29p%28%7Bx_2%7D%3B%7Bu_2%7D%2C%5Csigma%20_2%5E2%29%20%5Ccdots%20p%28%7Bx_n%7D%3B%7Bu_n%7D%2C%5Csigma%20_n%5E2%29%20%3D%20%5Cprod%5Climits_%7Bj%20%3D%201%7D%5En%20%7Bp%28%7Bx_j%7D%3B%7Bu_j%7D%2C%5Csigma%20_j%5E2%29%7D%20%24%24) 16 | - 过程 17 | - 选择具有代表异常的`feature`:xi 18 | - 参数估计：![$${u_1},{u_2}, \cdots ,{u_n};\sigma _1^2,\sigma _2^2 \cdots ,\sigma _n^2$$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24%7Bu_1%7D%2C%7Bu_2%7D%2C%20%5Ccdots%20%2C%7Bu_n%7D%3B%5Csigma%20_1%5E2%2C%5Csigma%20_2%5E2%20%5Ccdots%20%2C%5Csigma%20_n%5E2%24%24) 19 | - 计算`p(x)`,若是`P(x)<ε`则认为异常，其中`ε`为我们要求的概率的临界值`threshold` 20 | - 这里只是**单元高斯分布**，假设了`feature`之间是独立的，下面会讲到**多元高斯分布**，会自动捕捉到`feature`之间的关系 21 | - **参数估计**实现代码 22 | ``` 23 | # 参数估计函数（就是求均值和方差） 24 | def estimateGaussian(X): 25 | m,n = X.shape 26 | mu = np.zeros((n,1)) 27 | sigma2 = np.zeros((n,1)) 28 | 29 | mu = np.mean(X, axis=0) # axis=0表示列，每列的均值 30 | sigma2 = np.var(X,axis=0) # 求每列的方差 31 | return mu,sigma2 32 | ``` 33 | 34 | ### 3、评价`p(x)`的好坏，以及`ε`的选取 35 | - 对**偏斜数据**的错误度量 36 | - 因为数据可能是非常**偏斜**的（就是`y=1`的个数非常少，(`y=1`表示异常)），所以可以使用`Precision/Recall`，计算`F1Score`(在**CV交叉验证集**上) 37 | - 例如：预测癌症，假设模型可以得到`99%`能够预测正确，`1%`的错误率，但是实际癌症的概率很小，只有`0.5%`，那么我们始终预测没有癌症y=0反而可以得到更小的错误率。使用`error rate`来评估就不科学了。 38 | - 如下图记录： 39 | ![enter description here][49] 40 | - ![$$\Pr ecision = {{TP} \over {TP + FP}}$$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24%5CPr%20ecision%20%3D%20%7B%7BTP%7D%20%5Cover%20%7BTP%20+%20FP%7D%7D%24%24) ，即：**正确预测正样本/所有预测正样本** 41 | - ![$${\mathop{\rm Re}\nolimits} {\rm{call}} = {{TP} \over {TP + FN}}$$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24%7B%5Cmathop%7B%5Crm%20Re%7D%5Cnolimits%7D%20%7B%5Crm%7Bcall%7D%7D%20%3D%20%7B%7BTP%7D%20%5Cover%20%7BTP%20+%20FN%7D%7D%24%24) ，即：**正确预测正样本/真实值为正样本** 42 | - 总是让`y=1`(较少的类)，计算`Precision`和`Recall` 43 | - ![$${F_1}Score = 2{{PR} \over {P + R}}$$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24%7BF_1%7DScore%20%3D%202%7B%7BPR%7D%20%5Cover%20%7BP%20+%20R%7D%7D%24%24) 44 | - 还是以癌症预测为例，假设预测都是no-cancer，TN=199，FN=1，TP=0，FP=0，所以：Precision=0/0，Recall=0/1=0，尽管accuracy=199/200=99.5%，但是不可信。 45 | 46 | - `ε`的选取 47 | - 尝试多个`ε`值，使`F1Score`的值高 48 | - 实现代码 49 | ``` 50 | # 选择最优的epsilon，即：使F1Score最大 51 | def selectThreshold(yval,pval): 52 | '''初始化所需变量''' 53 | bestEpsilon = 0. 54 | bestF1 = 0. 55 | F1 = 0. 56 | step = (np.max(pval)-np.min(pval))/1000 57 | '''计算''' 58 | for epsilon in np.arange(np.min(pval),np.max(pval),step): 59 | cvPrecision = pval bestF1: # 修改最优的F1 Score 67 | bestF1 = F1 68 | bestEpsilon = epsilon 69 | return bestEpsilon,bestF1 70 | ``` 71 | 72 | ### 4、选择使用什么样的feature（单元高斯分布） 73 | - 如果一些数据不是满足高斯分布的，可以变化一下数据，例如`log(x+C),x^(1/2)`等 74 | - 如果`p(x)`的值无论异常与否都很大，可以尝试组合多个`feature`,(因为feature之间可能是有关系的) 75 | 76 | ### 5、多元高斯分布 77 | - 单元高斯分布存在的问题 78 | - 如下图，红色的点为异常点，其他的都是正常点（比如CPU和memory的变化） 79 | ![enter description here][50] 80 | - x1对应的高斯分布如下： 81 | ![enter description here][51] 82 | - x2对应的高斯分布如下： 83 | ![enter description here][52] 84 | - 可以看出对应的p(x1)和p(x2)的值变化并不大，就不会认为异常 85 | - 因为我们认为feature之间是相互独立的，所以如上图是以**正圆**的方式扩展 86 | - 多元高斯分布 87 | - ![$$x \in {R^n}$$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24x%20%5Cin%20%7BR%5En%7D%24%24)，并不是建立`p(x1),p(x2)...p(xn)`，而是统一建立`p(x)` 88 | - 其中参数：![$$\mu \in {R^n},\Sigma \in {R^{n \times {\rm{n}}}}$$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24%5Cmu%20%5Cin%20%7BR%5En%7D%2C%5CSigma%20%5Cin%20%7BR%5E%7Bn%20%5Ctimes%20%7B%5Crm%7Bn%7D%7D%7D%7D%24%24),`Σ`为**协方差矩阵** 89 | - ![$$p(x) = {1 \over {{{(2\pi )}^{{n \over 2}}}|\Sigma {|^{{1 \over 2}}}}}{e^{ - {1 \over 2}{{(x - u)}^T}{\Sigma ^{ - 1}}(x - u)}}$$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24p%28x%29%20%3D%20%7B1%20%5Cover%20%7B%7B%7B%282%5Cpi%20%29%7D%5E%7B%7Bn%20%5Cover%202%7D%7D%7D%7C%5CSigma%20%7B%7C%5E%7B%7B1%20%5Cover%202%7D%7D%7D%7D%7D%7Be%5E%7B%20-%20%7B1%20%5Cover%202%7D%7B%7B%28x%20-%20u%29%7D%5ET%7D%7B%5CSigma%20%5E%7B%20-%201%7D%7D%28x%20-%20u%29%7D%7D%24%24) 90 | - 同样，`|Σ|`越小，`p(x)`越尖 91 | - 例如： 92 | ![enter description here][53]， 93 | 表示x1,x2**正相关**，即x1越大，x2也就越大，如下图，也就可以将红色的异常点检查出了 94 | ![enter description here][54] 95 | 若： 96 | ![enter description here][55]， 97 | 表示x1,x2**负相关** 98 | - 实现代码： 99 | ``` 100 | # 多元高斯分布函数 101 | def multivariateGaussian(X,mu,Sigma2): 102 | k = len(mu) 103 | if (Sigma2.shape[0]>1): 104 | Sigma2 = np.diag(Sigma2) 105 | '''多元高斯分布函数''' 106 | X = X-mu 107 | argu = (2*np.pi)**(-k/2)*np.linalg.det(Sigma2)**(-0.5) 108 | p = argu*np.exp(-0.5*np.sum(np.dot(X,np.linalg.inv(Sigma2))*X,axis=1)) # axis表示每行 109 | return p 110 | ``` 111 | ### 6、单元和多元高斯分布特点 112 | - 单元高斯分布 113 | - 人为可以捕捉到`feature`之间的关系时可以使用 114 | - 计算量小 115 | - 多元高斯分布 116 | - 自动捕捉到相关的feature 117 | - 计算量大，因为：![$$\Sigma \in {R^{n \times {\rm{n}}}}$$](http://latex.codecogs.com/png.latex?%5Cfn_cm%20%24%24%5CSigma%20%5Cin%20%7BR%5E%7Bn%20%5Ctimes%20%7B%5Crm%7Bn%7D%7D%7D%7D%24%24) 118 | - `m>n`或`Σ`可逆时可以使用。（若不可逆，可能有冗余的x，因为线性相关，不可逆，或者就是m 0.5: # 概率大于0.5预测为1，否则预测为0 138 | p[i] = 1 139 | else: 140 | p[i] = 0 141 | return p 142 | 143 | 144 | # 测试逻辑回归函数 145 | def testLogisticRegression(): 146 | LogisticRegression() 147 | 148 | 149 | if __name__ == "__main__": 150 | testLogisticRegression() 151 | 152 | 153 | -------------------------------------------------------------------------------- /code/2-LogisticRegression/LogisticRegression_OneVsAll.py: -------------------------------------------------------------------------------- 1 | #-*- coding: utf-8 -*- 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | import scipy.io as spio 5 | from scipy import optimize 6 | from matplotlib.font_manager import FontProperties 7 | font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14) # 解决windows环境下画图汉字乱码问题 8 | 9 | 10 | def logisticRegression_OneVsAll(): 11 | data = loadmat_data("../../data/2-logistic_regression/data_digits.mat") 12 | X = data['X'] # 获取X数据，每一行对应一个数字20x20px 13 | y = data['y'] 14 | m,n = X.shape 15 | num_labels = 10 # 数字个数，0-9 16 | 17 | ##　随机显示几行数据 18 | rand_indices = [t for t in [np.random.randint(x-x, m) for x in range(100)]] # 生成100个0-m的随机数 19 | display_data(X[rand_indices,:]) # 显示100个数字 20 | 21 | Lambda = 0.1 # 正则化系数 22 | #y = y.reshape(-1,1) 23 | all_theta = oneVsAll(X, y, num_labels, Lambda) # 计算所有的theta 24 | 25 | p = predict_oneVsAll(all_theta,X) # 预测 26 | # 将预测结果和真实结果保存到文件中 27 | #res = np.hstack((p,y.reshape(-1,1))) 28 | #np.savetxt("predict.csv", res, delimiter=',') 29 | 30 | print(u"预测准确度为：%f%%" % np.mean((p == y.reshape(-1,1))*100)) 31 | 32 | # 加载mat文件 33 | def loadmat_data(fileName): 34 | return spio.loadmat(fileName) 35 | 36 | # 显示100个数字 37 | def display_data(imgData): 38 | sum = 0 39 | ''' 40 | 显示100个数（若是一个一个绘制将会非常慢，可以将要画的数字整理好，放到一个矩阵中，显示这个矩阵即可） 41 | - 初始化一个二维数组 42 | - 将每行的数据调整成图像的矩阵，放进二维数组 43 | - 显示即可 44 | ''' 45 | pad = 1 46 | display_array = -np.ones((pad+10*(20+pad),pad+10*(20+pad))) 47 | for i in range(10): 48 | for j in range(10): 49 | display_array[pad+i*(20+pad):pad+i*(20+pad)+20,pad+j*(20+pad):pad+j*(20+pad)+20] = (imgData[sum,:].reshape(20,20,order="F")) # order=F指定以列优先，在matlab中是这样的，python中需要指定，默认以行 50 | sum += 1 51 | 52 | plt.imshow(display_array,cmap='gray') # 显示灰度图像 53 | plt.axis('off') 54 | plt.show() 55 | 56 | # 求每个分类的theta，最后返回所有的all_theta 57 | def oneVsAll(X,y,num_labels,Lambda): 58 | # 初始化变量 59 | m,n = X.shape 60 | all_theta = np.zeros((n+1,num_labels)) # 每一列对应相应分类的theta,共10列 61 | X = np.hstack((np.ones((m,1)),X)) # X前补上一列1的偏置bias 62 | class_y = np.zeros((m,num_labels)) # 数据的y对应0-9，需要映射为0/1的关系 63 | initial_theta = np.zeros((n+1,1)) # 初始化一个分类的theta 64 | 65 | # 映射y 66 | for i in range(num_labels): 67 | class_y[:,i] = np.int32(y==i).reshape(1,-1) # 注意reshape(1,-1)才可以赋值 68 | 69 | #np.savetxt("class_y.csv", class_y[0:600,:], delimiter=',') 70 | 71 | '''遍历每个分类，计算对应的theta值''' 72 | for i in range(num_labels): 73 | #optimize.fmin_cg 74 | result = optimize.fmin_bfgs(costFunction, initial_theta, fprime=gradient, args=(X,class_y[:,i],Lambda)) # 调用梯度下降的优化方法 75 | all_theta[:,i] = result.reshape(1,-1) # 放入all_theta中 76 | 77 | all_theta = np.transpose(all_theta) 78 | return all_theta 79 | 80 | # 代价函数 81 | def costFunction(initial_theta,X,y,inital_lambda): 82 | m = len(y) 83 | J = 0 84 | 85 | h = sigmoid(np.dot(X,initial_theta)) # 计算h(z) 86 | theta1 = initial_theta.copy() # 因为正则化j=1从1开始，不包含0，所以复制一份，前theta(0)值为0 87 | theta1[0] = 0 88 | 89 | temp = np.dot(np.transpose(theta1),theta1) 90 | J = (-np.dot(np.transpose(y),np.log(h))-np.dot(np.transpose(1-y),np.log(1-h))+temp*inital_lambda/2)/m # 正则化的代价方程 91 | return J 92 | 93 | # 计算梯度 94 | def gradient(initial_theta,X,y,inital_lambda): 95 | m = len(y) 96 | grad = np.zeros((initial_theta.shape[0])) 97 | 98 | h = sigmoid(np.dot(X,initial_theta)) # 计算h(z) 99 | theta1 = initial_theta.copy() 100 | theta1[0] = 0 101 | 102 | grad = np.dot(np.transpose(X),h-y)/m+inital_lambda/m*theta1 #正则化的梯度 103 | return grad 104 | 105 | # S型函数 106 | def sigmoid(z): 107 | h = np.zeros((len(z),1)) # 初始化，与z的长度一致 108 | 109 | h = 1.0/(1.0+np.exp(-z)) 110 | return h 111 | 112 | # 预测 113 | def predict_oneVsAll(all_theta,X): 114 | m = X.shape[0] 115 | num_labels = all_theta.shape[0] 116 | p = np.zeros((m,1)) 117 | X = np.hstack((np.ones((m,1)),X)) # 在X最前面加一列1 118 | 119 | h = sigmoid(np.dot(X,np.transpose(all_theta))) # 预测 120 | 121 | ''' 122 | 返回h中每一行最大值所在的列号 123 | - np.max(h, axis=1)返回h中每一行的最大值（是某个数字的最大概率） 124 | - 最后where找到的最大概率所在的列号（列号即是对应的数字） 125 | ''' 126 | p = np.array(np.where(h[0,:] == np.max(h, axis=1)[0])) 127 | for i in np.arange(1, m): 128 | t = np.array(np.where(h[i,:] == np.max(h, axis=1)[i])) 129 | p = np.vstack((p,t)) 130 | return p 131 | 132 | 133 | if __name__ == "__main__": 134 | logisticRegression_OneVsAll() 135 | -------------------------------------------------------------------------------- /code/2-LogisticRegression/LogisticRegression_OneVsAll_scikit-learn.py: -------------------------------------------------------------------------------- 1 | #-*- coding: utf-8 -*- 2 | from scipy import io as spio 3 | import numpy as np 4 | from sklearn.linear_model import LogisticRegression 5 | 6 | 7 | def logisticRegression_oneVsAll(): 8 | data = loadmat_data("../../data/2-logistic_regression/data_digits.mat") 9 | X = data['X'] # 获取X数据，每一行对应一个数字20x20px 10 | y = data['y'] # 这里读取mat文件y的shape=(5000, 1) 11 | y = np.ravel(y) # 调用sklearn需要转化成一维的(5000,) 12 | 13 | model = LogisticRegression() 14 | model.fit(X, y) # 拟合 15 | 16 | predict = model.predict(X) # 预测 17 | 18 | print (u"预测准确度为：%f%%" % np.mean((predict == y)*100)) 19 | 20 | # 加载mat文件 21 | def loadmat_data(fileName): 22 | return spio.loadmat(fileName) 23 | 24 | 25 | if __name__ == "__main__": 26 | logisticRegression_oneVsAll() 27 | -------------------------------------------------------------------------------- /code/2-LogisticRegression/LogisticRegression_scikit-learn.py: -------------------------------------------------------------------------------- 1 | #coding:utf-8 2 | from sklearn.linear_model import LogisticRegression 3 | from sklearn.preprocessing import StandardScaler 4 | from sklearn.model_selection import train_test_split 5 | import numpy as np 6 | 7 | 8 | def logisticRegression(): 9 | data = loadtxtAndcsv_data("../../data/2-logistic_regression/data1.txt", ",", np.float64) 10 | X = data[:, 0:-1] 11 | y = data[:, -1] 12 | 13 | # 划分为训练集和测试集 14 | x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2) 15 | 16 | # 归一化 17 | scaler = StandardScaler() 18 | scaler.fit(x_train) 19 | x_train = scaler.fit_transform(x_train) 20 | x_test = scaler.fit_transform(x_test) 21 | 22 | # 逻辑回归 23 | model = LogisticRegression() 24 | model.fit(x_train, y_train) 25 | 26 | # 预测 27 | predict = model.predict(x_test) 28 | right = sum(predict == y_test) 29 | 30 | predict = np.hstack((predict.reshape(-1, 1), y_test.reshape(-1, 1))) # 将预测值和真实值放在一块，好观察 31 | print(predict) 32 | print('测试集准确率：%f%%' % (right * 100.0 / predict.shape[0])) # 计算在测试集上的准确度 33 | 34 | 35 | # 加载txt和csv文件 36 | def loadtxtAndcsv_data(fileName, split, dataType): 37 | return np.loadtxt(fileName, delimiter=split, dtype=dataType) 38 | 39 | 40 | # 加载npy文件 41 | def loadnpy_data(fileName): 42 | return np.load(fileName) 43 | 44 | 45 | if __name__ == "__main__": 46 | logisticRegression() 47 | -------------------------------------------------------------------------------- /code/3-NeuralNetwok/NeuralNetwork.py: -------------------------------------------------------------------------------- 1 | #-*- coding: utf-8 -*- 2 | import numpy as np 3 | from scipy import io as spio 4 | from matplotlib import pyplot as plt 5 | from scipy import optimize 6 | from matplotlib.font_manager import FontProperties 7 | import time 8 | font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14) # 解决windows环境下画图汉字乱码问题 9 | 10 | 11 | def neuralNetwork(input_layer_size,hidden_layer_size,out_put_layer): 12 | data_img = loadmat_data("../../data/3-neural_network/data_digits.mat") 13 | X = data_img['X'] 14 | y = data_img['y'] 15 | m,n = X.shape 16 | 17 | ##　随机显示几行数据 18 | rand_indices = [t for t in [np.random.randint(x-x, m) for x in range(100)]] # 生成100个0-m的随机数 19 | display_data(X[rand_indices,:]) # 显示100个数字 20 | 21 | #nn_params = np.vstack((Theta1.reshape(-1,1),Theta2.reshape(-1,1))) 22 | Lambda = 1 23 | 24 | initial_Theta1 = randInitializeWeights(input_layer_size,hidden_layer_size) 25 | initial_Theta2 = randInitializeWeights(hidden_layer_size,out_put_layer) 26 | 27 | initial_nn_params = np.vstack((initial_Theta1.reshape(-1,1),initial_Theta2.reshape(-1,1))) # 展开theta 28 | #np.savetxt("testTheta.csv",initial_nn_params,delimiter=",") 29 | start = time.time() 30 | result = optimize.fmin_cg(nnCostFunction, initial_nn_params, fprime=nnGradient, args=(input_layer_size,hidden_layer_size,out_put_layer,X,y,Lambda)) 31 | print (u'执行时间：',time.time()-start) 32 | print (result) 33 | '''可视化 Theta1''' 34 | length = result.shape[0] 35 | Theta1 = result[0:hidden_layer_size*(input_layer_size+1)].reshape(hidden_layer_size,input_layer_size+1) 36 | Theta2 = result[hidden_layer_size*(input_layer_size+1):length].reshape(out_put_layer,hidden_layer_size+1) 37 | display_data(Theta1[:,1:length]) 38 | display_data(Theta2[:,1:length]) 39 | '''预测''' 40 | p = predict(Theta1,Theta2,X) 41 | print (u"预测准确度为：%f%%" % np.mean((p == y.reshape(-1,1))*100)) 42 | res = np.hstack((p,y.reshape(-1,1))) 43 | np.savetxt("predict.csv", res, delimiter=',') 44 | 45 | 46 | # 加载mat文件 47 | def loadmat_data(fileName): 48 | return spio.loadmat(fileName) 49 | 50 | # 显示100个数字 51 | def display_data(imgData): 52 | sum = 0 53 | ''' 54 | 显示100个数（若是一个一个绘制将会非常慢，可以将要画的数字整理好，放到一个矩阵中，显示这个矩阵即可） 55 | - 初始化一个二维数组 56 | - 将每行的数据调整成图像的矩阵，放进二维数组 57 | - 显示即可 58 | ''' 59 | m,n = imgData.shape 60 | width = np.int32(np.round(np.sqrt(n))) 61 | height = np.int32(n/width) 62 | rows_count = np.int32(np.floor(np.sqrt(m))) 63 | cols_count = np.int32(np.ceil(m/rows_count)) 64 | pad = 1 65 | display_array = -np.ones((pad+rows_count*(height+pad),pad+cols_count*(width+pad))) 66 | for i in range(rows_count): 67 | for j in range(cols_count): 68 | if sum >= m: # 超过了行数，退出当前循环 69 | break 70 | display_array[pad+i*(height+pad):pad+i*(height+pad)+height,pad+j*(width+pad):pad+j*(width+pad)+width] = imgData[sum,:].reshape(height,width,order="F") # order=F指定以列优先，在matlab中是这样的，python中需要指定，默认以行 71 | sum += 1 72 | if sum >= m: # 超过了行数，退出当前循环 73 | break 74 | 75 | plt.imshow(display_array,cmap='gray') # 显示灰度图像 76 | plt.axis('off') 77 | plt.show() 78 | 79 | # 代价函数 80 | def nnCostFunction(nn_params,input_layer_size,hidden_layer_size,num_labels,X,y,Lambda): 81 | length = nn_params.shape[0] # theta的中长度 82 | # 还原theta1和theta2 83 | Theta1 = nn_params[0:hidden_layer_size*(input_layer_size+1)].reshape(hidden_layer_size,input_layer_size+1) 84 | Theta2 = nn_params[hidden_layer_size*(input_layer_size+1):length].reshape(num_labels,hidden_layer_size+1) 85 | 86 | # np.savetxt("Theta1.csv",Theta1,delimiter=',') 87 | 88 | m = X.shape[0] 89 | class_y = np.zeros((m,num_labels)) # 数据的y对应0-9，需要映射为0/1的关系 90 | # 映射y 91 | for i in range(num_labels): 92 | class_y[:,i] = np.int32(y==i).reshape(1,-1) # 注意reshape(1,-1)才可以赋值 93 | 94 | '''去掉theta1和theta2的第一列，因为正则化时从1开始''' 95 | Theta1_colCount = Theta1.shape[1] 96 | Theta1_x = Theta1[:,1:Theta1_colCount] 97 | Theta2_colCount = Theta2.shape[1] 98 | Theta2_x = Theta2[:,1:Theta2_colCount] 99 | # 正则化向theta^2 100 | term = np.dot(np.transpose(np.vstack((Theta1_x.reshape(-1,1),Theta2_x.reshape(-1,1)))),np.vstack((Theta1_x.reshape(-1,1),Theta2_x.reshape(-1,1)))) 101 | 102 | '''正向传播,每次需要补上一列1的偏置bias''' 103 | a1 = np.hstack((np.ones((m,1)),X)) 104 | z2 = np.dot(a1,np.transpose(Theta1)) 105 | a2 = sigmoid(z2) 106 | a2 = np.hstack((np.ones((m,1)),a2)) 107 | z3 = np.dot(a2,np.transpose(Theta2)) 108 | h = sigmoid(z3) 109 | '''代价''' 110 | J = -(np.dot(np.transpose(class_y.reshape(-1,1)),np.log(h.reshape(-1,1)))+np.dot(np.transpose(1-class_y.reshape(-1,1)),np.log(1-h.reshape(-1,1)))-Lambda*term/2)/m 111 | 112 | return np.ravel(J) 113 | 114 | # 梯度 115 | def nnGradient(nn_params,input_layer_size,hidden_layer_size,num_labels,X,y,Lambda): 116 | length = nn_params.shape[0] 117 | Theta1 = nn_params[0:hidden_layer_size*(input_layer_size+1)].reshape(hidden_layer_size,input_layer_size+1) 118 | Theta2 = nn_params[hidden_layer_size*(input_layer_size+1):length].reshape(num_labels,hidden_layer_size+1) 119 | m = X.shape[0] 120 | class_y = np.zeros((m,num_labels)) # 数据的y对应0-9，需要映射为0/1的关系 121 | # 映射y 122 | for i in range(num_labels): 123 | class_y[:,i] = np.int32(y==i).reshape(1,-1) # 注意reshape(1,-1)才可以赋值 124 | 125 | '''去掉theta1和theta2的第一列，因为正则化时从1开始''' 126 | Theta1_colCount = Theta1.shape[1] 127 | Theta1_x = Theta1[:,1:Theta1_colCount] 128 | Theta2_colCount = Theta2.shape[1] 129 | Theta2_x = Theta2[:,1:Theta2_colCount] 130 | 131 | Theta1_grad = np.zeros((Theta1.shape)) #第一层到第二层的权重 132 | Theta2_grad = np.zeros((Theta2.shape)) #第二层到第三层的权重 133 | 134 | Theta1[:,0] = 0 135 | Theta2[:,0] = 0 136 | '''正向传播，每次需要补上一列1的偏置bias''' 137 | a1 = np.hstack((np.ones((m,1)),X)) 138 | z2 = np.dot(a1,np.transpose(Theta1)) 139 | a2 = sigmoid(z2) 140 | a2 = np.hstack((np.ones((m,1)),a2)) 141 | z3 = np.dot(a2,np.transpose(Theta2)) 142 | h = sigmoid(z3) 143 | 144 | '''反向传播，delta为误差，''' 145 | delta3 = np.zeros((m,num_labels)) 146 | delta2 = np.zeros((m,hidden_layer_size)) 147 | for i in range(m): 148 | delta3[i,:] = h[i,:]-class_y[i,:] 149 | Theta2_grad = Theta2_grad+np.dot(np.transpose(delta3[i,:].reshape(1,-1)),a2[i,:].reshape(1,-1)) 150 | delta2[i,:] = np.dot(delta3[i,:].reshape(1,-1),Theta2_x)*sigmoidGradient(z2[i,:]) 151 | Theta1_grad = Theta1_grad+np.dot(np.transpose(delta2[i,:].reshape(1,-1)),a1[i,:].reshape(1,-1)) 152 | 153 | '''梯度''' 154 | grad = (np.vstack((Theta1_grad.reshape(-1,1),Theta2_grad.reshape(-1,1)))+Lambda*np.vstack((Theta1.reshape(-1,1),Theta2.reshape(-1,1))))/m 155 | return np.ravel(grad) 156 | 157 | # S型函数 158 | def sigmoid(Z): 159 | A = 1.0/(1.0+np.exp(-Z)) 160 | return A 161 | 162 | # S型函数导数 163 | def sigmoidGradient(z): 164 | g = sigmoid(z)*(1-sigmoid(z)) 165 | return g 166 | 167 | # 随机初始化权重theta 168 | def randInitializeWeights(L_in,L_out): 169 | W = np.zeros((L_out,1+L_in)) # 对应theta的权重 170 | epsilon_init = (6.0/(L_out+L_in))**0.5 171 | W = np.random.rand(L_out,1+L_in)*2*epsilon_init-epsilon_init # np.random.rand(L_out,1+L_in)产生L_out*(1+L_in)大小的随机矩阵 172 | return W 173 | 174 | 175 | # 检验梯度是否计算正确 176 | def checkGradient(Lambda = 0): 177 | '''构造一个小型的神经网络验证，因为数值法计算梯度很浪费时间，而且验证正确后之后就不再需要验证了''' 178 | input_layer_size = 3 179 | hidden_layer_size = 5 180 | num_labels = 3 181 | m = 5 182 | initial_Theta1 = debugInitializeWeights(input_layer_size,hidden_layer_size) 183 | initial_Theta2 = debugInitializeWeights(hidden_layer_size,num_labels) 184 | X = debugInitializeWeights(input_layer_size-1,m) 185 | y = 1+np.transpose(np.mod(np.arange(1,m+1), num_labels)) # 初始化y 186 | 187 | y = y.reshape(-1,1) 188 | nn_params = np.vstack((initial_Theta1.reshape(-1,1),initial_Theta2.reshape(-1,1))) #展开theta 189 | '''BP求出梯度''' 190 | grad = nnGradient(nn_params, input_layer_size, hidden_layer_size, 191 | num_labels, X, y, Lambda) 192 | '''使用数值法计算梯度''' 193 | num_grad = np.zeros((nn_params.shape[0])) 194 | step = np.zeros((nn_params.shape[0])) 195 | e = 1e-4 196 | for i in range(nn_params.shape[0]): 197 | step[i] = e 198 | loss1 = nnCostFunction(nn_params-step.reshape(-1,1), input_layer_size, hidden_layer_size, 199 | num_labels, X, y, 200 | Lambda) 201 | loss2 = nnCostFunction(nn_params+step.reshape(-1,1), input_layer_size, hidden_layer_size, 202 | num_labels, X, y, 203 | Lambda) 204 | num_grad[i] = (loss2-loss1)/(2*e) 205 | step[i]=0 206 | # 显示两列比较 207 | res = np.hstack((num_grad.reshape(-1,1),grad.reshape(-1,1))) 208 | print(res) 209 | 210 | # 初始化调试的theta权重 211 | def debugInitializeWeights(fan_in,fan_out): 212 | W = np.zeros((fan_out,fan_in+1)) 213 | x = np.arange(1,fan_out*(fan_in+1)+1) 214 | W = np.sin(x).reshape(W.shape)/10 215 | return W 216 | 217 | # 预测 218 | def predict(Theta1,Theta2,X): 219 | m = X.shape[0] 220 | #num_labels = Theta2.shape[0] 221 | #p = np.zeros((m,1)) 222 | '''正向传播，预测结果''' 223 | X = np.hstack((np.ones((m,1)),X)) 224 | h1 = sigmoid(np.dot(X,np.transpose(Theta1))) 225 | h1 = np.hstack((np.ones((m,1)),h1)) 226 | h2 = sigmoid(np.dot(h1,np.transpose(Theta2))) 227 | 228 | ''' 229 | 返回h中每一行最大值所在的列号 230 | - np.max(h, axis=1)返回h中每一行的最大值（是某个数字的最大概率） 231 | - 最后where找到的最大概率所在的列号（列号即是对应的数字） 232 | ''' 233 | #np.savetxt("h2.csv",h2,delimiter=',') 234 | p = np.array(np.where(h2[0,:] == np.max(h2, axis=1)[0])) 235 | for i in np.arange(1, m): 236 | t = np.array(np.where(h2[i,:] == np.max(h2, axis=1)[i])) 237 | p = np.vstack((p,t)) 238 | return p 239 | 240 | 241 | if __name__ == "__main__": 242 | #checkGradient() 243 | neuralNetwork(400, 25, 10) 244 | -------------------------------------------------------------------------------- /code/4-SVM/SVM_scikit-learn.py: -------------------------------------------------------------------------------- 1 | #coding:utf-8 2 | import numpy as np 3 | from scipy import io as spio 4 | from matplotlib import pyplot as plt 5 | from sklearn import svm 6 | 7 | 8 | def SVM(): 9 | '''data1——线性分类''' 10 | data1 = spio.loadmat('../../data/4-SVM/data1.mat') 11 | X = data1['X'] 12 | y = data1['y'] 13 | y = np.ravel(y) 14 | plot_data(X, y) 15 | 16 | model = svm.SVC(C=1.0, kernel='linear').fit(X, y) # 指定核函数为线性核函数 17 | plot_decisionBoundary(X, y, model) # 画决策边界 18 | '''data2——非线性分类''' 19 | data2 = spio.loadmat('../../data/4-SVM/data2.mat') 20 | X = data2['X'] 21 | y = data2['y'] 22 | y = np.ravel(y) 23 | plt = plot_data(X, y) 24 | plt.show() 25 | 26 | model = svm.SVC(gamma=100).fit(X, y) # gamma为核函数的系数，值越大拟合的越好 27 | plot_decisionBoundary(X, y, model, class_='notLinear') # 画决策边界 28 | 29 | 30 | # 作图 31 | def plot_data(X, y): 32 | plt.figure(figsize=(10, 8)) 33 | pos = np.where(y == 1) # 找到y=1的位置 34 | neg = np.where(y == 0) # 找到y=0的位置 35 | p1, = plt.plot(np.ravel(X[pos, 0]), np.ravel(X[pos, 1]), 'ro', markersize=8) 36 | p2, = plt.plot(np.ravel(X[neg, 0]), np.ravel(X[neg, 1]), 'g^', markersize=8) 37 | plt.xlabel("X1") 38 | plt.ylabel("X2") 39 | plt.legend([p1, p2], ["y==1", "y==0"]) 40 | return plt 41 | 42 | 43 | # 画决策边界 44 | def plot_decisionBoundary(X, y, model, class_='linear'): 45 | plt = plot_data(X, y) 46 | 47 | # 线性边界 48 | if class_ == 'linear': 49 | w = model.coef_ 50 | b = model.intercept_ 51 | xp = np.linspace(np.min(X[:, 0]), np.max(X[:, 1]), 100) 52 | yp = -(w[0, 0] * xp + b) / w[0, 1] 53 | plt.plot(xp, yp, 'b-', linewidth=2.0) 54 | plt.show() 55 | else: # 非线性边界 56 | x_1 = np.transpose(np.linspace(np.min(X[:, 0]), np.max(X[:, 0]), 100).reshape(1, -1)) 57 | x_2 = np.transpose(np.linspace(np.min(X[:, 1]), np.max(X[:, 1]), 100).reshape(1, -1)) 58 | X1, X2 = np.meshgrid(x_1, x_2) 59 | vals = np.zeros(X1.shape) 60 | for i in range(X1.shape[1]): 61 | this_X = np.hstack((X1[:, i].reshape(-1, 1), X2[:, i].reshape(-1, 1))) 62 | vals[:, i] = model.predict(this_X) 63 | 64 | plt.contour(X1, X2, vals, [0, 1], color='blue') 65 | plt.show() 66 | 67 | 68 | if __name__ == "__main__": 69 | SVM() 70 | -------------------------------------------------------------------------------- /code/5-K-Means/K-Means.py: -------------------------------------------------------------------------------- 1 | #-*- coding: utf-8 -*- 2 | import numpy as np 3 | from matplotlib import pyplot as plt 4 | from scipy import io as spio 5 | from scipy import misc # 图片操作 6 | from matplotlib.font_manager import FontProperties 7 | font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14) # 解决windows环境下画图汉字乱码问题 8 | 9 | 10 | def KMeans(): 11 | '''二维数据聚类过程演示''' 12 | print(u'聚类过程展示...\n') 13 | data = spio.loadmat("../../data/5-K-Means/data.mat") 14 | X = data['X'] 15 | K = 3 # 总类数 16 | initial_centroids = np.array([[3,3],[6,2],[8,5]]) # 初始化类中心 17 | max_iters = 10 18 | runKMeans(X,initial_centroids,max_iters,True) # 执行K-Means聚类算法 19 | ''' 20 | 图片压缩 21 | ''' 22 | print(u'K-Means压缩图片\n') 23 | img_data = misc.imread("../../data/5-K-Means/bird.png") # 读取图片像素数据 24 | img_data = img_data/255.0 # 像素值映射到0-1 25 | img_size = img_data.shape 26 | X = img_data.reshape(img_size[0]*img_size[1],3) # 调整为N*3的矩阵，N是所有像素点个数 27 | 28 | K = 16 29 | max_iters = 5 30 | initial_centroids = kMeansInitCentroids(X,K) 31 | centroids,idx = runKMeans(X, initial_centroids, max_iters, False) 32 | print(u'\nK-Means运行结束\n') 33 | print(u'\n压缩图片...\n') 34 | idx = findClosestCentroids(X, centroids) 35 | X_recovered = centroids[idx,:] 36 | X_recovered = X_recovered.reshape(img_size[0],img_size[1],3) 37 | 38 | print(u'绘制图片...\n') 39 | plt.subplot(1,2,1) 40 | plt.imshow(img_data) 41 | plt.title(u"原先图片",fontproperties=font) 42 | plt.subplot(1,2,2) 43 | plt.imshow(X_recovered) 44 | plt.title(u"压缩图像",fontproperties=font) 45 | plt.show() 46 | print(u'运行结束！') 47 | 48 | 49 | # 找到每条数据距离哪个类中心最近 50 | def findClosestCentroids(X,initial_centroids): 51 | m = X.shape[0] # 数据条数 52 | K = initial_centroids.shape[0] # 类的总数 53 | dis = np.zeros((m,K)) # 存储计算每个点分别到K个类的距离 54 | idx = np.zeros((m,1)) # 要返回的每条数据属于哪个类 55 | 56 | '''计算每个点到每个类中心的距离''' 57 | for i in range(m): 58 | for j in range(K): 59 | dis[i,j] = np.dot((X[i,:]-initial_centroids[j,:]).reshape(1,-1),(X[i,:]-initial_centroids[j,:]).reshape(-1,1)) 60 | 61 | '''返回dis每一行的最小值对应的列号，即为对应的类别 62 | - np.min(dis, axis=1)返回每一行的最小值 63 | - np.where(dis == np.min(dis, axis=1).reshape(-1,1)) 返回对应最小值的坐标 64 | - 注意：可能最小值对应的坐标有多个，where都会找出来，所以返回时返回前m个需要的即可（因为对于多个最小值，属于哪个类别都可以） 65 | ''' 66 | dummy,idx = np.where(dis == np.min(dis, axis=1).reshape(-1,1)) 67 | return idx[0:dis.shape[0]] # 注意截取一下 68 | 69 | 70 | # 计算类中心 71 | def computerCentroids(X,idx,K): 72 | n = X.shape[1] 73 | centroids = np.zeros((K,n)) 74 | for i in range(K): 75 | # 索引要是一维的,axis=0为每一列，idx==i一次找出属于哪一类的，然后计算均值 76 | centroids[i,:] = np.mean(X[np.ravel(idx==i),:], axis=0).reshape(1,-1) 77 | return centroids 78 | 79 | # 聚类算法 80 | def runKMeans(X,initial_centroids,max_iters,plot_process): 81 | m,n = X.shape # 数据条数和维度 82 | K = initial_centroids.shape[0] # 类数 83 | centroids = initial_centroids # 记录当前类中心 84 | previous_centroids = centroids # 记录上一次类中心 85 | idx = np.zeros((m,1)) # 每条数据属于哪个类 86 | 87 | for i in range(max_iters): # 迭代次数 88 | print(u'迭代计算次数：%d' % (i+1)) 89 | idx = findClosestCentroids(X, centroids) 90 | if plot_process: # 如果绘制图像 91 | plt = plotProcessKMeans(X,centroids,previous_centroids) # 画聚类中心的移动过程 92 | previous_centroids = centroids # 重置 93 | centroids = computerCentroids(X, idx, K) # 重新计算类中心 94 | if plot_process: # 显示最终的绘制结果 95 | plt.show() 96 | return centroids,idx # 返回聚类中心和数据属于哪个类 97 | 98 | # 画图，聚类中心的移动过程 99 | def plotProcessKMeans(X,centroids,previous_centroids): 100 | plt.scatter(X[:,0], X[:,1]) # 原数据的散点图 101 | plt.plot(previous_centroids[:,0],previous_centroids[:,1],'rx',markersize=10,linewidth=5.0) # 上一次聚类中心 102 | plt.plot(centroids[:,0],centroids[:,1],'rx',markersize=10,linewidth=5.0) # 当前聚类中心 103 | for j in range(centroids.shape[0]): # 遍历每个类，画类中心的移动直线 104 | p1 = centroids[j,:] 105 | p2 = previous_centroids[j,:] 106 | plt.plot([p1[0],p2[0]],[p1[1],p2[1]],"->",linewidth=2.0) 107 | return plt 108 | 109 | 110 | # 初始化类中心--随机取K个点作为聚类中心 111 | def kMeansInitCentroids(X,K): 112 | m = X.shape[0] 113 | m_arr = np.arange(0,m) # 生成0-m-1 114 | np.random.shuffle(m_arr) # 打乱m_arr顺序 115 | rand_indices = m_arr[:K] # 取前K个 116 | centroids = X[rand_indices,:] 117 | return centroids 118 | 119 | 120 | if __name__ == "__main__": 121 | KMeans() 122 | -------------------------------------------------------------------------------- /code/5-K-Means/K-Means_scikit-learn.py: -------------------------------------------------------------------------------- 1 | #-*- coding: utf-8 -*- 2 | 3 | from scipy import io as spio 4 | from matplotlib import pyplot as plt 5 | from sklearn.cluster import KMeans 6 | 7 | 8 | def kMenas(): 9 | data = spio.loadmat("../../data/5-K-Means/data.mat") 10 | X = data['X'] 11 | model = KMeans(n_clusters=3).fit(X) # n_clusters指定3类，拟合数据 12 | centroids = model.cluster_centers_ # 聚类中心 13 | 14 | plt.scatter(X[:,0], X[:,1]) # 原数据的散点图 15 | plt.plot(centroids[:,0],centroids[:,1],'r^',markersize=10) # 聚类中心 16 | plt.show() 17 | 18 | 19 | if __name__ == "__main__": 20 | kMenas() 21 | -------------------------------------------------------------------------------- /code/6-PCA/PCA.py: -------------------------------------------------------------------------------- 1 | #-*- coding: utf-8 -*- 2 | # ----------- 3 | # 修改：yijie 4 | # 日期：2017.12.28 5 | # ----------- 6 | # 原作者: Bob 7 | # 日期: 2016.11.24 8 | 9 | import numpy as np 10 | from matplotlib import pyplot as plt 11 | from scipy import io as spio 12 | 13 | 14 | ''' 15 | 主成分分析_2维数据降维1维演示函数 16 | ''' 17 | def PCA_2D(): 18 | data_2d = spio.loadmat("../../data/6-PCA/data.mat") 19 | X = data_2d['X'] 20 | m = X.shape[0] 21 | plt = plot_data_2d(X,'bo') # 显示二维的数据 22 | plt.show() 23 | 24 | X_copy = X.copy() 25 | X_norm,mu,sigma = featureNormalize(X_copy) # 归一化数据 26 | #plot_data_2d(X_norm) # 显示归一化后的数据 27 | #plt.show() 28 | 29 | Sigma = np.dot(np.transpose(X_norm),X_norm)/m # 求Sigma 30 | U,S,V = np.linalg.svd(Sigma) # 求Sigma的奇异值分解 31 | 32 | plt = plot_data_2d(X,'bo') # 显示原本数据 33 | drawline(plt, mu, mu+S[0]*(U[:,0]), 'r-') # 线，为投影的方向 34 | 35 | plt.axis('square') 36 | plt.show() 37 | 38 | K = 1 # 定义降维多少维（本来是2维的，这里降维1维） 39 | '''投影之后数据（降维之后）''' 40 | Z = projectData(X_norm,U,K) # 投影 41 | '''恢复数据''' 42 | X_rec = recoverData(Z,U,K) # 恢复 43 | '''作图-----原数据与恢复的数据''' 44 | plt = plot_data_2d(X_norm,'bo') 45 | plot_data_2d(X_rec,'ro') 46 | for i in range(X_norm.shape[0]): 47 | drawline(plt, X_norm[i,:], X_rec[i,:], '--k') 48 | plt.axis('square') 49 | plt.show() 50 | 51 | 52 | '''主成分分析_PCA图像数据降维''' 53 | def PCA_faceImage(): 54 | print (u'加载图像数据.....') 55 | data_image = spio.loadmat('../../data/6-PCA/data_faces.mat') 56 | X = data_image['X'] 57 | display_imageData(X[0:100,:]) 58 | m = X.shape[0] # 数据条数 59 | 60 | print(u'运行PCA....') 61 | X_norm,mu,sigma = featureNormalize(X) # 归一化 62 | 63 | Sigma = np.dot(np.transpose(X_norm),X_norm)/m # 求Sigma 64 | U,S,V = np.linalg.svd(Sigma) # 奇异值分解 65 | display_imageData(np.transpose(U[:,0:36])) # 显示U的数据 66 | 67 | print(u'对face数据降维.....') 68 | K = 100 # 降维100维(原先是32*32=1024维的) 69 | Z = projectData(X_norm, U, K) 70 | print(u'投影之后Z向量的大小：%d %d' %Z.shape) 71 | 72 | print(u'显示降维之后的数据......') 73 | X_rec = recoverData(Z, U, K) # 恢复数据 74 | display_imageData(X_rec[0:100,:]) 75 | 76 | 77 | # 可视化二维数据 78 | def plot_data_2d(X,marker): 79 | plt.plot(X[:,0],X[:,1],marker) 80 | return plt 81 | 82 | # 归一化数据 83 | def featureNormalize(X): 84 | '''（每一个数据-当前列的均值）/当前列的标准差''' 85 | n = X.shape[1] 86 | mu = np.zeros((1,n)) 87 | sigma = np.zeros((1,n)) 88 | 89 | mu = np.mean(X,axis=0) # axis=0表示列 90 | sigma = np.std(X,axis=0) 91 | for i in range(n): 92 | X[:,i] = (X[:,i]-mu[i])/sigma[i] 93 | return X,mu,sigma 94 | 95 | 96 | # 映射数据 97 | def projectData(X_norm,U,K): 98 | Z = np.zeros((X_norm.shape[0],K)) 99 | 100 | U_reduce = U[:,0:K] # 取前K个 101 | Z = np.dot(X_norm,U_reduce) 102 | return Z 103 | 104 | # 画一条线 105 | def drawline(plt,p1,p2,line_type): 106 | plt.plot(np.array([p1[0],p2[0]]),np.array([p1[1],p2[1]]),line_type) 107 | 108 | 109 | # 恢复数据 110 | def recoverData(Z,U,K): 111 | X_rec = np.zeros((Z.shape[0],U.shape[0])) 112 | U_recude = U[:,0:K] 113 | X_rec = np.dot(Z,np.transpose(U_recude)) # 还原数据（近似） 114 | return X_rec 115 | 116 | # 显示图片 117 | def display_imageData(imgData): 118 | sum = 0 119 | ''' 120 | 显示100个数（若是一个一个绘制将会非常慢，可以将要画的图片整理好，放到一个矩阵中，显示这个矩阵即可） 121 | - 初始化一个二维数组 122 | - 将每行的数据调整成图像的矩阵，放进二维数组 123 | - 显示即可 124 | ''' 125 | m,n = imgData.shape 126 | width = np.int32(np.round(np.sqrt(n))) 127 | height = np.int32(n/width) 128 | rows_count = np.int32(np.floor(np.sqrt(m))) 129 | cols_count = np.int32(np.ceil(m/rows_count)) 130 | pad = 1 131 | display_array = -np.ones((pad+rows_count*(height+pad),pad+cols_count*(width+pad))) 132 | for i in range(rows_count): 133 | for j in range(cols_count): 134 | max_val = np.max(np.abs(imgData[sum,:])) 135 | display_array[pad+i*(height+pad):pad+i*(height+pad)+height,pad+j*(width+pad):pad+j*(width+pad)+width] = imgData[sum,:].reshape(height,width,order="F")/max_val # order=F指定以列优先，在matlab中是这样的，python中需要指定，默认以行 136 | sum += 1 137 | 138 | plt.imshow(display_array,cmap='gray') # 显示灰度图像 139 | plt.axis('off') 140 | plt.show() 141 | 142 | 143 | if __name__ == "__main__": 144 | PCA_2D() 145 | PCA_faceImage() 146 | -------------------------------------------------------------------------------- /code/6-PCA/PCA_scikit-learn.py: -------------------------------------------------------------------------------- 1 | #-*- coding: utf-8 -*- 2 | # 版本： V 1.1 3 | # 修正： yijie 4 | # 时间：2017-12.28 5 | # Author:bob 6 | # Date:2016.12.22 7 | 8 | 9 | import numpy as np 10 | from matplotlib import pyplot as plt 11 | from scipy import io as spio 12 | from sklearn.decomposition import pca 13 | from sklearn.preprocessing import StandardScaler 14 | 15 | '''二维降为一维主运行函数''' 16 | def PCA_2d_example(): 17 | '''加载数据并作图''' 18 | data = spio.loadmat('../../data/6-PCA/data.mat') 19 | X = data['X'] 20 | plt = plot_data_2d(X,'bo') 21 | plt.axis('square') 22 | plt.title('original data') 23 | plt.show() 24 | '''归一化数据并作图''' 25 | scaler = StandardScaler() 26 | scaler.fit(X) 27 | x_train = scaler.transform(X) 28 | 29 | plot_data_2d(x_train, 'bo') 30 | plt.axis('square') 31 | plt.title('scaler data') 32 | plt.show() 33 | 34 | '''拟合数据''' 35 | K=1 # 要降的维度 36 | model = pca.PCA(n_components=K).fit(x_train) # 拟合数据，n_components定义要降的维度 37 | Z = model.transform(x_train) # transform就会执行降维操作 38 | 39 | '''数据恢复并作图''' 40 | Ureduce = model.components_ # 得到降维用的Ureduce 41 | x_rec = np.dot(Z,Ureduce) # 数据恢复 42 | 43 | plot_data_2d(x_rec,'bo') 44 | plt.plot() 45 | plt.axis('square') 46 | plt.title('recover data') 47 | plt.show() 48 | 49 | def PCA_face_example(): 50 | '''加载数据并显示''' 51 | image_data = spio.loadmat('../../data/6-PCA/data_faces.mat') 52 | X = image_data['X'] 53 | display_imageData(X[0:100,:]) # 显示100个最初图像 54 | 55 | '''归一化数据''' 56 | scaler = StandardScaler() 57 | scaler.fit(X) 58 | x_train = scaler.transform(X) 59 | 60 | '''拟合模型''' 61 | K=100 62 | model = pca.PCA(n_components=K).fit(x_train) 63 | Z = model.transform(x_train) 64 | Ureduce = model.components_ 65 | 66 | display_imageData(Ureduce[0:36,:]) # 可视化部分U数据 67 | x_rec = np.dot(Z,Ureduce) 68 | 69 | display_imageData(x_rec[0:100,:]) # 显示恢复的数据 70 | 71 | 72 | # 可视化二维数据 73 | def plot_data_2d(X,marker): 74 | plt.plot(X[:,0],X[:,1],marker) 75 | return plt 76 | 77 | # 显示图片 78 | def display_imageData(imgData): 79 | sum = 0 80 | ''' 81 | 显示100个数（若是一个一个绘制将会非常慢，可以将要画的图片整理好，放到一个矩阵中，显示这个矩阵即可） 82 | - 初始化一个二维数组 83 | - 将每行的数据调整成图像的矩阵，放进二维数组 84 | - 显示即可 85 | ''' 86 | m,n = imgData.shape 87 | width = np.int32(np.round(np.sqrt(n))) 88 | height = np.int32(n/width) 89 | rows_count = np.int32(np.floor(np.sqrt(m))) 90 | cols_count = np.int32(np.ceil(m/rows_count)) 91 | pad = 1 92 | display_array = -np.ones((pad+rows_count*(height+pad),pad+cols_count*(width+pad))) 93 | for i in range(rows_count): 94 | for j in range(cols_count): 95 | max_val = np.max(np.abs(imgData[sum,:])) 96 | display_array[pad+i*(height+pad):pad+i*(height+pad)+height,pad+j*(width+pad):pad+j*(width+pad)+width] = imgData[sum,:].reshape(height,width,order="F")/max_val # order=F指定以列优先，在matlab中是这样的，python中需要指定，默认以行 97 | sum += 1 98 | 99 | plt.imshow(display_array,cmap='gray') # 显示灰度图像 100 | plt.axis('off') 101 | plt.show() 102 | 103 | 104 | if __name__ == '__main__': 105 | #PCA_2d_example() 106 | PCA_face_example() -------------------------------------------------------------------------------- /code/7-AnomalyDetection/AnomalyDetection.py: -------------------------------------------------------------------------------- 1 | #-*- coding: utf-8 -*- 2 | 3 | # 修正：yijie 4 | # 日期 ：2017.12.28 5 | 6 | # Author: Bob 7 | # Date: 2016.12.22 8 | 9 | import numpy as np 10 | from matplotlib import pyplot as plt 11 | from scipy import io as spio 12 | 13 | '''异常检测主运行程序''' 14 | def anomalyDetection_example(): 15 | '''加载并显示数据''' 16 | data = spio.loadmat('../../data/7-anomaly_detection/data1.mat') 17 | X = data['X'] 18 | plt = display_2d_data(X, 'bx') 19 | plt.title("origin data") 20 | plt.show() 21 | '''多元高斯分布函数，并可视化拟合的边界''' 22 | mu,sigma2 = estimateGaussian(X) # 参数估计（求均值和方差） 23 | #print mu,sigma2 24 | p = multivariateGaussian(X,mu,sigma2) # 多元高斯分布函数 25 | #print p 26 | visualizeFit(X,mu,sigma2) # 显示图像 27 | 28 | '''选择异常点（在交叉验证CV上训练得到最好的epsilon）''' 29 | Xval = data['Xval'] 30 | yval = data['yval'] # y=1代表异常 31 | pval = multivariateGaussian(Xval, mu, sigma2) # 计算CV上的概率密度值 32 | epsilon,F1 = selectThreshold(yval,pval) # 选择最优的epsilon临界值 33 | print(u'在CV上得到的最好的epsilon是：%e' % epsilon) 34 | print(u'对应的F1Score值为：%f' % F1) 35 | outliers = np.where(p < epsilon) # 找到小于临界值的异常点，并作图 36 | plt.plot(X[outliers,0],X[outliers,1],'o',markeredgecolor='r',markerfacecolor='w',markersize=10.) 37 | plt = display_2d_data(X, 'bx') 38 | plt.show() 39 | 40 | # 显示二维数据 41 | def display_2d_data(X,marker): 42 | plt.plot(X[:,0],X[:,1],marker) 43 | plt.axis('square') 44 | return plt 45 | 46 | # 参数估计函数（就是求均值和方差） 47 | def estimateGaussian(X): 48 | mu = np.mean(X, axis=0) # axis=0表示列，每列的均值 49 | sigma2 = np.var(X,axis=0) # 求每列的方差 50 | return mu,sigma2 51 | 52 | # 多元高斯分布函数 53 | def multivariateGaussian(X,mu,Sigma2): 54 | k = len(mu) 55 | if (Sigma2.shape[0]>1): 56 | Sigma2 = np.diag(Sigma2) 57 | '''多元高斯分布函数''' 58 | X = X-mu 59 | argu = (2*np.pi)**(-k/2)*np.linalg.det(Sigma2)**(-0.5) 60 | p = argu*np.exp(-0.5*np.sum(np.dot(X,np.linalg.inv(Sigma2))*X,axis=1)) # axis表示每行 61 | return p 62 | 63 | # 可视化边界 64 | def visualizeFit(X,mu,sigma2): 65 | x = np.arange(0, 36, 0.5) # 0-36，步长0.5 66 | y = np.arange(0, 36, 0.5) 67 | X1,X2 = np.meshgrid(x,y) # 要画等高线，所以meshgird 68 | Z = multivariateGaussian(np.hstack((X1.reshape(-1,1),X2.reshape(-1,1))), mu, sigma2) # 计算对应的高斯分布函数 69 | Z = Z.reshape(X1.shape) # 调整形状 70 | plt.plot(X[:,0],X[:,1],'bx') 71 | 72 | if np.sum(np.isinf(Z).astype(float)) == 0: # 如果计算的为无穷，就不用画了 73 | # 画等高线，Z的值在10.**np.arange(-20, 0, 3) 74 | CS = plt.contour(X1,X2,Z,10.**np.arange(-20, 0, 3),color='black',linewidth=.5) 75 | #plt.clabel(CS) 76 | plt.show() 77 | 78 | # 选择最优的epsilon，即：使F1Score最大 79 | def selectThreshold(yval,pval): 80 | '''初始化所需变量''' 81 | bestEpsilon = 0. 82 | bestF1 = 0. 83 | F1 = 0. 84 | step = (np.max(pval)-np.min(pval))/1000 85 | '''计算''' 86 | for epsilon in np.arange(np.min(pval),np.max(pval),step): 87 | cvPrecision = pval < epsilon 88 | tp = np.sum((cvPrecision == 1) & (yval == 1)).astype(float) # sum求和是int型的，需要转为float 89 | fp = np.sum((cvPrecision == 1) & (yval == 0)).astype(float) 90 | fn = np.sum((cvPrecision == 1) & (yval == 0)).astype(float) 91 | precision = tp/(tp+fp) # 精准度 92 | recision = tp/(tp+fn) # 召回率 93 | F1 = (2*precision*recision)/(precision+recision) # F1Score计算公式 94 | if F1 > bestF1: # 修改最优的F1 Score 95 | bestF1 = F1 96 | bestEpsilon = epsilon 97 | return bestEpsilon,bestF1 98 | 99 | 100 | if __name__ == '__main__': 101 | anomalyDetection_example() 102 | -------------------------------------------------------------------------------- /data/1-linear_regression/data.csv: -------------------------------------------------------------------------------- 1 | 2104,3,399900 2 | 1600,3,329900 3 | 2400,3,369000 4 | 1416,2,232000 5 | 3000,4,539900 6 | 1985,4,299900 7 | 1534,3,314900 8 | 1427,3,198999 9 | 1380,3,212000 10 | 1494,3,242500 11 | 1940,4,239999 12 | 2000,3,347000 13 | 1890,3,329999 14 | 4478,5,699900 15 | 1268,3,259900 16 | 2300,4,449900 17 | 1320,2,299900 18 | 1236,3,199900 19 | 2609,4,499998 20 | 3031,4,599000 21 | 1767,3,252900 22 | 1888,2,255000 23 | 1604,3,242900 24 | 1962,4,259900 25 | 3890,3,573900 26 | 1100,3,249900 27 | 1458,3,464500 28 | 2526,3,469000 29 | 2200,3,475000 30 | 2637,3,299900 31 | 1839,2,349900 32 | 1000,1,169900 33 | 2040,4,314900 34 | 3137,3,579900 35 | 1811,4,285900 36 | 1437,3,249900 37 | 1239,3,229900 38 | 2132,4,345000 39 | 4215,4,549000 40 | 2162,4,287000 41 | 1664,2,368500 42 | 2238,3,329900 43 | 2567,4,314000 44 | 1200,3,299000 45 | 852,2,179900 46 | 1852,4,299900 47 | 1203,3,239500 48 | -------------------------------------------------------------------------------- /data/1-linear_regression/data.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/1-linear_regression/data.npy -------------------------------------------------------------------------------- /data/1-linear_regression/data.txt: -------------------------------------------------------------------------------- 1 | 2104,3,399900 2 | 1600,3,329900 3 | 2400,3,369000 4 | 1416,2,232000 5 | 3000,4,539900 6 | 1985,4,299900 7 | 1534,3,314900 8 | 1427,3,198999 9 | 1380,3,212000 10 | 1494,3,242500 11 | 1940,4,239999 12 | 2000,3,347000 13 | 1890,3,329999 14 | 4478,5,699900 15 | 1268,3,259900 16 | 2300,4,449900 17 | 1320,2,299900 18 | 1236,3,199900 19 | 2609,4,499998 20 | 3031,4,599000 21 | 1767,3,252900 22 | 1888,2,255000 23 | 1604,3,242900 24 | 1962,4,259900 25 | 3890,3,573900 26 | 1100,3,249900 27 | 1458,3,464500 28 | 2526,3,469000 29 | 2200,3,475000 30 | 2637,3,299900 31 | 1839,2,349900 32 | 1000,1,169900 33 | 2040,4,314900 34 | 3137,3,579900 35 | 1811,4,285900 36 | 1437,3,249900 37 | 1239,3,229900 38 | 2132,4,345000 39 | 4215,4,549000 40 | 2162,4,287000 41 | 1664,2,368500 42 | 2238,3,329900 43 | 2567,4,314000 44 | 1200,3,299000 45 | 852,2,179900 46 | 1852,4,299900 47 | 1203,3,239500 48 | -------------------------------------------------------------------------------- /data/2-logistic_regression/data1.npy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/2-logistic_regression/data1.npy -------------------------------------------------------------------------------- /data/2-logistic_regression/data1.txt: -------------------------------------------------------------------------------- 1 | 34.62365962451697,78.0246928153624,0 2 | 30.28671076822607,43.89499752400101,0 3 | 35.84740876993872,72.90219802708364,0 4 | 60.18259938620976,86.30855209546826,1 5 | 79.0327360507101,75.3443764369103,1 6 | 45.08327747668339,56.3163717815305,0 7 | 61.10666453684766,96.51142588489624,1 8 | 75.02474556738889,46.55401354116538,1 9 | 76.09878670226257,87.42056971926803,1 10 | 84.43281996120035,43.53339331072109,1 11 | 95.86155507093572,38.22527805795094,0 12 | 75.01365838958247,30.60326323428011,0 13 | 82.30705337399482,76.48196330235604,1 14 | 69.36458875970939,97.71869196188608,1 15 | 39.53833914367223,76.03681085115882,0 16 | 53.9710521485623,89.20735013750205,1 17 | 69.07014406283025,52.74046973016765,1 18 | 67.94685547711617,46.67857410673128,0 19 | 70.66150955499435,92.92713789364831,1 20 | 76.97878372747498,47.57596364975532,1 21 | 67.37202754570876,42.83843832029179,0 22 | 89.67677575072079,65.79936592745237,1 23 | 50.534788289883,48.85581152764205,0 24 | 34.21206097786789,44.20952859866288,0 25 | 77.9240914545704,68.9723599933059,1 26 | 62.27101367004632,69.95445795447587,1 27 | 80.1901807509566,44.82162893218353,1 28 | 93.114388797442,38.80067033713209,0 29 | 61.83020602312595,50.25610789244621,0 30 | 38.78580379679423,64.99568095539578,0 31 | 61.379289447425,72.80788731317097,1 32 | 85.40451939411645,57.05198397627122,1 33 | 52.10797973193984,63.12762376881715,0 34 | 52.04540476831827,69.43286012045222,1 35 | 40.23689373545111,71.16774802184875,0 36 | 54.63510555424817,52.21388588061123,0 37 | 33.91550010906887,98.86943574220611,0 38 | 64.17698887494485,80.90806058670817,1 39 | 74.78925295941542,41.57341522824434,0 40 | 34.1836400264419,75.2377203360134,0 41 | 83.90239366249155,56.30804621605327,1 42 | 51.54772026906181,46.85629026349976,0 43 | 94.44336776917852,65.56892160559052,1 44 | 82.36875375713919,40.61825515970618,0 45 | 51.04775177128865,45.82270145776001,0 46 | 62.22267576120188,52.06099194836679,0 47 | 77.19303492601364,70.45820000180959,1 48 | 97.77159928000232,86.7278223300282,1 49 | 62.07306379667647,96.76882412413983,1 50 | 91.56497449807442,88.69629254546599,1 51 | 79.94481794066932,74.16311935043758,1 52 | 99.2725269292572,60.99903099844988,1 53 | 90.54671411399852,43.39060180650027,1 54 | 34.52451385320009,60.39634245837173,0 55 | 50.2864961189907,49.80453881323059,0 56 | 49.58667721632031,59.80895099453265,0 57 | 97.64563396007767,68.86157272420604,1 58 | 32.57720016809309,95.59854761387875,0 59 | 74.24869136721598,69.82457122657193,1 60 | 71.79646205863379,78.45356224515052,1 61 | 75.3956114656803,85.75993667331619,1 62 | 35.28611281526193,47.02051394723416,0 63 | 56.25381749711624,39.26147251058019,0 64 | 30.05882244669796,49.59297386723685,0 65 | 44.66826172480893,66.45008614558913,0 66 | 66.56089447242954,41.09209807936973,0 67 | 40.45755098375164,97.53518548909936,1 68 | 49.07256321908844,51.88321182073966,0 69 | 80.27957401466998,92.11606081344084,1 70 | 66.74671856944039,60.99139402740988,1 71 | 32.72283304060323,43.30717306430063,0 72 | 64.0393204150601,78.03168802018232,1 73 | 72.34649422579923,96.22759296761404,1 74 | 60.45788573918959,73.09499809758037,1 75 | 58.84095621726802,75.85844831279042,1 76 | 99.82785779692128,72.36925193383885,1 77 | 47.26426910848174,88.47586499559782,1 78 | 50.45815980285988,75.80985952982456,1 79 | 60.45555629271532,42.50840943572217,0 80 | 82.22666157785568,42.71987853716458,0 81 | 88.9138964166533,69.80378889835472,1 82 | 94.83450672430196,45.69430680250754,1 83 | 67.31925746917527,66.58935317747915,1 84 | 57.23870631569862,59.51428198012956,1 85 | 80.36675600171273,90.96014789746954,1 86 | 68.46852178591112,85.59430710452014,1 87 | 42.0754545384731,78.84478600148043,0 88 | 75.47770200533905,90.42453899753964,1 89 | 78.63542434898018,96.64742716885644,1 90 | 52.34800398794107,60.76950525602592,0 91 | 94.09433112516793,77.15910509073893,1 92 | 90.44855097096364,87.50879176484702,1 93 | 55.48216114069585,35.57070347228866,0 94 | 74.49269241843041,84.84513684930135,1 95 | 89.84580670720979,45.35828361091658,1 96 | 83.48916274498238,48.38028579728175,1 97 | 42.2617008099817,87.10385094025457,1 98 | 99.31500880510394,68.77540947206617,1 99 | 55.34001756003703,64.9319380069486,1 100 | 74.77589300092767,89.52981289513276,1 101 | -------------------------------------------------------------------------------- /data/2-logistic_regression/data2.txt: -------------------------------------------------------------------------------- 1 | 0.051267,0.69956,1 2 | -0.092742,0.68494,1 3 | -0.21371,0.69225,1 4 | -0.375,0.50219,1 5 | -0.51325,0.46564,1 6 | -0.52477,0.2098,1 7 | -0.39804,0.034357,1 8 | -0.30588,-0.19225,1 9 | 0.016705,-0.40424,1 10 | 0.13191,-0.51389,1 11 | 0.38537,-0.56506,1 12 | 0.52938,-0.5212,1 13 | 0.63882,-0.24342,1 14 | 0.73675,-0.18494,1 15 | 0.54666,0.48757,1 16 | 0.322,0.5826,1 17 | 0.16647,0.53874,1 18 | -0.046659,0.81652,1 19 | -0.17339,0.69956,1 20 | -0.47869,0.63377,1 21 | -0.60541,0.59722,1 22 | -0.62846,0.33406,1 23 | -0.59389,0.005117,1 24 | -0.42108,-0.27266,1 25 | -0.11578,-0.39693,1 26 | 0.20104,-0.60161,1 27 | 0.46601,-0.53582,1 28 | 0.67339,-0.53582,1 29 | -0.13882,0.54605,1 30 | -0.29435,0.77997,1 31 | -0.26555,0.96272,1 32 | -0.16187,0.8019,1 33 | -0.17339,0.64839,1 34 | -0.28283,0.47295,1 35 | -0.36348,0.31213,1 36 | -0.30012,0.027047,1 37 | -0.23675,-0.21418,1 38 | -0.06394,-0.18494,1 39 | 0.062788,-0.16301,1 40 | 0.22984,-0.41155,1 41 | 0.2932,-0.2288,1 42 | 0.48329,-0.18494,1 43 | 0.64459,-0.14108,1 44 | 0.46025,0.012427,1 45 | 0.6273,0.15863,1 46 | 0.57546,0.26827,1 47 | 0.72523,0.44371,1 48 | 0.22408,0.52412,1 49 | 0.44297,0.67032,1 50 | 0.322,0.69225,1 51 | 0.13767,0.57529,1 52 | -0.0063364,0.39985,1 53 | -0.092742,0.55336,1 54 | -0.20795,0.35599,1 55 | -0.20795,0.17325,1 56 | -0.43836,0.21711,1 57 | -0.21947,-0.016813,1 58 | -0.13882,-0.27266,1 59 | 0.18376,0.93348,0 60 | 0.22408,0.77997,0 61 | 0.29896,0.61915,0 62 | 0.50634,0.75804,0 63 | 0.61578,0.7288,0 64 | 0.60426,0.59722,0 65 | 0.76555,0.50219,0 66 | 0.92684,0.3633,0 67 | 0.82316,0.27558,0 68 | 0.96141,0.085526,0 69 | 0.93836,0.012427,0 70 | 0.86348,-0.082602,0 71 | 0.89804,-0.20687,0 72 | 0.85196,-0.36769,0 73 | 0.82892,-0.5212,0 74 | 0.79435,-0.55775,0 75 | 0.59274,-0.7405,0 76 | 0.51786,-0.5943,0 77 | 0.46601,-0.41886,0 78 | 0.35081,-0.57968,0 79 | 0.28744,-0.76974,0 80 | 0.085829,-0.75512,0 81 | 0.14919,-0.57968,0 82 | -0.13306,-0.4481,0 83 | -0.40956,-0.41155,0 84 | -0.39228,-0.25804,0 85 | -0.74366,-0.25804,0 86 | -0.69758,0.041667,0 87 | -0.75518,0.2902,0 88 | -0.69758,0.68494,0 89 | -0.4038,0.70687,0 90 | -0.38076,0.91886,0 91 | -0.50749,0.90424,0 92 | -0.54781,0.70687,0 93 | 0.10311,0.77997,0 94 | 0.057028,0.91886,0 95 | -0.10426,0.99196,0 96 | -0.081221,1.1089,0 97 | 0.28744,1.087,0 98 | 0.39689,0.82383,0 99 | 0.63882,0.88962,0 100 | 0.82316,0.66301,0 101 | 0.67339,0.64108,0 102 | 1.0709,0.10015,0 103 | -0.046659,-0.57968,0 104 | -0.23675,-0.63816,0 105 | -0.15035,-0.36769,0 106 | -0.49021,-0.3019,0 107 | -0.46717,-0.13377,0 108 | -0.28859,-0.060673,0 109 | -0.61118,-0.067982,0 110 | -0.66302,-0.21418,0 111 | -0.59965,-0.41886,0 112 | -0.72638,-0.082602,0 113 | -0.83007,0.31213,0 114 | -0.72062,0.53874,0 115 | -0.59389,0.49488,0 116 | -0.48445,0.99927,0 117 | -0.0063364,0.99927,0 118 | 0.63265,-0.030612,0 119 | -------------------------------------------------------------------------------- /data/2-logistic_regression/data_digits.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/2-logistic_regression/data_digits.mat -------------------------------------------------------------------------------- /data/3-neural_network/data_digits.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/3-neural_network/data_digits.mat -------------------------------------------------------------------------------- /data/4-SVM/data.txt: -------------------------------------------------------------------------------- 1 | 0.051267,0.69956,1 2 | -0.092742,0.68494,1 3 | -0.21371,0.69225,1 4 | -0.375,0.50219,1 5 | -0.51325,0.46564,1 6 | -0.52477,0.2098,1 7 | -0.39804,0.034357,1 8 | -0.30588,-0.19225,1 9 | 0.016705,-0.40424,1 10 | 0.13191,-0.51389,1 11 | 0.38537,-0.56506,1 12 | 0.52938,-0.5212,1 13 | 0.63882,-0.24342,1 14 | 0.73675,-0.18494,1 15 | 0.54666,0.48757,1 16 | 0.322,0.5826,1 17 | 0.16647,0.53874,1 18 | -0.046659,0.81652,1 19 | -0.17339,0.69956,1 20 | -0.47869,0.63377,1 21 | -0.60541,0.59722,1 22 | -0.62846,0.33406,1 23 | -0.59389,0.005117,1 24 | -0.42108,-0.27266,1 25 | -0.11578,-0.39693,1 26 | 0.20104,-0.60161,1 27 | 0.46601,-0.53582,1 28 | 0.67339,-0.53582,1 29 | -0.13882,0.54605,1 30 | -0.29435,0.77997,1 31 | -0.26555,0.96272,1 32 | -0.16187,0.8019,1 33 | -0.17339,0.64839,1 34 | -0.28283,0.47295,1 35 | -0.36348,0.31213,1 36 | -0.30012,0.027047,1 37 | -0.23675,-0.21418,1 38 | -0.06394,-0.18494,1 39 | 0.062788,-0.16301,1 40 | 0.22984,-0.41155,1 41 | 0.2932,-0.2288,1 42 | 0.48329,-0.18494,1 43 | 0.64459,-0.14108,1 44 | 0.46025,0.012427,1 45 | 0.6273,0.15863,1 46 | 0.57546,0.26827,1 47 | 0.72523,0.44371,1 48 | 0.22408,0.52412,1 49 | 0.44297,0.67032,1 50 | 0.322,0.69225,1 51 | 0.13767,0.57529,1 52 | -0.0063364,0.39985,1 53 | -0.092742,0.55336,1 54 | -0.20795,0.35599,1 55 | -0.20795,0.17325,1 56 | -0.43836,0.21711,1 57 | -0.21947,-0.016813,1 58 | -0.13882,-0.27266,1 59 | 0.18376,0.93348,0 60 | 0.22408,0.77997,0 61 | 0.29896,0.61915,0 62 | 0.50634,0.75804,0 63 | 0.61578,0.7288,0 64 | 0.60426,0.59722,0 65 | 0.76555,0.50219,0 66 | 0.92684,0.3633,0 67 | 0.82316,0.27558,0 68 | 0.96141,0.085526,0 69 | 0.93836,0.012427,0 70 | 0.86348,-0.082602,0 71 | 0.89804,-0.20687,0 72 | 0.85196,-0.36769,0 73 | 0.82892,-0.5212,0 74 | 0.79435,-0.55775,0 75 | 0.59274,-0.7405,0 76 | 0.51786,-0.5943,0 77 | 0.46601,-0.41886,0 78 | 0.35081,-0.57968,0 79 | 0.28744,-0.76974,0 80 | 0.085829,-0.75512,0 81 | 0.14919,-0.57968,0 82 | -0.13306,-0.4481,0 83 | -0.40956,-0.41155,0 84 | -0.39228,-0.25804,0 85 | -0.74366,-0.25804,0 86 | -0.69758,0.041667,0 87 | -0.75518,0.2902,0 88 | -0.69758,0.68494,0 89 | -0.4038,0.70687,0 90 | -0.38076,0.91886,0 91 | -0.50749,0.90424,0 92 | -0.54781,0.70687,0 93 | 0.10311,0.77997,0 94 | 0.057028,0.91886,0 95 | -0.10426,0.99196,0 96 | -0.081221,1.1089,0 97 | 0.28744,1.087,0 98 | 0.39689,0.82383,0 99 | 0.63882,0.88962,0 100 | 0.82316,0.66301,0 101 | 0.67339,0.64108,0 102 | 1.0709,0.10015,0 103 | -0.046659,-0.57968,0 104 | -0.23675,-0.63816,0 105 | -0.15035,-0.36769,0 106 | -0.49021,-0.3019,0 107 | -0.46717,-0.13377,0 108 | -0.28859,-0.060673,0 109 | -0.61118,-0.067982,0 110 | -0.66302,-0.21418,0 111 | -0.59965,-0.41886,0 112 | -0.72638,-0.082602,0 113 | -0.83007,0.31213,0 114 | -0.72062,0.53874,0 115 | -0.59389,0.49488,0 116 | -0.48445,0.99927,0 117 | -0.0063364,0.99927,0 118 | 0.63265,-0.030612,0 119 | -------------------------------------------------------------------------------- /data/4-SVM/data1.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/4-SVM/data1.mat -------------------------------------------------------------------------------- /data/4-SVM/data2.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/4-SVM/data2.mat -------------------------------------------------------------------------------- /data/4-SVM/data3.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/4-SVM/data3.mat -------------------------------------------------------------------------------- /data/5-K-Means/bird.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/5-K-Means/bird.mat -------------------------------------------------------------------------------- /data/5-K-Means/bird.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/5-K-Means/bird.png -------------------------------------------------------------------------------- /data/5-K-Means/data.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/5-K-Means/data.mat -------------------------------------------------------------------------------- /data/6-PCA/data.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/6-PCA/data.mat -------------------------------------------------------------------------------- /data/6-PCA/data_faces.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/6-PCA/data_faces.mat -------------------------------------------------------------------------------- /data/7-anomaly_detection/data1.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/7-anomaly_detection/data1.mat -------------------------------------------------------------------------------- /data/7-anomaly_detection/data2.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/data/7-anomaly_detection/data2.mat -------------------------------------------------------------------------------- /formula/AnomalyDetection.wmf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/formula/AnomalyDetection.wmf -------------------------------------------------------------------------------- /formula/K-Means.wmf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/formula/K-Means.wmf -------------------------------------------------------------------------------- /formula/LinearRegression_01.wmf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/formula/LinearRegression_01.wmf -------------------------------------------------------------------------------- /formula/LogisticRegression_01.wmf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/formula/LogisticRegression_01.wmf -------------------------------------------------------------------------------- /formula/NeuralNetwork.wmf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/formula/NeuralNetwork.wmf -------------------------------------------------------------------------------- /formula/PCA.wmf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/formula/PCA.wmf -------------------------------------------------------------------------------- /formula/SVM.wmf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/formula/SVM.wmf -------------------------------------------------------------------------------- /images/AnomalyDetection_01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/AnomalyDetection_01.png -------------------------------------------------------------------------------- /images/AnomalyDetection_02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/AnomalyDetection_02.png -------------------------------------------------------------------------------- /images/AnomalyDetection_03.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/AnomalyDetection_03.png -------------------------------------------------------------------------------- /images/AnomalyDetection_04.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/AnomalyDetection_04.png -------------------------------------------------------------------------------- /images/AnomalyDetection_05.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/AnomalyDetection_05.png -------------------------------------------------------------------------------- /images/AnomalyDetection_06.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/AnomalyDetection_06.png -------------------------------------------------------------------------------- /images/AnomalyDetection_07.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/AnomalyDetection_07.png -------------------------------------------------------------------------------- /images/AnomalyDetection_08.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/AnomalyDetection_08.png -------------------------------------------------------------------------------- /images/AnomalyDetection_09.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/AnomalyDetection_09.png -------------------------------------------------------------------------------- /images/AnomalyDetection_10.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/AnomalyDetection_10.png -------------------------------------------------------------------------------- /images/K-Means_01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/K-Means_01.png -------------------------------------------------------------------------------- /images/K-Means_02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/K-Means_02.png -------------------------------------------------------------------------------- /images/K-Means_03.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/K-Means_03.png -------------------------------------------------------------------------------- /images/K-Means_04.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/K-Means_04.png -------------------------------------------------------------------------------- /images/K-Means_05.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/K-Means_05.png -------------------------------------------------------------------------------- /images/K-Means_06.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/K-Means_06.png -------------------------------------------------------------------------------- /images/K-Means_07.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/K-Means_07.png -------------------------------------------------------------------------------- /images/LinearRegression_01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LinearRegression_01.png -------------------------------------------------------------------------------- /images/LogisticRegression_01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_01.png -------------------------------------------------------------------------------- /images/LogisticRegression_02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_02.png -------------------------------------------------------------------------------- /images/LogisticRegression_03.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_03.jpg -------------------------------------------------------------------------------- /images/LogisticRegression_04.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_04.png -------------------------------------------------------------------------------- /images/LogisticRegression_05.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_05.png -------------------------------------------------------------------------------- /images/LogisticRegression_06.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_06.png -------------------------------------------------------------------------------- /images/LogisticRegression_07.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_07.png -------------------------------------------------------------------------------- /images/LogisticRegression_08.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_08.png -------------------------------------------------------------------------------- /images/LogisticRegression_09.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_09.png -------------------------------------------------------------------------------- /images/LogisticRegression_10.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_10.png -------------------------------------------------------------------------------- /images/LogisticRegression_11.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_11.png -------------------------------------------------------------------------------- /images/LogisticRegression_12.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_12.png -------------------------------------------------------------------------------- /images/LogisticRegression_13.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/LogisticRegression_13.png -------------------------------------------------------------------------------- /images/NeuralNetwork_01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/NeuralNetwork_01.png -------------------------------------------------------------------------------- /images/NeuralNetwork_02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/NeuralNetwork_02.png -------------------------------------------------------------------------------- /images/NeuralNetwork_03.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/NeuralNetwork_03.jpg -------------------------------------------------------------------------------- /images/NeuralNetwork_04.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/NeuralNetwork_04.png -------------------------------------------------------------------------------- /images/NeuralNetwork_05.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/NeuralNetwork_05.png -------------------------------------------------------------------------------- /images/NeuralNetwork_06.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/NeuralNetwork_06.png -------------------------------------------------------------------------------- /images/NeuralNetwork_07.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/NeuralNetwork_07.png -------------------------------------------------------------------------------- /images/NeuralNetwork_08.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/NeuralNetwork_08.png -------------------------------------------------------------------------------- /images/NeuralNetwork_09.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/NeuralNetwork_09.png -------------------------------------------------------------------------------- /images/PCA_01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/PCA_01.png -------------------------------------------------------------------------------- /images/PCA_02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/PCA_02.png -------------------------------------------------------------------------------- /images/PCA_03.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/PCA_03.png -------------------------------------------------------------------------------- /images/PCA_04.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/PCA_04.png -------------------------------------------------------------------------------- /images/PCA_05.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/PCA_05.png -------------------------------------------------------------------------------- /images/PCA_06.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/PCA_06.png -------------------------------------------------------------------------------- /images/PCA_07.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/PCA_07.png -------------------------------------------------------------------------------- /images/PCA_08.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/PCA_08.png -------------------------------------------------------------------------------- /images/SVM_01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/SVM_01.png -------------------------------------------------------------------------------- /images/SVM_02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/SVM_02.png -------------------------------------------------------------------------------- /images/SVM_03.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/SVM_03.png -------------------------------------------------------------------------------- /images/SVM_04.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/SVM_04.png -------------------------------------------------------------------------------- /images/SVM_05.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/SVM_05.png -------------------------------------------------------------------------------- /images/SVM_06.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/SVM_06.png -------------------------------------------------------------------------------- /images/SVM_07.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/SVM_07.png -------------------------------------------------------------------------------- /images/SVM_08.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/SVM_08.png -------------------------------------------------------------------------------- /images/SVM_09.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/SVM_09.png -------------------------------------------------------------------------------- /images/SVM_10.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/SVM_10.png -------------------------------------------------------------------------------- /images/nn_model.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DeepInDeeper/MachineLearningZeroToALL/b14005c3e0b5a39a0ba82db5c9791f682b5effd5/images/nn_model.png -------------------------------------------------------------------------------- /other/note/LSJU-chapter06-01.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 第六讲：事件模型、函数间隔与几何间隔\n", 8 | "\n", 9 | "接着上一讲，进一步讨论朴素贝叶斯算法及事件模型。\n", 10 | "\n", 11 | "## 2.2 文本分类的事件模型\n", 12 | "\n", 13 | "在结束生成学习算法前，我们再来介绍一种针对文本分类的模型。虽然前面介绍的朴素贝叶斯算法对于很多分类问题都要良好的效果，不过对于文本分类，我们有一种更好的模型。\n", 14 | "\n", 15 | "在特定语境的文本分类中，朴素贝叶斯算法使用了**多元伯努利事件模型（multi-variate Bernoulli event model）**（特征值按照伯努利试验取$x_i\\in\\{0,1\\}$，特征值向量长度为字典长度）。回忆一下上一讲的知识，在这个模型中，我们首先假设下一封邮件的发送方已经确定，一个随机的邮件发送人（可能是垃圾邮件制造者，也可能只是普通联系人，是由我们确定的条件概率中的条件）；接着我们假设，发送者会遍历词典，独立的决定是否将单词$x_i$写入邮件（该词语相对于其他词语独立），而且该词语服从概率$p(x_i=1\\mid y)=\\phi_{i\\mid y}$（如果是垃圾邮件制造者则可能更倾向于发送带有“buy”、“sales”、“discount”等单词的 邮件，而普通联系人则会选择更正常的词语分布发送正常邮件）。于是我们得到，$p(x\\mid y)=\\prod_{i=1}^np(x_i\\mid y)$和$p(y)$，再根据$\\mathrm{arg}\\displaystyle\\operatorname*{max}_yp(x\\mid y)=\\mathrm{arg}\\displaystyle\\operatorname*{max}_yp(x\\mid y)p(y)$最终得到该邮件是垃圾邮件的概率：$p(y)\\prod_{i=1}^np(x_i\\mid y)$。这个模型存在一些小问题，比如，它不能讲词语的出现的次数反应在输入特征值向量中，如果一封邮件多次出现“buy”这个词，那么此邮件确实更有可能是垃圾邮件。\n", 16 | "\n", 17 | "下面介绍的模型是朴素贝叶斯算法算法的简单变形，称为**多项事件模型（multinomial event model）**。接下来，我们将使用不同的记法和不同的特征值描述邮件。使用$x_i$表示邮件中的第$i$个词语，$x_i$在是一个在$\\{1,\\cdots,\\lvert V\\rvert\\}$取值的整数，而$\\lvert V\\rvert$就是词汇表（词典）的大小。于是，一封邮件被我们表示为$(x_1,x_2,\\cdots,x_n)$向量，注意，对于不同的邮件$n$是不同的。举个例子，对于一封以“A NIPS”开头的邮件，有$x_1=1$（“a”是词典的第一个单词）、$x_2=35000$（假设“nips”是词典的第35000个单词）。\n", 18 | "\n", 19 | "在多项事件模型中，我们像以前一样假设邮件发送方已经由一个随机过程确定（根据$p(y)$），可能是垃圾邮件制造者，也可能是普通联系人；接着，发件人从某多项分布（$p(x_i\\mid y)$）中选出一个词$x_1$；然后根据相同的多项分布选出第二个词$x_2$（独立于$x_1$），继续重复这个动作选出$x_3,x_4,\\cdot,x_n$；最后，邮件编写结束。因此，该邮件是垃圾邮件的概率为$p(y)\\prod_{i=1}^np(x_i\\mid y)$，这个式子和前面的完全一样，但是请注意，这里的特征值$x_i$是邮件第$i$个单词，其取值不再是多元伯努利事件模型中的$\\{0,1\\}$了，它现在是一个多项分布。\n", 20 | "\n", 21 | "多项事件模型的参数为：$\\phi_y=p(y)$（同以前一样），$\\phi_{k\\mid y=1}=p(x_j=k\\mid y=1),\\ \\phi_{k\\mid y=0}=p(x_j=k\\mid y=0)$（对任意$j$）。注意到这里我们假设了对于任意$j$都有其$p(x_j\\mid y)$相等，即在$y$条件下关于某词语的概率分布与该词语出现在邮件里的位置（$j$）无关。\n", 22 | "\n", 23 | "对于训练集$\\left\\{\\left(x^{(i)},y^{(i)}\\right);i=1,\\cdots,m\\right\\}$（其中$x^{(i)}=\\left(x_1^{(i)},x_2^{(i)},\\cdots,x_{n_i}^{(i)}\\right)$代表训练集第$i$封样本邮件特征值向量，邮件共有$n_i$个单词），参数的似然函数为：\n", 24 | "\n", 25 | "$$\\begin{align}\\mathcal{L}\\left(\\phi_y,\\phi_{k\\mid y=0},\\phi_{k\\mid y=1}\\right)&=\\prod_{i=1}^mp\\left(x^{(i)},y^{(i)}\\right)\\\\&=\\prod_{i=1}^m\\left(\\left(\\prod_{j=1}^{n_i}p\\left(x_j^{(i)}\\mid y;\\phi_{k\\mid y=1},\\phi_{k\\mid y=0}\\right)\\right)p\\left(y^{(i)};\\phi_y\\right)\\right)\\end{align}$$\n", 26 | "\n", 27 | "最大化似然函数将得到各参数的最大似然估计：\n", 28 | "\n", 29 | "$$\\begin{align}\\phi_{k\\mid y=1}&=p(x_j=k\\mid y=1)&=\\frac{\\sum_{i=1}^m\\sum_{j=1}^{n_i}1\\left\\{x_j^{(i)}=k\\land y^{(i)}=1\\right\\}}{\\sum_{i=1}^m1\\left\\{y^{(i)}=1\\right\\}n_i}\\\\\\phi_{k\\mid y=0}&=p(x_j=k\\mid y=0)&=\\frac{\\sum_{i=1}^m\\sum_{j=1}^{n_i}1\\left\\{x_j^{(i)}=k\\land y^{(i)}=0\\right\\}}{\\sum_{i=1}^m1\\left\\{y^{(i)}=0\\right\\}n_i}\\\\\\phi_y&=p(y=1)&=\\frac{\\sum_{i=1}^m1\\left\\{y^{(i)}=1\\right\\}}{m}\\end{align}$$\n", 30 | "\n", 31 | "我们对$\\phi_{k\\mid y=0},\\phi_{k\\mid y=1}$应用拉普拉斯平滑（在实际问题中应用拉普拉斯平滑通常可以得到更好的模型），即在分子上加一，分母上加$\\lvert V\\rvert$，得到：\n", 32 | "\n", 33 | "$$\\begin{align}\\phi_{k\\mid y=1}&=\\frac{\\left(\\sum_{i=1}^m\\sum_{j=1}^{n_i}1\\left\\{x_j^{(i)}=k\\land y^{(i)}=1\\right\\}\\right)+1}{\\left(\\sum_{i=1}^m1\\left\\{y^{(i)}=1\\right\\}n_i\\right)+\\lvert V\\rvert}\\\\\\phi_{k\\mid y=0}&=\\frac{\\left(\\sum_{i=1}^m\\sum_{j=1}^{n_i}1\\left\\{x_j^{(i)}=k\\land y^{(i)}=0\\right\\}\\right)+1}{\\left(\\sum_{i=1}^m1\\left\\{y^{(i)}=0\\right\\}n_i\\right)+\\lvert V\\rvert}\\end{align}$$\n", 34 | "\n", 35 | "在处理文本分类问题时，多项事件模型通常比原始的朴素贝叶斯算法效果更好，一个可能的原因是因为它考虑了每个单词出现的次数。\n", 36 | "\n", 37 | "尽管朴素贝叶斯分类器不是最好的分类算法，但它的效果一般都非常好，再加上它简单且易于实现的特性，我们通常用它作为“首选试验算法”。（使用朴素贝叶斯算法最终会得到一个逻辑函数形式的后验分布，也就是说，朴素贝叶斯算法也属于指数分布族，它仍然是一个线性分类器。）\n", 38 | "\n" 39 | ] 40 | } 41 | ], 42 | "metadata": { 43 | "kernelspec": { 44 | "display_name": "Python 2", 45 | "language": "python", 46 | "name": "python2" 47 | }, 48 | "language_info": { 49 | "codemirror_mode": { 50 | "name": "ipython", 51 | "version": 2 52 | }, 53 | "file_extension": ".py", 54 | "mimetype": "text/x-python", 55 | "name": "python", 56 | "nbconvert_exporter": "python", 57 | "pygments_lexer": "ipython2", 58 | "version": "2.7.13" 59 | } 60 | }, 61 | "nbformat": 4, 62 | "nbformat_minor": 1 63 | } 64 | -------------------------------------------------------------------------------- /other/note/LSJU-chapter19.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 第十九讲：微分动态规划及线性二次型高斯\n", 8 | "\n", 9 | "在继续学习之前，我们先来回顾一下[上一讲](chapter18.ipynb)的内容：\n", 10 | "* 其目标是$\\displaystyle\\max_a\\mathrm E\\left[R^{(0)}(s_0,a_0)+R^{(1)}(s_1,a_1)+\\cdots+R^{(T)}(s_T,a_T)\\right]$；\n", 11 | "* 之后我们应用了动态规划算法：\n", 12 | " $$\n", 13 | " \\begin{align}\n", 14 | " V_T^*(s)&=\\max_{a_T}R(s_T,a_T)\\tag{1}\\\\\n", 15 | " V_t^*(s)&=\\max_a\\left(R(s,a)+\\sum_{s'}P_{sa}^{(t)}\\left(s'\\right)V_{t+1}^*\\left(s'\\right)\\right)\\tag{2}\\\\\n", 16 | " \\pi_t^*(s)&=\\arg\\max_a\\left(R(s,a)+\\sum_{s'}P_{sa}^{(t)}\\left(s'\\right)V_{t+1}^*\\left(s'\\right)\\right)\\tag{3}\n", 17 | " \\end{align}\n", 18 | " $$\n", 19 | " 其中$(1)$式是有限时域MDP的最后一步；得出最后一步后就可以使用$(2)$式向后递推每一个$V_{T-1},\\cdots,V_{0}$；最后，在使用$\\arg\\max$对每一步价值函数最大化的部分做运算，就可以得到每一步的最优策略。\n", 20 | "* 接下来我们介绍了一个具体的LQR问题：\n", 21 | " * 状态为$S\\in\\mathbb R^n$；\n", 22 | " * 动作为$A\\in\\mathbb R^d$；\n", 23 | " * 将下一步作为关于当前状态及动作的函数$s_{t+1}=A_ts_t+B_ta_t+w_t$，此处的$w_t\\sim\\mathcal N(0,\\varSigma_w)$是一个期望为零、协方差为$\\varSigma_w$的高斯噪音项。\n", 24 | "* 上面定义中有了关于当前状态及动作的函数$s_{t+1}=f(s_t,a_t)$，我们就可以选择一个系统长时间保持的状态（系统通常都会都处于这种状态）$(\\bar s_t,\\bar a_t)$，在该点使用线性函数近似非线性函数$s_{t+1}=f(s_t,a_t)$，进而得到$\\displaystyle s_{t+1}\\approx f(\\bar s_t,\\bar a_t)+(\\nabla_sf(\\bar s_t,\\bar a_t))^T(s_t-\\bar s_t)+(\\nabla_af(\\bar s_t,\\bar a_t))^T(a_t-\\bar a_t)$。最终能够在$(\\bar s_t,\\bar a_t)$附近得到一个线性函数$s_{t+1}=A_ts_t+B_ta_t$。\n", 25 | "* LQR的奖励函数为$\\displaystyle R^{(t)}(s_t,a_t)=-\\left(s_t^TU_ts_t+a^TV_ta_t\\right)$，其中矩阵$U,V$是半正定的，所以这个奖励函数总是非正数；\n", 26 | "* 对LQR使用上面的动态规划得到求解方法：\n", 27 | " * 使用$\\varPhi_t=-U_t,\\varPsi_t=0$初始化$V_T^*$；\n", 28 | " * 向后递推计算$\\varPhi_t,\\varPsi_t$，使用离散时间Riccati方程，将其当做关于$\\varPhi_{t+1},\\varPsi_{t+1}$的线性函数；（依次求出$t=T-1,T-2,\\cdots,0$。）\n", 29 | " $$\n", 30 | " \\begin{align}\n", 31 | " \\varPhi_t&=A_t^T\\left(\\varPhi_{t+1}-\\varPhi_{t+1}B_t\\left(B_t^T\\varPhi_{t+1}B_t-V_t\\right)^{-1}B_t\\varPhi_{t+1}\\right)A_t-U_t\\\\\n", 32 | " \\varPsi_t&=-\\mathrm{tr}\\varSigma_w\\varPhi_{t+1}+\\varPsi_{t+1}\n", 33 | " \\end{align}\n", 34 | " $$\n", 35 | " * 计算$\\displaystyle L_t=\\left(B_t^T\\varPhi_{t+1}B_t-V_t\\right)^{-1}B_t^T\\varPhi_{t+1}A_t$，这是一个关于$\\varPhi_{t+1},\\varPsi_{t+1}$的函数；\n", 36 | " * 计算$\\pi^*(s_t)=L_ts_t$，这是一个关于$s_t$的线性函数，系数是$L_t$。\n", 37 | " \n", 38 | " 这个算法中有趣的一点是，$L_t$不依靠$\\varPsi_t$，$\\varPhi_t$也不依赖于$\\varPsi_t$。所以，即使我们从不考虑$\\varPsi$也不会影响最终的结果。另一个有趣的地方在于$\\varSigma_w$只在$\\varPsi_t$中出现，再看LQR定义中的$s_{t+1}=A_ts_t+B_ta_t+w_t$可以得出，即使在不知道噪音项协方差的前提下，也可以正确的求出最优策略（但不要忘了最优价值函数是受$\\varPsi$影响的）。最后，这两点都是对这个特殊LQR模型（非线性动力系统）独有的，一旦我们对模型做出改变，则这两个特性将不复存在，也就是只有在这个例子中才有“最优策略不受噪音项协方差影响”。在后面讨论Kalman滤波的时候会用到这个性质。\n", 39 | "\n", 40 | "## 8. 强化学习算法的调试\n", 41 | "\n", 42 | "我们在[第十一讲](chapter11.ipynb)中，在关于机器学习算法的调试介绍过直升机模型提到：\n", 43 | "\n", 44 | "1. 搭建一个遥控直升机模拟器，主要是对状态转换概率$P_{sa}$进行建模（比如通过学习物理知识，依照空气动力学原理编写模拟器；或者也可以收集大量试验数据，通过拟合这些数据一个线性或非线性模型，以得到一个用当前状态、当前操作表示下一步状态的函数）；\n", 45 | "2. 选择奖励函数，比如$R(s)=\\left\\lVert s-s_\\mathrm{desired}\\right\\rVert^2$（$s$代表直升机当前的位置，这里示例的函数表示直升机实际位置与期望位置的平方误差，我们在[上一讲](chapter18.ipynb)的LQR中已经使用过这个奖励函数了）；\n", 46 | "3. 在模拟器中运行强化学习算法控制直升机并尝试最大化奖励函数，$\\mathrm E\\left[R(s_0)+R(s_1)+\\cdots+R(s_T)\\right]$，进而求得对应的策略$\\pi_\\mathrm{RL}$。\n", 47 | "\n", 48 | "现在，假设我们已经按照上述步骤得到了控制模型，但是发现该模型比人类直接操作差很多，接下来应该怎么办呢？我们可能会：\n", 49 | "* 改进模拟器（也许模拟器所用的模型不是线性或非线性的；也许需要收集更多数据来拟合模型；也许需要调整拟合模型时所使用的特征值）；\n", 50 | "* 修改奖励函数$R$（也许它不只是一个二次函数）；\n", 51 | "* 改进学习算法（也许RL并不适合这个问题；也许需要对状态进行更精细的描述；也许在价值函数近似过程中使用的特征值需要调整）；\n", 52 | "\n", 53 | "对于调整算法这样的任务，我们有太多的选择方向，如果选择错误，则将会浪费大量的时间精力。\n", 54 | "\n", 55 | "接下来我们假设：\n", 56 | "1. 直升机模拟器足够精确；\n", 57 | "2. RL算法能够在模拟器中正确的控制飞机，因此算法正确的最大化了预期总收益$V_t^{\\pi_\\mathrm{RL}}(s_0)=\\mathrm E\\left[R(s_0)+R(s_1)+\\cdots+R(s_T)\\mid\\pi_\\mathrm{RL},s_t=s_0\\right]$；\n", 58 | "3. 最大化预期总收益与模型正确的操作飞机强相关。\n", 59 | "\n", 60 | "如果上述三条假设均正确，则可以推出$\\pi_\\mathrm{RL}$能够控制好真正的直升机。\n", 61 | "\n", 62 | "于是，我们可以**依次**做出如下诊断：\n", 63 | "1. 首先，如果$\\pi_\\mathrm{RL}$在模拟器中飞的很好，但是在实际飞机上却表现不好，则说明是模拟器的问题；\n", 64 | "2. 然后，用$\\pi_\\mathrm{human}$表示人类操纵者在操纵直升机时使用的策略，比较人类和算法的策略所对应的价值函数，如果$V^{\\pi_\\mathrm{RL}}\\lt V^{\\pi_\\mathrm{human}}$，则说明是RL算法的问题。（算法并没有成功的最大化预期总收益。）\n", 65 | "3. 最后，如果经比较发现$V^{\\pi_\\mathrm{RL}}\\gt V^{\\pi_\\mathrm{human}}$，则说明问题出在奖励函数上。（最大化这个奖励函数并没有使得飞行水平提高。）\n", 66 | "\n", 67 | "以上仅是一个强化学习调试的例子，因为我们恰好找到了一个极优秀的直升机操纵者，如果没有的话则需要想出别的调试方法。在通常的问题中，我们都需要自己找出针对问题的有效的调试方法。\n", 68 | "\n", 69 | "## 9. 微分动态规划（DDP: Differential Dynamic Programming）\n", 70 | "\n", 71 | "继续使用遥控直升机的例子，假设我们已经有模拟器并可以通过模拟器知道$s_{t+1}=f(s_t,a_t)$（即下一个状态是一个关于当前状态及动作的函数），而且这个模拟器是非线性、确定性的，噪音项也比较小。我们现在想要让直升机飞出一些特定轨迹，于是：\n", 72 | "1. 先写出这个轨迹：$(\\bar s_0,\\bar a_0),(\\bar s_1,\\bar a_1),\\cdots,(\\bar s_T,\\bar a_T)$，这也称为**标准轨迹（nominal trajectory）**；（这个轨迹也可能来自一个很粗糙的控制算法，但是虽然粗糙，却也是描述的我们想要做出的动作，比如在空中做$90^\\circ$转弯之类的动作。）\n", 73 | "2. 然后，我们在这个轨迹附近线性化$f$得到：$\\displaystyle s_{t+1}\\approx f(\\bar s_t,\\bar a_t)+(\\nabla_sf(\\bar s_t,\\bar a_t))^T(s_t-\\bar s_t)+(\\nabla_af(\\bar s_t,\\bar a_t))^T(a_t-\\bar a_t)$，也就是说能够得到一个线性函数$s_{t+1}=A_ts_t+B_ta_t$。我们这是在课程中第一次使用LQR来处理有限时域上的非平稳的动态问题，尤其要注意的是这里的$A_t,B_t$是依赖于时间的（也就是这是一系列不相等的矩阵）；（即使标准轨迹来自一套很糟糕的控制，但我们仍然希望系统在$t$时刻的状态和动作能够近似于这个糟糕的轨迹。也许这个控制算法做的工作很马虎，但毕竟这个轨迹描述了我们想要得到的动作，也就是希望$(s_t,a_t)\\approx(\\bar s_t,\\bar a_t)$。）\n", 74 | "3. 有了线性模型，再使用LQR计算最优策略$\\pi_t$，于是我们就会得到一个更好的策略；\n", 75 | "4. 在模拟器中按照新的策略实现一个新的轨迹，也就是：\n", 76 | " * 用$\\bar s_0$初始化模拟器；\n", 77 | " * 用刚学到的$\\pi_t$控制每一步的动作$a_t=\\pi_t(\\bar s_t)$；\n", 78 | " * 最终得到一套新的轨迹$\\bar s_{t+1}=f(\\bar s_t,\\bar a_t)$\n", 79 | "5. 得到新的轨迹后，我们就可以继续重复上面的操作，不停的优化这个轨迹（也就是重复步骤2-5）。\n", 80 | "\n", 81 | "在实践中能够知道，这是一个非常有效的算法，DDP实际上是一种局部搜索算法，在每次迭代中，找到一个稍好的点进行线性化，进而得到一个稍好的策略，重复这个动作最终就可以得到一个比较好的策略了。（“微分”指的就是每次迭代我们都会选择一个点并通过求导做线性化。）\n", 82 | "\n", 83 | "## 10. 线性二次型高斯（LQG: Linear Quadratic Gaussian）\n", 84 | "\n", 85 | "### 10.1 Kalman滤波（Kalman Filter）\n", 86 | "\n", 87 | "现在介绍另一种类型的MDP，在这种MDP中，我们并不能直接观察到每一步的状态（在前面的MDP中我们都会假设系统的状态已知，于是可以计算出策略，它是一个关于状态的函数；在LQR中我们也是计算$L_ts_t$，状态都是已知的）。\n", 88 | "\n", 89 | "我们暂时先不谈控制，来说说普通的不能观察到状态信息的动态系统。举个例子，我们对“使用雷达追踪飞行器”的过程进行极其简化的建模：线性模型$s_{t+1}=As_t+w_t$，其中$s_t=\\begin{bmatrix}x_t\\\\\\dot x_t\\\\y_t\\\\\\dot y_t\\end{bmatrix},\\ A=\\begin{bmatrix}1&1&0&0\\\\0&0.9&0&0\\\\0&0&1&1\\\\0&0&0&0.9\\end{bmatrix}$（这是一个非常简化的模型，可以理解为一架在2D空间中移动的飞机）。\n", 90 | "\n", 91 | "在这个简化模型中我们无法观察到每一步的状态，但假设我们可以观察到另一个量——$y_t=Cs_t+v_t,\\ v_t\\sim\\mathcal N(0,\\varSigma_v)$：比如$C=\\begin{bmatrix}1&0&0&0\\\\0&0&1&0\\end{bmatrix}$，则有$Cs_t=\\begin{bmatrix}x_t\\\\y_t\\end{bmatrix}$。这个量可能是雷达追踪到的飞行器的位置（只能得到位置相关的状态，而不能得到加速度相关的状态）。比如说在$\\mathrm{xOy}$平面上，有一个雷达位于$x$轴某点，其视角沿$y$轴正方向大致对着飞行器，并依次观察到一系列飞行器移动过程中的不连续的点，因为雷达视角沿$y$轴正半轴方向，所以得到的点的坐标的纵坐标的噪音（方差）应该大于横坐标的方差，可以说这些点分别位于一个个小的高斯分布中，而这些高斯分布的协方差矩阵应该型为$\\varSigma=\\begin{bmatrix}a&0\\\\0&b\\end{bmatrix},\\ a\\gt b$（即因为在$y$轴方向上的观测结果更容易出现偏差，所以等高线图中椭圆的长轴会沿着$y$轴方向。）而我们想要做的就是通过观测到的一系列坐标估计飞行器在每个观测点的状态$P(s_t\\mid y_1,\\cdots,y_t)$。\n", 92 | "\n", 93 | "$s_0,\\cdots,s_t;\\ y_0,\\cdots,y_t$组成了一个高斯分布的联合分布（多元正态分布），可以用$z=\\begin{bmatrix}s_0\\\\\\vdots\\\\s_t\\\\y_0\\\\\\vdots\\\\y_t\\end{bmatrix},\\ z\\sim\\mathcal N(\\mu,\\varSigma)$表示，再结合[第十三讲](chapter13.ipynb)中了解的多元正态分布的边缘分布与条件分布的计算方法，我们就可以对$P(s_t\\mid y_1,\\cdots,y_t)$进行求解。虽然这个思路在概念上是可行的，但是在实际中跟踪一个飞行器会得到成千上万个位置，于是就会有一个巨大的协方差矩阵（期望向量和协方差矩阵都会随着时间、步数的增长呈线性增长，在计算过程中需要用到的边缘分布、条件分布都可能会使用协方差的逆，而计算协方差的逆的复杂度是矩阵规模的平方级别），所以对于计算来说可行性较低。\n", 94 | "\n", 95 | "于是我们引入**Kalman滤波（Kalman Filter）**算法来解决这个效率问题。这个算法实际上是一个隐式马尔可夫模型，使用递推的方式计算，下面写出算法的步骤，算法的思路可以在[Hidden Markov Models](http://cs229.stanford.edu/section/cs229-hmm.pdf)中找到：\n", 96 | "* 第一步称为**预测（predict）**步骤，使用$P(s_t\\mid y_1,\\cdots,y_t)$对$P(s_{t+1}\\mid y_1,\\cdots,y_t)$进行预测；\n", 97 | " * 有$s_t\\mid y_0,\\cdots,y_t\\sim\\mathcal N\\left(s_{t\\mid t},\\varSigma_{t\\mid t}\\right)$；\n", 98 | " * 则有$s_{t+1}\\mid y_0,\\cdots,y_t\\sim\\mathcal N\\left(s_{t+1\\mid t},\\varSigma_{t+1\\mid t}\\right)$；\n", 99 | " * 其中$\\begin{cases}s_{t+1\\mid t}&=As_{t\\mid t}\\\\ \\varSigma_{t+1\\mid t}&=A\\varSigma_{t\\mid t}A^T+\\varSigma_t\\end{cases}$；\n", 100 | " * 需要说明的是，我们使用诸如$s_t,y_t$表示模型的真实状态（如为观测到的实际状态，已观测到的实际位置），而使用$s_{t\\mid t},s_{t+1\\mid t},\\varSigma_{t\\mid t}$表示由计算得到的值；\n", 101 | "* 第二步称为**更新（update）**步骤，使用上一步预测的$P(s_{t+1}\\mid y_1,\\cdots,y_t)$更新$P(s_{t+1}\\mid y_1,\\cdots,y_{t+1})$，也就是有了预测结果之后再将对应的样本纳入模型：\n", 102 | " * 其中$s_{t+1\\mid t+1}=s_{t+1\\mid t}+K_{t+1}\\cdot\\left(y_{t+1}-Cs_{t+1\\mid t}\\right)$；\n", 103 | " * 而$K_{t+1}=\\varSigma_{t+1\\mid t}C^T\\left(C\\varSigma_{t+1\\mid t}C^T+\\varSigma_t\\right)^{-1}$；\n", 104 | " * $\\varSigma_{t+1\\mid t+1}=\\varSigma_{t+1\\mid t}+\\varSigma_{t+1\\mid t}\\cdot C^T\\left(C\\varSigma_{t+1\\mid t}C^T+\\varSigma_t\\right)^{-1}C\\varSigma_{t+1\\mid t}$\n", 105 | "\n", 106 | " Kalman滤波算法的复杂度比计算协方差矩阵的逆低很多，因为采用了递推的计算过程，每当步骤增加，则只需多执行一步迭代，而且无需保留太多数据在内存中，相比于求一个巨大矩阵的逆而言，算法复杂度低了很多：\n", 107 | " $$\n", 108 | " \\require{AMScd}\n", 109 | " \\begin{CD}\n", 110 | " y_1 @. y_2 @. y_3 \\\\\n", 111 | " @VVV @VVV @VVV \\\\\n", 112 | " P\\left(s_1\\mid y_1\\right) @>>> P\\left(s_2\\mid y_1,y_2\\right) @>>> P\\left(s_3\\mid y_1,y_2,y_3\\right) @>>> \\cdots\n", 113 | " \\end{CD}\n", 114 | " $$\n", 115 | " 从这个草图可以看出来，当计算$P\\left(s_3\\mid y_1,y_2,y_3\\right)$时，我们并不需要$y_1,y_2,P\\left(s_1\\mid y_1\\right)$，每步计算只需要知道最新的观测值和上一步得出的概率估计即可。\n", 116 | "\n", 117 | "### 10.2 LQG\n", 118 | "\n", 119 | "将Kalman滤波与LQR结合起来就可以得到**线性二次高斯（LQG: Linear Quadratic Gaussian）**线性二次高速算法。在LQR问题中，我们将动作$a_t$加回到模型中：设非线性动力学系统为$s_{t+1}=As_t+Ba_t+w_t,\\ w\\sim\\mathcal N(0,\\varSigma_w)$，而且我们无法直接观测到状态，只能观测到$y_t=Cs_t+v_t,\\ v\\sim\\mathcal N(0,\\varSigma_v)$。现在使用Kalman滤波估计状态：\n", 120 | "* 假设初始状态为$s_{0\\mid0}=s_0,\\varSigma_{0\\mid0}=0$；（如果不知道确切初始状态，测可以大致估计初始状态$s_0\\sim\\mathcal N\\left(s_{0\\mid0},\\varSigma_{0\\mid0}\\right)$，即使用初始状态的平均值和协方差的估计。）\n", 121 | "* 预测步骤，$\\begin{cases}s_{t+1\\mid t}&=As_{t\\mid t}+Ba_t\\\\\\varSigma_{t+1\\mid t}&=A\\varSigma_{t\\mid t}A^T+\\varSigma_t\\end{cases}$。如此，我们就“解决”为了状态观测不到的问题（这里的$A,B$都是已知项）；\n", 122 | "* 控制步骤，按照LQR算法中的最优动作$a_t=L_ts_t$计算其中的$L_t$，并暂时忽略观测不到状态的问题；得到$L_t$后，选择$a_t=L_ts_{t\\mid t}$作为最优动作（换句话说，因为不知道状态，所以我们对状态的最佳估计就是$s_{t\\mid t}$）。\n", 123 | "\n", 124 | "这个算法实际上是先设计了一个状态估计算法，然后再使用了一个控制算法，把两个算法结合起来就得到了LQG。" 125 | ] 126 | } 127 | ], 128 | "metadata": { 129 | "kernelspec": { 130 | "display_name": "Python 3", 131 | "language": "python", 132 | "name": "python3" 133 | }, 134 | "language_info": { 135 | "codemirror_mode": { 136 | "name": "ipython", 137 | "version": 3 138 | }, 139 | "file_extension": ".py", 140 | "mimetype": "text/x-python", 141 | "name": "python", 142 | "nbconvert_exporter": "python", 143 | "pygments_lexer": "ipython3", 144 | "version": "3.5.2" 145 | } 146 | }, 147 | "nbformat": 4, 148 | "nbformat_minor": 0 149 | } 150 | -------------------------------------------------------------------------------- /other/note/LSJU-chapter20.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 第二十讲：策略搜索算法\n", 8 | "\n", 9 | "回忆[上一讲](chapter19.ipynb)的内容，实际上上一讲的例子就是一个部分可观测MDP的特例。\n", 10 | "\n", 11 | "在原LQR问题中有模型$s_{t+1}=As_t+Ba_t+w_t$，我们改变了条件，假设只能观测到$y_t=Cs_t+v_t$（不能直接观测到状态，只能观测到某些关于状态的函数，并需要根据这些观测值对最优动作作出判断）。\n", 12 | "\n", 13 | "在状态完全可观测的情形下，我们可以根据$a_t=L_ts_t$选择动作；而在部分可观测的例子中，我们会使用$s_{t\\mid t}$估计$s_t$，然后使用Kalman滤波的思想$s_{t\\mid y_0,\\cdots,y_t}\\sim\\mathcal N\\left(s_{t\\mid t},\\varSigma_{t\\mid t}\\right)$计算这个估计$s_{t\\mid t}$。\n", 14 | "\n", 15 | "最后，我们使用$a_t=L_ts_{t\\mid t}$选择最优动作。事实上这个算法让我们能够在不完全清楚系统每一个状态的前提下选择尽可能好的策略，而在一个部分可观测MDP中求最优策略是一个NP困难问题。\n", 16 | "\n", 17 | "### 10.3 部分可观测MDP（POMDP: Partial Observed MDP）\n", 18 | "\n", 19 | "我们现在给出POMDP的正式描述——七元组$(S,A,Y,\\{P_{sa}\\},\\{O_s\\},T,R)$：\n", 20 | "* $Y$是可观测到的值的集合；\n", 21 | "* $O$是可观测到的值的分布；\n", 22 | " \n", 23 | " 也就是在每个$s_t$下都能够观测到某个服从$y_t\\sim O_{s_t}$的随机变量。上一讲中我们介绍的在线性动力学系统中的特例可以使用Kalman过滤算法，从观测值中估计状态，再通过状态计算最优策略。然而这个算法仅对上一讲那个的特例（上一讲的例子也是POMDP的特例）有效，不过这个算法对普通的POMDP问题也有一定的效果，只是对该问题这个算法不一定是最优的算法。\n", 24 | "\n", 25 | "## 12. 策略搜索（Policy Search）\n", 26 | "\n", 27 | "再来介绍一个不同的强化学习算法——策略搜索算法，看名字就大概可以猜出，它可以被用于完全可观测MDP（Fully Observed MDP）或部分可观测MDP的最优策略求解。下面我们先来介绍策略搜索算法在完全可观测MDP中的应用。（在后面我们会介绍如何将策略搜索应用在POMDP上，但这并不能保证算法会找到全局最优解，策略搜索通常在POMDP中找到的是局部最优策略。解决POMDP是异常困难的，而策略搜索算法在实践中被证明是最好的POMDP解决算法之一。）\n", 28 | "\n", 29 | "* 首先定义$\\varPi$为策略的集合，而我们的算法就是在$\\varPi$中搜索$\\pi\\in\\varPi$。可以类比前面在监督学习算法中的概念——从假设类$\\mathcal H$中搜索最优假设$h$（参见[第九讲](chapter09.ipynb)）。\n", 30 | "\n", 31 | " 在之前的关于MDP的算法中，我们都是通过解出最优价值函数$V^*$进而得到最优策略$\\pi^*$的。而在策略搜索算法中——有时被称作直接搜索算法——我们会“直接”去寻找最优策略（不再通过中间的步骤——计算最优价值函数）。\n", 32 | "\n", 33 | "* 接下来再定义随机策略——是一个函数$\\pi:S\\times A\\to\\mathbb R$，$\\pi(s,a)$表示在状态$s$执行动作$a$的概率。从定义就可以知道，函数$\\pi$实际上是事件“在状态$s$执行动作$a$的概率”的概率密度函数，满足$\\displaystyle\\sum_a\\pi(s,a)=1,\\pi(s,a)\\geq0$。换句话说，对于每一个状态，函数$\\pi$都确定了一个在$a$上的分布。\n", 34 | "\n", 35 | " 举个例子，假设我们要执行随机的策略$\\pi$，而在当前的MDP中有三个动作$a_t\\in\\{a_1,a_2,a_3\\}$，那么我们执行动作$a_1$的概率就是$\\pi(s,a_1)$、执行动作$a_2$的概率就是$\\pi(s,a_2)$、执行动作$a_3$的概率就是$\\pi(s,a_3)$。这个过程就是执行一个随机策略。\n", 36 | "\n", 37 | "下面继续使用倒置钟摆的例子来讲解策略搜索算法，我们定义$\\phi$为钟摆偏离竖直位的角度，$a_1$是向右的加速度，$a_2$是向左的加速度。再找一个奖励函数，杆不论倒向那一边都对模型做出惩罚。提出一类随机策略意味着提出一类函数，这类函数被用来估计在状态$s_t$下将要执行的行动$a_t$。而现在，我们选择逻辑函数作为我们的策略，因为它是我们经常使用的一个很方便的函数：\n", 38 | "$$\n", 39 | "\\begin{align}\n", 40 | "\\pi_\\theta(s,a_1)&=\\frac{1}{1+e^{-\\theta^Ts}}\\\\\n", 41 | "\\pi_\\theta(s,a_2)&=1-\\frac{1}{1+e^{-\\theta^Ts}}\n", 42 | "\\end{align}\n", 43 | "$$\n", 44 | "因为我们不是选择$a_1$就是选择$a_2$，所以选择它们的概率之和为$1$。举个例子解释这个选择的合理性，假设我们的状态向量为$s=\\begin{bmatrix}1\\\\x\\\\\\dot x\\\\\\phi\\\\\\dot\\phi\\end{bmatrix}$（这里添加了$1$作为截距项给逻辑回归一个额外的特征值），如果我们选择$\\theta=\\begin{bmatrix}0\\\\0\\\\0\\\\1\\\\0\\end{bmatrix}$，则有$P\\displaystyle\\left(a=\\textrm{\"right\"}\\right)=\\frac{1}{1+e^{-\\theta^Ts}}=\\frac{1}{1+e^{-\\phi}}$，这说明“向右加速”的概率只取决于“杆的倾角$\\phi$”，所以当的杆向右偏的时候小车就会尝试向右加速以接住杆。当然，这个例子里的参数选择并不是最优的，因为它忽略的别的参数。现在，我们的目标就是调整$\\theta$，使得当执行$\\pi_\\theta$时能够让杆尽可能的保持竖直，也就是说，我们的目标是选择一个参数$\\theta$使得执行$\\pi_\\theta$时的预期总收益最大化。再举个例子，如果有$d$个离散的动作，那么我们也可以用[第四讲](chapter04.ipynb)提到的softmax回归$\\displaystyle\\theta_1,\\cdots,\\theta_d;\\ \\pi_{\\theta_i}(s,a_i)=\\frac{e^{\\theta_i^Ts}}{\\sum_je^{\\theta_j^Ts}}$，策略类型的选择是可以自己确定的，线性函数、使用二次特征值的线性函数、监督学习算法等等。\n", 45 | "\n", 46 | "### 12.1 增强算法（Reinforce algorithm）\n", 47 | "\n", 48 | "设$s_0$是一个固定的初始化状态（即从一个确定的初始状态分布中抽样得到），我们的目标是：\n", 49 | "\n", 50 | "$$\n", 51 | "\\begin{align}\n", 52 | "\\max\\ &\\mathrm E[R(s_0,a_0)+\\cdots+R(s_T,a_T]\\\\\n", 53 | "&=\\sum_{(s_0,a_0),\\cdots,(s_T,a_T)}P(s_0a_0\\cdots s_Ta_T)[R(s_0,a_0)+\\cdots+R(s_T,a_T)]\\tag{1}\\\\\n", 54 | "&=\\sum_{(s_0,a_0),\\cdots,(s_T,a_T)}P(s_0)\\pi_\\theta(s_0,a_0)P_{s_0a_0}(s_1)\\pi_\\theta(s_1,a_1)P_{s_1a_1}(s_2)\\cdots P_{s_{T-1}\\ a_{T-1}}\\ (s_T)\\pi_\\theta(s_T,a_T)\\cdot\\underbrace{[R(s_0,a_0)+\\cdots+R(s_T,a_T)]}_{\\textrm{payoff}}\\tag{2}\n", 55 | "\\end{align}\n", 56 | "$$\n", 57 | "\n", 58 | "在后面我们就将$R(s_0,a_0)+\\cdots+R(s_T,a_T)$部分简称为收益（payoff），先写出算法步骤：\n", 59 | "\n", 60 | "* 重复：`{`\n", 61 | " * 抽样：$s_0,a_0,s_1,a_1,\\cdots,s_T,a_t$\n", 62 | " * 计算收益：$R(s_0,a_0)+\\cdots+R(s_T,a_T)$\n", 63 | " * 更新参数：$\\displaystyle\\theta:=\\theta+\\alpha\\left[\\frac{\\nabla_\\theta\\pi_\\theta(s_0,a_0)}{\\pi_\\theta(s_0,a_0)}+\\cdots+\\frac{\\nabla_\\theta\\pi_\\theta(s_T,a_T)}{\\pi_\\theta(s_T,a_T)}\\right]\\cdot[R(s_0,a_0)+\\cdots+R(s_T,a_T)]$\n", 64 | " \n", 65 | " `}`\n", 66 | "\n", 67 | "算法的第一步就是随机抽样得到一个状态-动作序列，也就是在MDP中执行当前的随机策略——从某个$s_0$开始，根据随机策略选择一个动作$a_0$，然后看状态转换概率给出的下一个状态，继续重复执行策略。第二步就是计算收益。第三步更新参数。\n", 68 | "\n", 69 | "由于这个算法执行的是随机策略，所以我们想知道它为什么这样更新参数。我们可以计算更新参数步骤的期望，只要更新参数后带来的收益呈增长趋势，我们就对算法是满意的。实际上这个算法类似随机梯度上升，它将在局部最优解附近“游荡”，但总趋势是向局部最优解前进。\n", 70 | "\n", 71 | "回顾上面的$(2)$式，它表示概率与收益之积在所有状态上的和，我们现在要做的就是对$(2)$式求关于$\\theta$的导数，因为我们想对这个式子做梯度上升：\n", 72 | "$$\n", 73 | "\\begin{align}\n", 74 | "\\nabla_\\theta\\mathrm E\\left[R(s_0,a_0)+\\cdots+R(s_T,a_T)\\right]\n", 75 | "=\\sum_{(s_0,a_0),\\cdots,(s_T,a_T)}\n", 76 | "&\\Bigg[\\ P(s_0)\\underline{(\\nabla_\\theta\\pi_\\theta(s_0,a_0))}P_{s_0a_0}(s_1)\\pi_\\theta(s_1,a_1)P_{s_1a_1}(s_2)\\cdots P_{s_{T-1}\\ a_{T-1}}\\ (s_T)\\pi_\\theta(s_T,a_T)\\\\\n", 77 | "&+P(s_0)\\pi_\\theta(s_0,a_0)P_{s_0a_0}(s_1)\\underline{(\\nabla_\\theta\\pi_\\theta(s_1,a_1))}P_{s_1a_1}(s_2)\\cdots P_{s_{T-1}\\ a_{T-1}}\\ (s_T)\\pi_\\theta(s_T,a_T)\\\\\n", 78 | "&+\\cdots\\\\\n", 79 | "&+P(s_0)\\pi_\\theta(s_0,a_0)P_{s_0a_0}(s_1)\\pi_\\theta(s_1,a_1)P_{s_1a_1}(s_2)\\cdots P_{s_{T-1}\\ a_{T-1}}\\ (s_T)\\underline{(\\nabla_\\theta\\pi_\\theta(s_T,a_T))}\\ \\Bigg]\\\\\n", 80 | "&\\times[R(s_0,a_0)+\\cdots+R(s_T,a_T)]\\\\\n", 81 | "=\\sum_{(s_0,a_0),\\cdots,(s_T,a_T)}&P(s_0)\\pi_\\theta(s_0,a_0)P_{s_0a_0}(s_1)\\pi_\\theta(s_1,a_1)P_{s_1a_1}(s_2)\\cdots P_{s_{T-1}\\ a_{T-1}}\\ (s_T)\\pi_\\theta(s_T,a_T)\\\\\n", 82 | "&\\times\\left[\\frac{\\nabla_\\theta\\pi_\\theta(s_0,a_0)}{\\pi_\\theta(s_0,a_0)}+\\frac{\\nabla_\\theta\\pi_\\theta(s_1,a_1)}{\\pi_\\theta(s_1,a_1)}+\\cdots+\\frac{\\nabla_\\theta\\pi_\\theta(s_T,a_T)}{\\pi_\\theta(s_T,a_T)}\\right]\\\\\n", 83 | "&\\times[R(s_0,a_0)+\\cdots+R(s_T,a_T)]\\\\\n", 84 | "=\\sum_{(s_0,a_0),\\cdots,(s_T,a_T)}&P(s_0a_0\\cdots s_Ta_T)\\cdot\\left[\\frac{\\nabla_\\theta\\pi_\\theta(s_0,a_0)}{\\pi_\\theta(s_0,a_0)}+\\cdots+\\frac{\\nabla_\\theta\\pi_\\theta(s_T,a_T)}{\\pi_\\theta(s_T,a_T)}\\right]\\\\\n", 85 | "&\\times[R(s_0,a_0)+\\cdots+R(s_T,a_T)]\\\\\n", 86 | "\\end{align}\\\\\n", 87 | "\\Downarrow\\\\\n", 88 | "\\nabla_\\theta\\mathrm E\\left[R(s_0,a_0)+\\cdots+R(s_T,a_T)\\right]=\\mathrm E\\left[\\left(\\frac{\\nabla_\\theta\\pi_\\theta(s_0,a_0)}{\\pi_\\theta(s_0,a_0)}+\\cdots+\\frac{\\nabla_\\theta\\pi_\\theta(s_T,a_T)}{\\pi_\\theta(s_T,a_T)}\\right)\\cdot\\left(R(s_0,a_0)+\\cdots+R(s_T,a_T)\\right)\\right]\n", 89 | "$$\n", 90 | "第一步应用了几个相乘函数的求导法则$\\displaystyle\\frac{\\mathrm d}{\\mathrm d\\theta}f(\\theta)g(\\theta)h(\\theta)=f'(\\theta)g(\\theta)h(\\theta)+f(\\theta)g'(\\theta)h(\\theta)+f(\\theta)g(\\theta)h'(\\theta)$。\n", 91 | "\n", 92 | "但是，使用加强算法的时候，我们通常认为对于待解决的问题，存在一个简单的函数（如线性函数、逻辑函数等），描述了从状态空间到动作空间的映射。对于倒置钟摆这种简单的任务，事实可能就是这样的（杆向右偏时小车就向右加速接住杆）。实际上对于很多低级别的控制任务（如开车时右边有障碍就应该向左转向以避让），人类也是条件反射式的做出“本能”动作。对于这种较为简单的、极短时间内的“本能”判断，通常能够找到一个由简单函数组成的合理的策略类。\n", 93 | "\n", 94 | "与其相反的是复杂任务，需要很长的多步推理的任务，比如象棋、围棋等。在这种活动中做出决策需要多步严密的因果推理，这是一种高级别的控制任务，所以就不能使用“本能”了。在这种任务中我们有时会用前面提到的价值函数的线性近似。另外，在POMDP中如果使用$\\hat s$近似真实状态（比如在Kalman滤波中的$\\hat s=s_{t\\mid t}$），则我们仍然可以使用策略搜索算法$\\displaystyle\\pi_\\theta(\\hat s,a_t)=\\frac{1}{1+e^{-\\theta^T\\hat s}}$。\n", 95 | "\n", 96 | "最后，关于加强算法——这个算法在做上升时本质上是没有明确方向的（虽然其总体期望上是正确的），这可能会导致加强算法需要大量的迭代才到达到最优值附近；而且，在算法中，每次迭代都需要一次抽样，如果对于一个物理实体来说成本可能会很高，比如我们在研究控制一个机器人，那么这个机器人可能就需要做很多次动作（多次迭代，每次都需要抽样），所以这个算法通常运行在模拟器中。\n", 97 | "\n", 98 | "### 12.2 Pegasus算法\n", 99 | "\n", 100 | "在[第十七讲](chapter17.ipynb)我们提到模拟器的应用。模拟器可以接受状态$s_t$和动作$a_t$，输出下一步的状态$s_{t+1}$，$s_{t+1}$通常是一个从随机状态转换概率中抽样的随机状态，也就是说在模拟器中$s_{t+1}$是一个关于$s_t,a_t$的随机函数。比如我们在直升机的例子中，使用线性回归、局部加权回归等监督学习算法，就可以构建一个非线性动力学模型，在这个模型中，$s_{t+1}$就是一个关于$s_t,a_t$的随机函数。我们可以使用模拟器估计任意的状态-动作序列对应的预期总收益（将每个状态的奖励函数值相加即可）。\n", 101 | "\n", 102 | "同样是在[第十七讲](chapter17.ipynb)我们定义了策略，它接受当前状态，输出当前状态下应执行的动作，那么结合模拟器，就可以估计任意策略的预期总收益了（选定初始状态$s_0$后，输入策略$\\pi$得到$a_0$，再将$s_0,a_0$输入模拟器得到$s_1$；将$s_1$带入策略$\\pi$得到$a_1$，再将$s_1,a_1$带入模拟器得到$s_2$……将所有状态带入奖励函数，求和即可估计出该策略的预期总收益）。那么，我们就可以尝试找到使这个由模拟器估计出的总收益最大的策略，也就是找到该策略对应的参数即可。从概念上讲，这是一个不错的思路，但是实际上几乎不可行：由于模拟器的随机性，即使我们对同一个策略做估计时，也会得到有细微的差别两个不同的结果，所以在策略空间中对策略进行估计时，如果策略空间维数较高，那么我们很难知道空间中策略对应的收益的分布趋势。\n", 103 | "\n", 104 | "模拟器会根据输入的状态-动作输出一个带有机性的下一步状态，通常，能够做到这一点的模拟器都会调用一个随机数生成器。那么，为了降低使用模拟器对策略空间进行搜索的难度，我们可以在MDP中每一步调用模拟器时，固定随机数生成器得到的值（也就是让每一步的生成器只生成器只运行一次，然后就固定这个值），如果我们每次估计策略都使用同一组随机数序列，则模拟器就不再是随机的了，此时对同一个策略进行多次估计，得到的也将是相同的值（取消了随机数也就意味着确定了在策略空间上的收益函数，这极大程度上降低了最优策略的求解难度）。虽然我们现在通过模拟器只能得到的策略预期总收益的估计（因为固定了随机数，模拟器不再是原来通过试验数据拟合出来的系统了），但这个估计值离实际的预期总收益相乘不大，所以现在我们就可以使用诸如梯度上升等算法在策略空间中搜索最优策略了。\n", 105 | "\n", 106 | "关于这个随机数，可以举个例子，在直升机模型中，假设随机数是对直升机在风场中的模拟，不同的随机数对应不同的风。在对风场的模拟中，我们不是对每一种模式的风都进行建模估计，而是采样不同模式的风，对它们做平均的估计。在模拟器中，我们对控制策略做收益估计，并不是只做一次，而是做很多次，然后取所有测试的平均收益。这就相当于在不同的风场中做了多次测试，然后得出控制策略在不同风场状况下的平均预期收益。\n", 107 | "\n", 108 | "### 12.3 强化学习算法小结\n", 109 | "\n", 110 | "我们一共介绍了两种强化学习算法，第一种方法是通过求解最优价值函数推导出最优策略，这种方法常被用于解决需要“深思熟虑”才能解决的问题，它涉及的问题一般都会有多步推导，且后面步骤的决策也会影响前面的步骤，常见于诸如俄罗斯方块、象棋等场景；第二种方法是通过策略搜索直接找到最优策略，这种方法通常被用于解决“条件反射”式的问题，比如直升机悬停控制、汽车障碍避让等场景。强化学习算法的核心是根据状态做出的决策序列，它的适用场景为“需要依次根据状态做出决策的问题，而且决策可能具有长期影响”。列出一些RL算法已经应用的场景：医疗决策——根据病人所处的状态选择不同的治疗方案；用于减少排队等待时间——其中包括流水线上的效率提升问题等；用于博弈论中某些场景——比如怎样大量抛售股票同时又将对市场的影响降到最低；也应用于运筹学——最大化工厂的生产效率同时降低成本……。" 111 | ] 112 | } 113 | ], 114 | "metadata": { 115 | "kernelspec": { 116 | "display_name": "Python 3", 117 | "language": "python", 118 | "name": "python3" 119 | }, 120 | "language_info": { 121 | "codemirror_mode": { 122 | "name": "ipython", 123 | "version": 3 124 | }, 125 | "file_extension": ".py", 126 | "mimetype": "text/x-python", 127 | "name": "python", 128 | "nbconvert_exporter": "python", 129 | "pygments_lexer": "ipython3", 130 | "version": "3.5.2" 131 | } 132 | }, 133 | "nbformat": 4, 134 | "nbformat_minor": 0 135 | } 136 | -------------------------------------------------------------------------------- /readme.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "放在前面，更新说明：\n", 8 | "(TODO) ipynb脚本需要添加必要的解释和说明，最好能够完成笔记和代码相结合。\n", 9 | "> 更新代码，能在python2 和python3 运行 \n", 10 | "> 章节更改为ipynb，用来更好显示运行结果，方便查看。并在后期用来更好转换为pdf、html等格式，同时也添加更为详细的解释\n", 11 | "> 原所有py文件修改，完善放置[code](code)文件夹下面，数据单独放在[data](data)文件夹下 \n", 12 | "> readme.md 分章节下面，笔记增添 [LSJU机器学习笔记](https://github.com/zlotus/notes-LSJU-machine-learning) \n", 13 | "> （TODO） 增添吴恩达机器学习课程python代码 \n", 14 | "\n", 15 | "`Github` 加载 `.ipynb` 的速度较慢，建议在[这里](http://nbviewer.jupyter.org/github/Peterchenyijie/MachineLearningZeroToALL/blob/master/readme.ipynb)中查看该项目。\n", 16 | "\n", 17 | "requirement：\n", 18 | "* scikit-learn >=0.19 \n", 19 | " \n", 20 | "[![MIT license](https://img.shields.io/dub/l/vibe-d.svg)](https://github.com/PeterChenYijie/MachineLearningZeroToALL/blob/master/LICENSE)\n", 21 | "\n", 22 | "机器学习算法Python实现\n", 23 | "=========\n", 24 | "\n", 25 | "\n", 26 | "## ipynb 学习目录\n", 27 | "* [0 Basic Concept|基础概念](0-BasicConcept)\n", 28 | " * [概率论](0-BasicConcept/note/probability_theory.ipynb)\n", 29 | "* [1 Linear Regression|线性回归](1-LinearRegression)\n", 30 | " * 1.1 [线性回归笔记](1-LinearRegression/note)\n", 31 | " * 1.1.1 [LSJU笔记-监督学习应用](1-LinearRegression/note/LSJU_chapter02.ipynb)\n", 32 | " * 1.1.2 [LSJU笔记-线性模型概率解释、局部加权回归](1-LinearRegression/note/LSJU-chapter03_01.ipynb)\n", 33 | " * 1.1.3 [LSJU笔记-一般线性模型](1-LinearRegression/note/LSJU_chapter04.ipynb)\n", 34 | " * 1.1.3 [笔记](1-LinearRegression/note/NOTE-linear_regression.ipynb)\n", 35 | " * 1.2 [线性回归的实现](1-LinearRegression/LinearRegression.ipynb)\n", 36 | " * 1.3 [使用sklearn 线性回归](1-LinearRegression/LinearRegression_sklearn.ipynb)\n", 37 | " * 1.4 [Mxnet 实现线性回归](1-LinearRegression/linear_regression_mxnet.ipynb)\n", 38 | "* [2 Logistic Regression|逻辑回归](2-LogisticRegression)\n", 39 | " * 2.1 [逻辑回归笔记](2-LogisticRegression/note/)\n", 40 | " * 2.1.1 [LSJU笔记-分类问题、逻辑回归](2-LogisticRegression/note/LSJU-chapter03_2.ipynb)\n", 41 | " * 2.1.2 [逻辑回归笔记](2-LogisticRegression/note/NOTE-logistic_regression.ipynb)\n", 42 | " * 2.2 [逻辑回归的实现](2-LogisticRegression/LogisticRegression.ipynb)\n", 43 | " * 2.3 [使用sklearn 逻辑回归](2-LogisticRegression/LogisticRegression_scikit-learn.ipynb)\n", 44 | " * 2.4 [逻辑回归识别手写数字](2-LogisticRegression/LogisticRegression_OneVsAll.ipynb)\n", 45 | " * 2.5 [使用sklearn 逻辑回归识别手写数字](2-LogisticRegression/LogisticRegression_OneVsAll_scikit-learn.ipynb)\n", 46 | "* [3 Neural Network|神经网络](3-NeuralNetwok)\n", 47 | " * 3.1 [神经网络笔记](3-NeuralNetwok/note/NOTE-neural_network.md)\n", 48 | " * 3.2 [神经网络识别手写数字](3-NeuralNetwok/NeuralNetwork.ipynb)\n", 49 | "* [4 SVM|支持向量机](4-SVM)\n", 50 | " * 4.1 [SVM笔记](4-SVM/NOTE-SVM.md)\n", 51 | " * 4.2 [SVM实现]\n", 52 | " * 4.3 [使用sklearn SVM](4-SVM/SVM_scikit-learn.ipynb)\n", 53 | "* [5 K-Means|聚类](5-K-Means)\n", 54 | " * 5.1 [K-Mean 聚类笔记](5-K-Means/LSJU----NOTE-K-Means.ipynb)\n", 55 | " * 5.2 [K-Mean的实现](5-K-Means/K-Means.ipynb)\n", 56 | " * 5.3 [使用sklearn K-Means](5-K-Means/K-Means-sklearn.ipynb)\n", 57 | "* [6 PCA|主成分分析](6-PCA)\n", 58 | " * 6.1 [PCA笔记](6-PCA/note/LSJU----NOTE-PCA.ipynb)\n", 59 | " * 6.2 [PCA的实现](6-PCA/PCA.ipynb)\n", 60 | " * 6.3 [使用sklearn PCA](6-PCA/PCA_sklearn.ipynb)\n", 61 | "* [7 Anomaly Detection|异常检测](7-AnomalyDetection)\n", 62 | " * 7.1 [异常检测笔记](7-AnomalyDetection/note/NOTE-anomaly_detection.md)\n", 63 | " * 7.2 [异常检测实现](7-AnomalyDetection/AnomalyDetection.ipynb)\n", 64 | "* [8 HMM|隐马尔可夫模型](8-HMM)\n", 65 | " * 8.1 [马尔科夫决策过程](8-HMM/note/LSJU-HMM.ipynb)其他参考 [这里](8-HMM/note/sn06.ipynb)\n", 66 | "* [9 NaiveBayer|朴素贝叶斯](9-NaiveBayer)\n", 67 | " * 9.1 [笔记](9-NaiveBayer/note)\n", 68 | " * 9.1.1 [LSJU-生成学习算法、高斯判别分布、朴素贝叶斯算法](9-NaiveBayer/note/LSJU-chapter05.ipynb)\n" 69 | ] 70 | } 71 | ], 72 | "metadata": { 73 | "kernelspec": { 74 | "display_name": "Python 2", 75 | "language": "python", 76 | "name": "python2" 77 | }, 78 | "language_info": { 79 | "codemirror_mode": { 80 | "name": "ipython", 81 | "version": 2 82 | }, 83 | "file_extension": ".py", 84 | "mimetype": "text/x-python", 85 | "name": "python", 86 | "nbconvert_exporter": "python", 87 | "pygments_lexer": "ipython2", 88 | "version": "2.7.13" 89 | } 90 | }, 91 | "nbformat": 4, 92 | "nbformat_minor": 2 93 | } 94 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | 放在前面，更新说明： 2 | (TODO) ipynb脚本需要添加必要的解释和说明，最好能够完成笔记和代码相结合。 3 | > 更新代码，能在python2 和python3 运行 4 | > 章节更改为ipynb，用来更好显示运行结果，方便查看。并在后期用来更好转换为pdf、html等格式，同时也添加更为详细的解释 5 | > 原所有py文件修改，完善放置[code](code)文件夹下面，数据单独放在[data](data)文件夹下 6 | > readme.md 分章节下面，笔记增添 [LSJU机器学习笔记](https://github.com/zlotus/notes-LSJU-machine-learning) 7 | > （TODO） 增添吴恩达机器学习课程python代码 8 | 9 | `Github` 加载 `.ipynb` 的速度较慢，建议在[这里](http://nbviewer.jupyter.org/github/Peterchenyijie/MachineLearningZeroToALL/blob/master/readme.ipynb)中查看该项目。 10 | 11 | requirement： 12 | * scikit-learn >=0.19 13 | 14 | [![MIT license](https://img.shields.io/dub/l/vibe-d.svg)](https://github.com/PeterChenYijie/MachineLearningZeroToALL/blob/master/LICENSE) 15 | 16 | 机器学习算法Python实现 17 | ========= 18 | 19 | 20 | ## ipynb 学习目录 21 | * [0 Basic Concept|基础概念](0-BasicConcept) 22 | * [概率论](0-BasicConcept/note/probability_theory.ipynb) 23 | * [1 Linear Regression|线性回归](1-LinearRegression) 24 | * 1.1 [线性回归笔记](1-LinearRegression/note) 25 | * 1.1.1 [LSJU笔记-监督学习应用](1-LinearRegression/note/LSJU_chapter02.ipynb) 26 | * 1.1.2 [LSJU笔记-线性模型概率解释、局部加权回归](1-LinearRegression/note/LSJU-chapter03_01.ipynb) 27 | * 1.1.3 [LSJU笔记-一般线性模型](1-LinearRegression/note/LSJU_chapter04.ipynb) 28 | * 1.1.3 [笔记](1-LinearRegression/note/NOTE-linear_regression.ipynb) 29 | * 1.2 [线性回归的实现](1-LinearRegression/LinearRegression.ipynb) 30 | * 1.3 [使用sklearn 线性回归](1-LinearRegression/LinearRegression_sklearn.ipynb) 31 | * 1.4 [Mxnet 实现线性回归](1-LinearRegression/linear_regression_mxnet.ipynb) 32 | * [2 Logistic Regression|逻辑回归](2-LogisticRegression) 33 | * 2.1 [逻辑回归笔记](2-LogisticRegression/note/) 34 | * 2.1.1 [LSJU笔记-分类问题、逻辑回归](2-LogisticRegression/note/LSJU-chapter03_2.ipynb) 35 | * 2.1.2 [逻辑回归笔记](2-LogisticRegression/note/NOTE-logistic_regression.ipynb) 36 | * 2.2 [逻辑回归的实现](2-LogisticRegression/LogisticRegression.ipynb) 37 | * 2.3 [使用sklearn 逻辑回归](2-LogisticRegression/LogisticRegression_scikit-learn.ipynb) 38 | * 2.4 [逻辑回归识别手写数字](2-LogisticRegression/LogisticRegression_OneVsAll.ipynb) 39 | * 2.5 [使用sklearn 逻辑回归识别手写数字](2-LogisticRegression/LogisticRegression_OneVsAll_scikit-learn.ipynb) 40 | * [3 Neural Network|神经网络](3-NeuralNetwok) 41 | * 3.1 [神经网络笔记](3-NeuralNetwok/note/NOTE-neural_network.md) 42 | * 3.2 [神经网络识别手写数字](3-NeuralNetwok/NeuralNetwork.ipynb) 43 | * [4 SVM|支持向量机](4-SVM) 44 | * 4.1 [SVM笔记](4-SVM/NOTE-SVM.md) 45 | * 4.2 [SVM实现] 46 | * 4.3 [使用sklearn SVM](4-SVM/SVM_scikit-learn.ipynb) 47 | * [5 K-Means|聚类](5-K-Means) 48 | * 5.1 [K-Mean 聚类笔记](5-K-Means/LSJU----NOTE-K-Means.ipynb) 49 | * 5.2 [K-Mean的实现](5-K-Means/K-Means.ipynb) 50 | * 5.3 [使用sklearn K-Means](5-K-Means/K-Means-sklearn.ipynb) 51 | * [6 PCA|主成分分析](6-PCA) 52 | * 6.1 [PCA笔记](6-PCA/note/LSJU----NOTE-PCA.ipynb) 53 | * 6.2 [PCA的实现](6-PCA/PCA.ipynb) 54 | * 6.3 [使用sklearn PCA](6-PCA/PCA_sklearn.ipynb) 55 | * [7 Anomaly Detection|异常检测](7-AnomalyDetection) 56 | * 7.1 [异常检测笔记](7-AnomalyDetection/note/NOTE-anomaly_detection.md) 57 | * 7.2 [异常检测实现](7-AnomalyDetection/AnomalyDetection.ipynb) 58 | * [8 HMM|隐马尔可夫模型](8-HMM) 59 | * 8.1 [马尔科夫决策过程](8-HMM/note/LSJU-HMM.ipynb)其他参考 [这里](8-HMM/note/sn06.ipynb) 60 | * [9 NaiveBayer|朴素贝叶斯](9-NaiveBayer) 61 | * 9.1 [笔记](9-NaiveBayer/note) 62 | * 9.1.1 [LSJU-生成学习算法、高斯判别分布、朴素贝叶斯算法](9-NaiveBayer/note/LSJU-chapter05.ipynb) 63 | 64 | 65 | [收藏！机器学习算法优缺点综述][Title-6] + 七月在线实验室 66 | ![img-06-01][img-06-01] 67 | * 正则化算法（Regularization Algorithms） 68 | * 例子 69 | * 岭回归（Ridge Regression） 70 | * 最小绝对收缩与选择算子（LASSO） 71 | * GLASSO 72 | * 弹性网络（Elastic Net） 73 | * 最小角回归（Least-Angle Regression） 74 | * 优点 75 | * 其惩罚会减少过拟合 76 | * 总会有解决方法 77 | * 缺点 78 | * 惩罚会造成欠拟合 79 | * 很难校准 80 | 81 | * 集成算法（Ensemble Algorithms） 82 | * 例子 83 | * Boosting 84 | * Bootstrapped Aggregation（Bagging） 85 | * AdaBoost 86 | * 层叠泛化（Stacked Generalization）（blending） 87 | * 梯度推进机（Gradient Boosting Machines，GBM） 88 | * 梯度提升回归树（Gradient Boosted Regression Trees，GBRT） 89 | * 随机森林（Random Forest） 90 | * 优点 91 | * 当先最先进的预测几乎都使用了算法集成。它比使用单个模型预测出来的结果要精确的多 92 | * 缺点 93 | * 需要大量的维护工作 94 | * 决策树算法（Decision Tree Algorithm） 95 | * 例子 96 | * 分类和回归树（Classification and Regression Tree，CART） 97 | * Iterative Dichotomiser 3（ID3） 98 | * C4.5 和 C5.0（一种强大方法的两个不同版本） 99 | * 优点 100 | * 容易解释 101 | * 非参数化 102 | * 缺点 103 | * 趋向过拟合 104 | * 可能或陷于局部最小值中 105 | * 没有在线学习 106 | 107 | * 回归（Regression） 108 | * 例子 109 | * 普通最小二乘回归（Ordinary Least Squares Regression，OLSR） 110 | * 线性回归（Linear Regression） 111 | * 逻辑回归（Logistic Regression） 112 | * 逐步回归（Stepwise Regression） 113 | * 多元自适应回归样条（Multivariate Adaptive Regression Splines，MARS） 114 | * 本地散点平滑估计（Locally Estimated Scatterplot Smoothing，LOESS） 115 | * 优点 116 | * 直接、快速 117 | * 知名度高 118 | * 缺点 119 | * 要求严格的假设 120 | * 需要处理异常值 121 | 122 | * 人工神经网络（Artificial Neural Network） 123 | * 例子 124 | * 感知器 125 | * 反向传播 126 | * Hopfield 网络 127 | * 径向基函数网络（Radial Basis Function Network，RBFN） 128 | * 优点： 129 | * 在语音、语义、视觉、各类游戏（如围棋）的任务中表现极好 130 | * 算法可以快速调整，适应新的问题 131 | * 缺点： 132 | * 需要大量数据进行训练 133 | * 训练要求很高的硬件配置 134 | * 模型处于「黑箱状态」，难以理解内部机制 135 | * 元参数（Metaparameter）与网络拓扑选择困难。 136 | 137 | * 深度学习（Deep Learning） 138 | * 例子： 139 | * 深玻耳兹曼机（Deep Boltzmann Machine，DBM） 140 | * Deep Belief Networks（DBN） 141 | * 卷积神经网络（CNN） 142 | * Stacked Auto-Encoders 143 | * 优点/缺点：见神经网络 144 | 145 | * 支持向量机（Support Vector Machine） 146 | * 优点 147 | * 在非线性可分问题上表现优秀 148 | * 缺点 149 | * 非常难以训练 150 | * 很难解释 151 | 152 | * 降维算法（Dimensionality Reduction Algorithms） 153 | * 例子： 154 | * 主成分分析（Principal Component Analysis (PCA)） 155 | * 主成分回归（Principal Component Regression (PCR)） 156 | * 偏最小二乘回归（Partial Least Squares Regression (PLSR)） 157 | * Sammon 映射（Sammon Mapping） 158 | * 多维尺度变换（Multidimensional Scaling (MDS)） 159 | * 投影寻踪（Projection Pursuit） 160 | * 线性判别分析（Linear Discriminant Analysis (LDA)） 161 | * 混合判别分析（Mixture Discriminant Analysis (MDA)） 162 | * 二次判别分析（Quadratic Discriminant Analysis (QDA)） 163 | * 灵活判别分析（Flexible Discriminant Analysis (FDA)） 164 | * 优点： 165 | * 可处理大规模数据集 166 | * 无需在数据上进行假设 167 | * 缺点： 168 | * 难以搞定非线性数据 169 | * 难以理解结果的意义 170 | 171 | 172 | * 聚类算法（Clustering Algorithms） 173 | * 例子： 174 | * K-均值（k-Means） 175 | * K-Medians 算法 176 | * Expectation–maximization（EM） 177 | * 分层集群（Hierarchical Clustering） 178 | * 优点： 179 | * 让数据变得有意义 180 | * 缺点： 181 | * 结果难以解读，针对不寻常的数据组，结果可能无用 182 | 183 | * 基于实例的算法（Instance-based Algorithms） 184 | * 例子： 185 | * K 最近邻（k-Nearest Neighbor (kNN)） 186 | * 学习向量量化（Learning Vector Quantization (LVQ)） 187 | * 自组织映射（Self-Organizing Map (SOM)） 188 | * 局部加权学习（Locally Weighted Learning (LWL)） 189 | * 优点： 190 | * 算法简单、结果易于解读 191 | * 缺点： 192 | * 内存使用非常高 193 | * 计算成本高 194 | * 不可能用于高维特征空间 195 | 196 | * 贝叶斯算法（Bayesian Algorithms） 197 | * 例子： 198 | * 朴素贝叶斯（Naive Bayer） 199 | * 高斯朴素贝叶斯（Gaussian Naive Bayer） 200 | * 多项式朴素贝叶斯（Multinomial Naive Bayer） 201 | * 平均一致依赖估计器（Averaged One—Dependence Estimators（AODE）） 202 | * 贝叶斯网络（Bayeian Network（BN）） 203 | * 优点 204 | * 快速、易于训练、给出了它们所需的资源能带来良好的表现 205 | * 缺点 206 | * 如果输入变量是相关的，则会出现问题 207 | 208 | * 关联规则学习算法（Association Rule Learning Algorithms） 209 | * 例子 210 | * Apriori 算法（Apriori algorithm） 211 | * Eclat 算法（Eclat algorithm） 212 | * FP-growth 213 | 214 | * 图模型（Graphical Models） 215 | * 例子： 216 | * 贝叶斯网络（Bayesian network） 217 | * 马尔可夫随机域（Markov random field） 218 | * 链图（Chain Graphs） 219 | * 祖先图（Ancestral graph） 220 | * 优点： 221 | * 模型清晰，能被直观地理解 222 | * 缺点： 223 | * 确定其依赖的拓扑很困难，有时候也很模糊 224 | 225 | --- 226 | [Title-6]:https://mp.weixin.qq.com/s/Xomx6Z_fP1EsnwNEegj5Cw 227 | [img-06-01]:img/20180527-06-01.jpg --------------------------------------------------------------------------------