├── .gitignore ├── README.md ├── alg_base ├── Activation_Function.md ├── BackPropagation.md ├── Bagging.md ├── Boosting.md ├── Capacity.md ├── CrossValidation.md ├── Distributed_Representation.md ├── Entropy.md ├── Error&variance.md ├── GiniIndex.md ├── Hierarchical_cluster.md ├── InformationGain.md ├── InformationGainRadio.md ├── Intention_recognition.md ├── Jupyterhub-install-tutorial.md ├── MachineLearningAlgorithms.png ├── MaxPooling1D_GlobalMaxPooling1D.md ├── One-hot-Representation.md ├── Principles_of_Decision_tree.md ├── Pruning.md ├── RandomForest.md ├── TF-idf.md ├── appendix.md ├── bpe.md ├── cluster_concept.md ├── cluster_k_means.md ├── cluster_k_means_plus.md ├── cnn_intro.md ├── data_clean.md ├── data_normalization.md ├── data_sample.md ├── dataset_classification.md ├── dataset_partition.md ├── debug_ml_alg.md ├── decision_tree.md ├── decision_tree_generate.md ├── estimator.md ├── estimator_optimize.md ├── features.md ├── features_concept.md ├── features_handle.md ├── features_handle.md.bak ├── generalization.md ├── gradient_descent.md ├── hmm.md ├── how_to_read_paper.md ├── kmeans.md ├── knn.md ├── latent_factor_model.md ├── learning_carve.md ├── linear_regression_model.md ├── logisticRegression.md ├── loss_function.md ├── lstm.md ├── lstm_param.md ├── model_ensemble.md ├── nb │ ├── 1.jpg │ ├── 2.jpg │ ├── 3.jpg │ ├── 4.jpg │ ├── 5.jpg │ ├── gram_model.md │ └── nb.md ├── neural_network.md ├── nlp_opensource_dataset.md ├── normalization.md ├── one-hot.md ├── pca.md ├── precision_andrecall.md ├── regularization.md ├── sample_feature_label.md ├── scikit-plot.md ├── speed_up_training.md ├── svm.md ├── task_nlp.md ├── the_division_of_ml.md ├── todolist.md ├── underfitting_vs_overfitting.md ├── wiml.md └── word2vec.md ├── math_base ├── Comparison_Activation.md ├── Hessian_Matrix.md ├── Lagrange.md ├── MLE.md ├── Prior_probability.md ├── activation_relu_function.md ├── activation_sigmoid_function.md ├── activation_tanh_function.md ├── bayes.md ├── central_limit.md ├── conjugate.md ├── cov.md ├── distribution.md ├── expectation_variance.md ├── likehood.md ├── linearly_separable.md ├── matrix.md ├── matrix_multi.md ├── moment_estimation.md ├── pmf.md ├── skewness.md └── taylor.md ├── papers ├── PIIA.pdf └── nl2sql.pdf └── practice ├── .recommendation_collaborative_filtering.md.swp ├── .rmse.md.swp ├── 1.basic_ml_feature_engineering.ipynb ├── 43_suggestions_from_google_Experience.md ├── auto_ml_tools.md ├── awesome-chatbot.md ├── code ├── .ipynb_checkpoints │ ├── example_code_of_decision_tree-checkpoint.ipynb │ ├── first_steps_with_tensor_flow-checkpoint.ipynb │ └── python-numpy-tutorial-checkpoint.ipynb ├── MNIST_Softmax.ipynb ├── deeplearning │ ├── Activation_function_with_pytorch.ipynb │ ├── Attention_on_seq2seq.ipynb │ ├── Classifier_with_keras.ipynb │ ├── Classifier_with_pytorch.ipynb │ ├── Cnn_with_keras.py │ ├── Regressor_with_keras.ipynb │ ├── Regressor_with_pytorch.ipynb │ ├── Transformer.ipynb │ ├── cnn_with_keras.ipynb │ ├── lstm_with_keras.ipynb │ ├── rnn_with_keras.ipynb │ └── variable_with_pytorch.ipynb ├── example_code_of_decision_tree.ipynb ├── feature_engineering │ ├── .ipynb_checkpoints │ │ ├── Untitled-checkpoint.ipynb │ │ ├── decision_tree-checkpoint.ipynb │ │ └── feature_engineering-checkpoint.ipynb │ ├── D805EAA4-5FCA-4CB1-B788-BEF90B34D9F3.png │ └── feature_engineering.ipynb ├── first_steps_with_tensor_flow.ipynb ├── input │ ├── data_banknote_authentication.csv │ ├── kaggle_bike_competition_train.csv │ ├── kaggle_titanic_data │ │ ├── gender_submission.csv │ │ ├── test.csv │ │ └── train.csv │ └── pima-indians-diabetes.data.csv ├── linear_regression_practice │ ├── .ipynb_checkpoints │ │ └── Untitled-checkpoint.ipynb │ ├── linear_regression_data1.txt │ └── linear_regression_practice.ipynb ├── logisitic_regression_practice │ ├── .ipynb_checkpoints │ │ └── Untitled-checkpoint.ipynb │ ├── data1.txt │ ├── data2.txt │ └── logistic_regression_example.ipynb ├── output │ └── Titanic_data │ │ ├── logistic_regression_bagging_predictions.csv │ │ └── logistic_regression_predictions.csv └── python-numpy-tutorial.ipynb ├── jieba_part_of_speech ├── linear-regression-practice.md ├── major_task.md ├── matplotlib_pyplot ├── axis.md ├── content.md ├── gca.md └── scatter.md ├── ml-hello-world-program.md ├── mse.md ├── python-environment-install.md ├── recommendation_basic_concept.md ├── recommendation_collaborative_filtering.md ├── recommendation_usr_behavior.md ├── rmse_mae.md ├── synthetic_features_and_outliers.ipynb ├── tensorflow ├── .ipynb_checkpoints │ ├── Softmax_with_tensorflow-checkpoint.ipynb │ ├── a_nn_by_tensorflow-checkpoint.ipynb │ └── linear_model_by_tensorflow-checkpoint.ipynb ├── Softmax_with_tensorflow.ipynb ├── a_nn_by_tensorflow.ipynb ├── data │ └── mnist │ │ ├── t10k-images-idx3-ubyte.gz │ │ ├── t10k-labels-idx1-ubyte.gz │ │ ├── train-images-idx3-ubyte.gz │ │ └── train-labels-idx1-ubyte.gz └── linear_model_by_tensorflow.ipynb ├── todolist.md ├── tuning_e1.md └── user_portrait.md /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | .ipynb_checkpoints 3 | *.swp 4 | .vscode/ 5 | -------------------------------------------------------------------------------- /alg_base/Activation_Function.md: -------------------------------------------------------------------------------- 1 | # 激励函数 (Activation Function) 2 | 3 | ## 非线性方程 4 | 我们为什么要使用激励函数? 用简单的语句来概括. 就是因为, 现实并没有我们想象的那么美好, 它是残酷多变的. 哈哈, 开个玩笑, 不过激励函数也就是为了解决我们日常生活中 不能用线性方程所概括的问题. 好了,我知道你的问题来了. 什么是线性方程 (linear function)? 5 | 6 | ![](https://morvanzhou.github.io/static/results/ML-intro/active1.png) 7 | 8 | 说到线性方程, 我们不得不提到另外一种方程, 非线性方程 (nonlinear function). 我们假设, 女生长得越漂亮, 越多男生爱. 这就可以被当做一个线性问题. 但是如果我们假设这个场景是发生在校园里. 校园里的男生数是有限的, 女生再漂亮, 也不可能会有无穷多的男生喜欢她. 所以这就变成了一个非线性问题.再说..女生也不可能是无穷漂亮的. 这个问题我们以后有时间私下讨论. 9 | 10 | 11 | ![](https://morvanzhou.github.io/static/results/ML-intro/active2.png) 12 | 13 | 然后我们就可以来讨论如何在神经网络中达成我们描述非线性的任务了. 我们可以把整个网络简化成这样一个式子. Y = Wx, W 就是我们要求的参数, y 是预测值, x 是输入值. 用这个式子, 我们很容易就能描述刚刚的那个线性问题, 因为 W 求出来可以是一个固定的数. 不过这似乎并不能让这条直线变得扭起来 , 激励函数见状, 拔刀相助, 站出来说道: “让我来掰弯它!”. 14 | 15 | ## 激励函数 16 | ![](https://morvanzhou.github.io/static/results/ML-intro/active3.png) 17 | 18 | 这里的 AF 就是指的激励函数. 激励函数拿出自己最擅长的”掰弯利器”, 套在了原函数上 用力一扭, 原来的 Wx 结果就被扭弯了. 19 | 20 | 其实这个 AF, 掰弯利器, 也不是什么触不可及的东西. 它其实就是另外一个非线性函数. 比如说relu, sigmoid, tanh. 将这些掰弯利器嵌套在原有的结果之上, 强行把原有的线性结果给扭曲了. 使得输出结果 y 也有了非线性的特征. 举个例子, 比如我使用了 relu 这个掰弯利器, 如果此时 Wx 的结果是1, y 还将是1, 不过 Wx 为-1的时候, y 不再是-1, 而会是0. 21 | 22 | 你甚至可以创造自己的激励函数来处理自己的问题, 不过要确保的是这些激励函数必须是可以微分的, 因为在 backpropagation 误差反向传递的时候, 只有这些可微分的激励函数才能把误差传递回去. 23 | 24 | 25 | 26 | ## 常用选择 27 | ![](https://morvanzhou.github.io/static/results/ML-intro/active4.png) 28 | 29 | 想要恰当使用这些激励函数, 还是有窍门的. 比如当你的神经网络层只有两三层, 不是很多的时候, 对于隐藏层, 使用任意的激励函数, 随便掰弯是可以的, 不会有特别大的影响. 不过, 当你使用特别多层的神经网络, 在掰弯的时候, 玩玩不得随意选择利器. 因为这会涉及到梯度爆炸, 梯度消失的问题. 因为时间的关系, 我们可能会在以后来具体谈谈这个问题. 30 | 31 | 最后我们说说, 在具体的例子中, 我们默认首选的激励函数是哪些. 在少量层结构中, 我们可以尝试很多种不同的激励函数. 在卷积神经网络 Convolutional neural networks 的卷积层中, 推荐的激励函数是 relu. 在循环神经网络中 recurrent neural networks, 推荐的是 tanh 或者是 relu (这个具体怎么选, 我会在以后 循环神经网络的介绍中在详细讲解). 32 | -------------------------------------------------------------------------------- /alg_base/BackPropagation.md: -------------------------------------------------------------------------------- 1 | # 误差逆传播算法 2 | 3 | 训练多层神经网络，通常使用误差逆传播算法（BP算法）。BP算法不仅可以用于多层前馈神经网络，还可用于其它类型神经网络，但说到BP网络时通常是指多层前馈神经网络。 4 | 5 | 如下图所示： 6 | 7 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170625014518.jpg) 8 | -------------------------------------------------------------------------------- /alg_base/Bagging.md: -------------------------------------------------------------------------------- 1 | # Bagging 2 | ## 工作机制 3 | 1. 初始样本集D，使用自助采样法(有放回采样)生成m个采样集； 4 | 2. 每个采样集训练处一个基学习器； 5 | 3. 分类任务中使用投票法，回归任务使用平均法 6 | 7 | 从偏差-方差分解角度，Bagging主要关注降低方差。 8 | -------------------------------------------------------------------------------- /alg_base/Boosting.md: -------------------------------------------------------------------------------- 1 | # Boosting 2 | ## 工作机制 3 | 1. 先初始化训练集D1，训练出一个基学习器L1； 4 | 2. 根据基学习器L1的表现对训练集D1样本分布进行调整，生成样本集D2，D2使得基学习器之前做错的训练样本在后续受到更多关注； 5 | 3. 基于调整后的D2,训练下一个基学习器L2； 6 | 4. 重复以上过程，直到学习出T个学习器（T为超参数）； 7 | 5. 最终预测时对这T个基学习器加权结合； 8 | 9 | 从偏差-方差分解的角度看，Boosting更关注降低偏差。因此Boosting能基于泛化性能相当弱的学习期构建出很强的集成。 10 | 11 | ## 关于xgboost的理解和推导 12 | > 陈天奇大神关于Bossted tree的文章[Boosted tree](http://www.52cs.org/?p=429) 13 | 14 | ## More介绍XGBoost的文章 15 | 一篇写的很好的xGBost文章，我就不用再写一遍了。链接在下面： 16 | 17 | > [点击跳转:xgboost原理](http://blog.csdn.net/a819825294/article/details/51206410) 18 | 19 | > [点击跳转:从ID3到XGBoost](http://www.jianshu.com/p/41dac1f6b0d2) 20 | 21 | > [xgboost作者写的关于xgboost](https://courses.cs.washington.edu/courses/cse546/14au/slides/oct22_recitation_boosted_trees.pdf) 22 | -------------------------------------------------------------------------------- /alg_base/Capacity.md: -------------------------------------------------------------------------------- 1 | # 模型容量（Capacity） 2 | 通俗的说就是你的model能够很好地表达examples的数量. 3 | 4 | > The ability of the learner (or called model) to discover a function 5 | > taken from a family of functions. 6 | 7 | 比如说，下面的几个predictor: 8 | ``` 9 | Linear predictor 10 | y = wx + b 11 | 12 | Quadratic predictor 13 | y = W2X^2 + W1X + b 14 | 15 | Degree-4 polynomial predictor 16 | y = b+W1x+W2X^2+W3X^3+W4X^4 17 | ``` 18 | 明显对于4次多项式函数，其能够capture更复杂的functions. 19 | -------------------------------------------------------------------------------- /alg_base/CrossValidation.md: -------------------------------------------------------------------------------- 1 | # 交叉验证 2 | 交叉验证是在机器学习建立模型和验证模型参数时常用的办法。交叉验证，顾名思义，就是重复的使用数据，把得到的样本数据进行切分，组合为不同的训练集和测试集，用训练集来训练模型，用测试集来评估模型预测的好坏。在此基础上可以得到多组不同的训练集和测试集，某次训练集中的某样本在下次可能成为测试集中的样本，即所谓“交叉”。　 3 | 4 | 那么什么时候才需要交叉验证呢？交叉验证用在数据不是很充足的时候。比如在我日常项目里面，对于普通适中问题，如果数据样本量小于一万条，我们就会采用交叉验证来训练优化选择模型。如果样本大于一万条的话，我们一般随机的把数据分成三份，一份为训练集（Training Set），一份为验证集（Validation Set），最后一份为测试集（Test Set）。用训练集来训练模型，用验证集来评估模型预测的好坏和选择模型及其对应的参数。把最终得到的模型再用于测试集，最终决定使用哪个模型以及对应参数。 5 | 6 | 回到交叉验证，根据切分的方法不同，交叉验证分为下面三种：　　　 7 | 8 | 第一种是简单交叉验证，所谓的简单，是和其他交叉验证方法相对而言的。首先，我们随机的将样本数据分为两部分（比如： 70%的训练集，30%的测试集），然后用训练集来训练模型，在测试集上验证模型及参数。接着，我们再把样本打乱，重新选择训练集和测试集，继续训练数据和检验模型。最后我们选择损失函数评估最优的模型和参数。　 9 | 10 | 第二种是S折交叉验证（S-Folder Cross Validation）。和第一种方法不同，S折交叉验证会把样本数据随机的分成S份，每次随机的选择S-1份作为训练集，剩下的1份做测试集。当这一轮完成后，重新随机选择S-1份来训练数据。若干轮（小于S）之后，选择损失函数评估最优的模型和参数。 11 | 12 | 第三种是留一交叉验证（Leave-one-out Cross Validation），它是第二种情况的特例，此时S等于样本数N，这样对于N个样本，每次选择N-1个样本来训练数据，留一个样本来验证模型预测的好坏。此方法主要用于样本量非常少的情况，比如对于普通适中问题，N小于50时，我一般采用留一交叉验证。 13 | 14 | 通过反复的交叉验证，用损失函数来度量得到的模型的好坏，最终我们可以得到一个较好的模型。那这三种情况，到底我们应该选择哪一种方法呢？一句话总结，如果我们只是对数据做一个初步的模型建立，不是要做深入分析的话，简单交叉验证就可以了。否则就用S折交叉验证。在样本量少的时候，使用S折交叉验证的特例留一交叉验证。 15 | 16 | 此外还有一种比较特殊的交叉验证方式，也是用于样本量少的时候。叫做自助法(bootstrapping)。比如我们有m个样本（m较小），每次在这m个样本中随机采集一个样本，放入训练集，采样完后把样本放回。这样重复采集m次，我们得到m个样本组成的训练集。当然，这m个样本中很有可能有重复的样本数据。同时，用原始的m个样本做测试集。这样接着进行交叉验证。由于我们的训练集有重复数据，这会改变数据的分布，因而训练结果会有估计偏差，因此，此种方法不是很常用，除非数据量真的很少，比如小于20个。 17 | 18 | [以上内容转自博文](http://www.cnblogs.com/pinard/p/5992719.html) 19 | -------------------------------------------------------------------------------- /alg_base/Distributed_Representation.md: -------------------------------------------------------------------------------- 1 | # Distributed Representation 2 | Distributed representation 最早由 Hinton 在 1986 年提出[8]。其基本思想是 通过训练将每个词映射成 K 维实数向量(K 一般为模型中的超参数)，通过词之 间的距离(比如 cosine 相似度、欧氏距离等)来判断它们之间的语义相似度。而 word2vec 使用的就是这种 Distributed representation 的词向量表示方式。 3 | 4 | 这种向量一般长成这个样子：[0.792, −0.177, −0.107, 0.109, −0.542, ...]，也就是普通的向量表示形式。维度以50维和100维比较常见。 5 | -------------------------------------------------------------------------------- /alg_base/Entropy.md: -------------------------------------------------------------------------------- 1 | # 熵 Entropy 2 | ## 信息量 3 | 信息熵，信息熵，怎么看怎么觉得这个“熵”字不顺眼，那就先不看。我们起码知道这个概念跟信息有关系。而它又是个数学模型里面的概念，一般而言是可以量化的。所以，第一个问题来了：信息是不是可以量化？ 4 | 5 | 起码直觉上而言是可以的，不然怎么可能我们觉得有些人说的废话特别多，“没什么信息量”，有些人一语中的，一句话就传达了很大的信息量。 6 | 7 | 为什么有的信息量大有的信息量小？ 8 | 9 | 有些事情本来不是很确定，例如明天股票是涨还是跌。如果你告诉我明天NBA决赛开始了，这两者似乎没啥关系啊，所以你的信息对明天股票是涨是跌带来的信息量很少。但是假如NBA决赛一开始，大家都不关注股票了没人坐庄股票有99%的概率会跌，那你这句话信息量就很大，因为本来不确定的事情变得十分确定。 10 | 11 | 而有些事情本来就很确定了，例如太阳从东边升起，你再告诉我一百遍太阳从东边升起，你的话还是丝毫没有信息量的，因为这事情不能更确定了。 12 | 13 | 所以说信息量的大小跟事情不确定性的变化有关。 14 | 15 | 那么，不确定性的变化跟什么有关呢？ 16 | 一，跟事情的可能结果的数量有关； 17 | 18 | 二，跟概率有关。 19 | 20 | 先说一。 21 | 22 | 例如我们讨论太阳从哪升起。本来就只有一个结果，我们早就知道，那么无论谁传递任何信息都是没有信息量的。 23 | 当可能结果数量比较大时，我们得到的新信息才有潜力拥有大信息量。 24 | 25 | 二，单看可能结果数量不够，还要看初始的概率分布。例如一开始我就知道小明在电影院的有15*15个座位的A厅看电影。小明可以坐的位置有225个，可能结果数量算多了。可是假如我们一开始就知道小明坐在第一排的最左边的可能是99%，坐其它位置的可能性微乎其微，那么在大多数情况下，你再告诉我小明的什么信息也没有多大用，因为我们几乎确定小明坐第一排的最左边了。 26 | 27 | 那么，怎么衡量不确定性的变化的大小呢？怎么定义呢？ 28 | 这个问题不好回答，但是假设我们已经知道这个量已经存在了，不妨就叫做信息量，那么你觉得信息量起码该满足些什么特点呢？ 29 | 30 | 31 | 一，起码不是个负数吧，不然说句话还偷走信息呢~ 32 | 33 | 二，起码信息量和信息量之间可以相加吧！假如你告诉我的第一句话的信息量是3，在第一句话的基础上又告诉我一句话，额外信息量是4，那么两句话信息量加起来应该等于7吧！难道还能是5是9？ 34 | 35 | 三，刚刚已经提过，信息量跟概率有关系，但我们应该会觉得，信息量是连续依赖于概率的吧！就是说，某一个概率变化了0.0000001，那么这个信息量不应该变化很大。 36 | 37 | 四，刚刚也提过，信息量大小跟可能结果数量有关。假如每一个可能的结果出现的概率一样，那么对于可能结果数量多的那个事件，新信息有更大的潜力具有更大的信息量，因为初始状态下不确定性更大。 38 | 39 | 那有什么函数能满足上面四个条件呢？负的对数函数，也就是-log（x）！底数取大于1的数保证这个函数是非负的就行。前面再随便乘个正常数也行。 40 | a. 为什么不是正的？因为假如是正的，由于x是小于等于1的数，log（x）就小于等于0了。第一个特点满足。 41 | 42 | b. 咱们再来验证一下其他特点。三是最容易的。假如x是一个概率，那么log（x）是连续依赖于x的。done 43 | 44 | c.四呢？假如有n个可能结果，那么出现任意一个的概率是1/n，而-log(1/n)是n的增函数，没问题。 45 | 46 | d.最后验证二。由于-log(xy) = -log(x) -log(y)，所以也是对的。学数学的同学注意，这里的y可以是给定x的条件概率，当然也可以独立于x。 47 | 48 | By the way，这个函数是唯一的（除了还可以多乘上任意一个常数），有时间可以自己证明一下，或者查书。 49 | 50 | ok，所以我们知道一个事件的信息量就是这个事件发生的概率的负对数。 51 | 52 | 最后终于能回到信息熵。信息熵是跟所有可能性有关系的。每个可能事件的发生都有个概率。信息熵就是平均而言发生一个事件我们得到的信息量大小。所以数学上，信息熵其实是信息量的期望。（表达式参考其它答案或者看下面） 53 | 54 | ## 在决策树中的应用 55 | 怎么知道该选哪个条件（variable）去分开（split）数据？ 56 | 57 | 58 | 计算公式： 59 | 60 | ![](https://imgsa.baidu.com/baike/s%3D244/sign=49cc170a35d3d539c53d08c70e86e927/2e2eb9389b504fc2554487f1e6dde71190ef6d2e.jpg) 61 | 62 | 63 | 举例子： 64 | 65 | 二元信源的熵： 66 | 67 | ![](https://imgsa.baidu.com/baike/s%3D220/sign=f34e70ca0ff3d7ca08f63874c21ebe3c/ac345982b2b7d0a267983369c8ef76094a369af4.jpg) 68 | -------------------------------------------------------------------------------- /alg_base/Error&variance.md: -------------------------------------------------------------------------------- 1 | # 误差和方差 2 | 3 | 如下图，当运行一个学习算法时，如果这个算法的表现不理想，那么多半是出现两种情况： 4 | 要么是偏差比较大(欠拟合)，要么是方差比较大（过拟合）。 5 | 6 | 能判断出现的情况是这两种情况中的哪一种非常重要，因为它是一个很有效的指示器， 7 | 告诉我们可以改进算法的最有效的方法和途径。 8 | 9 | ![](http://images2015.cnblogs.com/blog/788978/201604/788978-20160416213113738-43890851.png) 10 | 11 | 沿用之前所使用的训练集误差和验证集误差的定义也就是平方误差，画出下图. 12 | 13 | ![](http://images2015.cnblogs.com/blog/788978/201604/788978-20160416213114098-1355895486.png) 14 | * 如果d等于1，意味着用一个很简单的函数来拟合数据，此时我们不能很好地拟合训练集(欠拟合) 15 | * d等于2，那么我们会得到一个更小的交叉验证误差，因为我们找了一个能够更好拟合数据的次数。 16 | d等于1是用线性函数来进行拟合，而在最右边的这个图表示更高次数的多项式的拟合情况。 17 | * d的值取为4 ，那么我们又过拟合了，我们又会得到一个较大的交叉验证误差。 18 | -------------------------------------------------------------------------------- /alg_base/GiniIndex.md: -------------------------------------------------------------------------------- 1 | # 基尼系数(Gini Index) 2 | 写了一个简单的计算计算基尼系数的程序。 3 | 4 | ``` 5 | # 数据集D 6 | # x = [1,0,1.0,3,4] 7 | # D = [(x1,y1),(x2,y2),(x3,y3)...(xn,yn)] 8 | 9 | def Gini(): 10 | count = 0 11 | clf_count = {} 12 | for d in D: 13 | count++ 14 | if d[1] not in clf_count: 15 | clf_count[d[1]] = 0 16 | clf_count[d[1]]++ 17 | 18 | if count == 0: 19 | return false, 0 20 | 21 | sum = 0 22 | count_squ = count * count 23 | for cc in clf_count: 24 | sum = sum + (cc*cc/count_squ) 25 | return true, (1 - sum) 26 | 27 | # a是数据集中的第i个属性 28 | def Gini_index(i): 29 | # 假设属性a可以取1,2,3三个值 30 | a = [1,2,3] 31 | # 假设样本集中，属性a取1，2，3对应样本数分别为10，20，30 32 | a_col = {1:10, 2:20, 3:30} 33 | count = 10 + 20 + 30 34 | sum = 0 35 | for c,ck in a_col.items(): 36 | dv = [] 37 | for d in D: 38 | if d[i] == ck: 39 | dv.append(d) 40 | sum = sum + (c /count * Gini(dv)) 41 | ``` 42 | 43 | -------------------------------------------------------------------------------- /alg_base/Hierarchical_cluster.md: -------------------------------------------------------------------------------- 1 | # 层次聚类（Hierarchical_cluster） 2 | 3 | ## 工作机制 4 | 假设有N个待聚类的样本，对于层次聚类来说，基本步骤就是： 5 | 1. （初始化）把每个样本归为一类，计算每两个类之间的距离，也就是样本与样本之间的相似度； 6 | 2. 寻找各个类之间最近的两个类，把他们归为一类（这样类的总数就少了一个）； 7 | 3. 重新计算新生成的这个类与各个旧类之间的相似度； 8 | 4. 重复2和3直到所有样本点都归为一类，结束。 9 | 10 | 整个聚类过程其实是建立了一棵树，在建立的过程中，可以通过在第二步上设置一个阈值，当最近的两个类的距离大于这个阈值，则认为迭代可以终止。另外关键的一步就是第三步，如何判断两个类之间的相似度有不少种方法。 11 | 12 | ## 相似度判断 13 | 1. SingleLinkage：又叫做 nearest-neighbor ，就是取两个类中距离最近的两个样本的距离作为这两个集合的距离，也就是说，最近两个样本之间的距离越小，这两个类之间的相似度就越大。容易造成一种叫做 Chaining 的效果，两个 cluster 明明从“大局”上离得比较远，但是由于其中个别的点距离比较近就被合并了，并且这样合并之后 Chaining 效应会进一步扩大，最后会得到比较松散的 cluster 。 14 | 2. CompleteLinkage：这个则完全是 Single Linkage 的反面极端，取两个集合中距离最远的两个点的距离作为两个集合的距离。其效果也是刚好相反的，限制非常大，两个 cluster 即使已经很接近了，但是只要有不配合的点存在，就顽固到底，老死不相合并，也是不太好的办法。这两种相似度的定义方法的共同问题就是指考虑了某个有特点的数据，而没有考虑类内数据的整体特点。 15 | 3. Average-linkage：这种方法就是把两个集合中的点两两的距离全部放在一起求一个平均值，相对也能得到合适一点的结果。average-linkage的一个变种就是取两两距离的中值，与取均值相比更加能够解除个别偏离样本对结果的干扰。 16 | 17 | ## 时间复杂度 18 | 时间复杂度是O(n³)， 19 | * 步骤2时间复杂度是O(n); 20 | * 步骤3时间复杂度是O(n); 21 | * 步骤4时间复杂度是O(n); 22 | 23 | 所以整体的时间复杂度是O(n³)。 24 | -------------------------------------------------------------------------------- /alg_base/InformationGain.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | ## 信息增益（Information Gain） 4 | 5 | 信息增益是按某属性分裂前的熵与按该属性分裂后的熵的差值。 6 | 7 | ### 公式 8 | 9 | ``` 10 | 11 | gain()=infobeforeSplit()–infoafterSplit() 12 | 13 | ``` 14 | ![公式](http://latex.codecogs.com/gif.latex?infoGain%5Cleft&space;(&space;S,&space;A&space;%5Cright&space;)=Entropy%5Cleft&space;(&space;S&space;%5Cright&space;)-%5Csum&space;_%7BV%5Cin&space;Value%5Cleft&space;(&space;A&space;%5Cright&space;)%7D%5Cfrac%7B%5Cleft&space;%7C&space;S_V&space;%5Cright&space;%7C%7D%7B%5Cleft&space;%7C&space;S&space;%5Cright&space;%7C%7DEntropy%5Cleft&space;(&space;S_V&space;%5Cright&space;)) 15 | 16 | 信息增益选择方法有一个很大的缺陷，它总是会倾向于选择属性值多的属性，如果训练集中加一个姓名属性，假设14条记录中的每个人姓名不同，那么信息增益就会选择姓名作为最佳属性，因为按姓名分裂后，每个组只包含一条记录，而每个记录只属于一类（要么购买电脑要么不购买），因此纯度最高，以姓名作为测试分裂的结点下面有14个分支。但是这样的分类没有意义，它没有任何泛化能力。增益比率对此进行了改进，它引入一个分裂信息： 17 | 18 | 19 | -------------------------------------------------------------------------------- /alg_base/InformationGainRadio.md: -------------------------------------------------------------------------------- 1 | 2 | ## 信息增益比（Information Gain Ratio） 3 | 4 | 信息增益比是信息增益除以按某属性分裂前的熵。 5 | 6 | ### 公式 7 | 8 | ``` 9 | # gain()信息增益 10 | # infobeforeSplit()按属性a划分前信息熵 11 | # infoafterSplit()按属性a划分后的信息熵 12 | gain() = infobeforeSplit() – infoafterSplit() 13 | 14 | # IV称作固有值，划分属性a的取值越多，IV越大 15 | IV() = infoafterSplit() 16 | 17 | GainRatio=gain() / IV() 18 | 19 | ``` 20 | 21 | 22 | -------------------------------------------------------------------------------- /alg_base/Intention_recognition.md: -------------------------------------------------------------------------------- 1 | # Intention recognition 2 | 调研用LSTM+Softmax和Rasa做意图识别的可行性。 3 | 4 | # Reference 5 | 1. [机器人意图识别和词槽抽取RasaNLU解析](https://blog.csdn.net/m0epNwstYk4/article/details/80479967) 6 | 2. [用LSTM和softmax做意图识别](https://www.cnblogs.com/ModifyRong/p/8546421.html) 7 | 3. [用CNN和softmax做意图识别](https://zhuanlan.zhihu.com/p/41944121) 8 | 9 | -------------------------------------------------------------------------------- /alg_base/Jupyterhub-install-tutorial.md: -------------------------------------------------------------------------------- 1 | # Jupyterhub install tutorial 2 | 3 | **一、下载安装依赖：** 4 | 5 | Make sure that: 6 | * Python 3.5 or greater 7 | * nodejs/npm environment 8 | 9 | 执行如下命令操作： 10 | 11 | > sudo apt-get install npm nodejs-legacy 12 | 13 | > npm install -g configurable-http-proxy 14 | 15 | > pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple notebook 16 | 17 | > pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple jupyter 18 | 19 | **二、安装jupyterhub：** 20 | 21 | > python3.5 -m pip install jupyterhub 22 | 23 | **三、安装及配置：** 24 | 25 | **1. 生成配置文件** 26 | 27 | > mkdir /etc/jupyterhub 28 | 29 | > cd /etc/jupyterhub 30 | 31 | > jupyterhub --generate-config 32 | 33 | **2. 配置ip和port** 34 | 35 | > vim /etc/jupyterhub/jupyterhub_config.py 36 | 37 | > c.JupyterHub.bind_url = 'http://ip_adress:port' 38 | 39 | 40 | **3. 设置为系统服务，开机自启** 41 | 42 | > touch /lib/systemd/system/jupyterhub.service 43 | 44 | 45 | ``` 46 | [Unit] 47 | Description=Jupyterhub 48 | 49 | [Service] 50 | User=root 51 | Environment="PATH=/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin" 52 | ExecStart=/usr/local/bin/jupyterhub -f /etc/jupyterhub/jupyterhub_config.py 53 | 54 | [Install] 55 | WantedBy=multi-user.target 56 | ``` 57 | 启动： 58 | 59 | > service jupyterhub start 60 | 61 | **四、 浏览器访问** 62 | 63 | http://ip_adress:port/ 64 | 65 | 66 | **五、如何添加python虚拟环境到juperhub** 67 | ``` 68 | # 进入python虚拟环境 69 | source ~/tensorflow-py3.5/bin/activate 70 | 71 | # 安装ipykernel 72 | pip3.5 install ipykernel 73 | 74 | # 将tensorflow-py3,5加入到ipykernel 75 | python3.5 -m ipykernel install --user --name=tensorflow-py3,5 76 | 77 | # 重启服务使之生效 78 | service jupyterhub restart 79 | 80 | ``` 81 | -------------------------------------------------------------------------------- /alg_base/MachineLearningAlgorithms.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/alg_base/MachineLearningAlgorithms.png -------------------------------------------------------------------------------- /alg_base/MaxPooling1D_GlobalMaxPooling1D.md: -------------------------------------------------------------------------------- 1 | # MaxPooling1D和GlobalMaxPooling1D区别 2 | 3 | 说不明白，直接上代码，看打印： 4 | 5 | ``` 6 | import numpy as np 7 | from keras.models import Sequential 8 | from keras.layers import Dense, LSTM, GlobalMaxPooling1D,MaxPooling1D 9 | 10 | D = np.random.rand(10, 6, 10) 11 | 12 | model = Sequential() 13 | model.add(LSTM(16, input_shape=(6, 10), return_sequences=True)) 14 | model.add(MaxPooling1D(pool_size=2, strides=1)) 15 | model.add(LSTM(10)) 16 | model.add(Dense(1)) 17 | model.compile(loss='binary_crossentropy', optimizer='sgd') 18 | model.summary() 19 | ``` 20 | 打印： 21 | Layer (type) Output Shape Param # 22 | ================================================================= 23 | lstm_4 (LSTM) (None, 6, 16) 1728 24 | _________________________________________________________________ 25 | max_pooling1d_2 (MaxPooling1 (None, 5, 16) 0 26 | _________________________________________________________________ 27 | lstm_5 (LSTM) (None, 10) 1080 28 | _________________________________________________________________ 29 | dense_2 (Dense) (None, 1) 11 30 | ================================================================= 31 | Total params: 2,819 32 | Trainable params: 2,819 33 | Non-trainable params: 0 34 | _________________________________________________________________ 35 | 36 | ``` 37 | model = Sequential() 38 | model.add(LSTM(16, input_shape=(6, 10), return_sequences=True)) 39 | model.add(GlobalMaxPooling1D()) 40 | model.add(Dense(1)) 41 | model.compile(loss='binary_crossentropy', optimizer='sgd') 42 | 43 | model.summary() 44 | ``` 45 | 46 | Layer (type) Output Shape Param # 47 | ================================================================= 48 | lstm_7 (LSTM) (None, 6, 16) 1728 49 | _________________________________________________________________ 50 | global_max_pooling1d_2 (Glob (None, 16) 0 51 | _________________________________________________________________ 52 | dense_4 (Dense) (None, 1) 17 53 | ================================================================= 54 | Total params: 1,745 55 | Trainable params: 1,745 56 | Non-trainable params: 0 57 | _________________________________________________________________ 58 | -------------------------------------------------------------------------------- /alg_base/One-hot-Representation.md: -------------------------------------------------------------------------------- 1 | # One-Hot Representation 2 | 3 | 4 | 一种最简单的词向量方式是 one-hotrepresentation，就是用一个很长的向量来表示一个词，向量的长度为词典的大小，向量的分量只有一个 1，其他全为 0， 1 的位置对应该词在词典中的位置。举个例子， 5 | 6 | 　　 7 | “话筒”表示为 [0 0 0 1 00 0 0 0 0 0 0 0 0 0 0 ...] 8 | 9 | “麦克”表示为 [0 0 0 0 00 0 0 1 0 0 0 0 0 0 0 ...] 10 | 11 | 每个词都是茫茫 0 海中的一个 1。 12 | 13 | 这种 One-hot Representation 如果采用稀疏方式存储，会是非常的简洁：也就是给每个词分配一个数字 ID。比如刚才的例子中，话筒记为 3，麦克记为 8（假设从 0 开始记）。如果要编程实现的话，用 Hash 表给每个词分配一个编号就可以了。这么简洁的表示方法配合上最大熵、SVM、CRF 等等算法已经很好地完成了 NLP 领域的各种主流任务。 14 | 15 | 但这种词表示有两个缺点： 16 | 1. 容易受维数灾难的困扰，尤其是将其用于 Deep Learning 的一些算法时； 17 | 2. 不能很好地刻画词与词之间的相似性（术语好像叫做“词汇鸿沟”）：任意两个词之间都是孤立的。光从这两个向量中看不出两个词是否有关系，哪怕是话筒和麦克这样的同义词也不能幸免于难。 18 | 19 | 所以会寻求发展，用另外的方式表示，就是下面这种。 20 | -------------------------------------------------------------------------------- /alg_base/Principles_of_Decision_tree.md: -------------------------------------------------------------------------------- 1 | # 决策树 2 | ## 定义 3 | [决策树的定义](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/alg_base/decision_tree.md) 4 | 5 | [什么是熵？](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/alg_base/Entropy.md) 6 | 7 | ## 决策树的属性划分 8 | 决策树学习的关键在于如何选择最优的划分属性。 9 | 10 | 一般而言，随着划分的不断进行，我们希望决策树的分支结点所包含的样本尽可能属于同一类别（即结点的纯度(purity)越来越高）。 11 | 12 | 判断结点的纯度的主要方法： 13 | * [信息增益](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/alg_base/InformationGain.md)； 14 | * [增益比](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/alg_base/InformationGainRadio.md)； 15 | * [基尼指数](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/alg_base/GiniIndex.md)。 16 | 17 | ### 主要算法 18 | 决策树的划分选择主要包括ID3、C4.5和CART。 19 | * ID3决策树算法使用信息增益判断纯度； 20 | * C4.5决策树使用增益比 21 | * CART决策树使用基尼指数 22 | 23 | ## 训练与生成决策树 24 | 1. [Generate](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/alg_base/decision_tree_generate.md) 25 | 2. [Pruning](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/alg_base/Pruning.md) 26 | ## 代码实现 27 | [CART tree with python](https://machinelearningmastery.com/implement-decision-tree-algorithm-scratch-python/) 28 | -------------------------------------------------------------------------------- /alg_base/Pruning.md: -------------------------------------------------------------------------------- 1 | # 剪枝(Pruning) 2 | 剪枝是决策树解决过拟合问题的主要手段。在决策树学习过程中，为了尽可能正确分类样本，结点划分不断重复，造成决策树分支过多，产生过拟合。 3 | 4 | 决策树剪枝分为：预剪枝(pre-pruning)和后剪枝(post-pruning)。 5 | 6 | ## 预剪枝(pre-pruning) 7 | 预剪枝是指在决策树生成过程中，对每个阶段在划分前后进行估计，若当前阶段的划分不能带来决策树泛化性能的提升，则停止划分，并将当前节点标记为叶节点。 8 | 9 | ## 后剪枝(post-pruning) 10 | 后剪枝是指先从训练集生成一棵完整的决策树，然后自底向上地对非叶节点进行考察，若将该节点对应的子树替换成叶节点能带来决策树泛化性能的提升，则将该子树替换为叶节点。 11 | 12 | ## 预剪枝与后剪枝对比 13 | 14 | * 后剪枝决策树通常比预剪枝决策树保留更多的分支，一般情况下，后剪枝决策树的欠拟合风险更小，泛化性能往往优于预剪枝决策树。 15 | * 后剪枝决策树是先生成完整决策树，然后自底向上地对树中的所有非叶子节点进行逐一考察，因此其训练时间开销比未剪枝决策树和预剪枝决策树都要大的多。 16 | -------------------------------------------------------------------------------- /alg_base/RandomForest.md: -------------------------------------------------------------------------------- 1 | # 随机森林 （Random Forest） 2 | 3 | ## 工作机制 4 | 1. 从原始训练数据集中，应⽤自助采样法(bootstrap)⽅法有放回地随机抽取k个新的⾃助样本集， 5 | 并由此构建k棵分类回归树，每次未被抽到的样本组成了Ｋ个袋外数据（out-ofbag,BBB）； 6 | 2. 设有n个特征，则在每⼀棵树的每个节点处随机抽取m个特征，从子集中选择最优特征划分； 7 | 3. 每棵树最⼤限度地⽣长， 不做任何剪裁； 8 | 4. 将⽣成的多棵树组成随机森林， ⽤随机森林对新的数据进⾏分类， 9 | 分类结果按树分类器投票多少⽽定。 10 | 11 | ## 性能 12 | 与Bagging对比，Bagging使用却限定性决策树，在选择特征划分时对所有结点进行考察，随机森林只对部分特征进行考察，所以RF性能高于Bagging。 13 | -------------------------------------------------------------------------------- /alg_base/TF-idf.md: -------------------------------------------------------------------------------- 1 | # TF–IDF 2 | 3 | > [请参照阮一峰的博客](http://www.ruanyifeng.com/blog/2013/03/tf-idf.html) 4 | -------------------------------------------------------------------------------- /alg_base/appendix.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 依存句法关系 4 | ------------- 5 | 6 | +------------+-----+----------------------------+----------------------------+ 7 | | 关系类型 | Tag | Description | Example | 8 | +============+=====+============================+============================+ 9 | | 主谓关系 | SBV | subject-verb | 我送她一束花 (我 <-- 送) | 10 | +------------+-----+----------------------------+----------------------------+ 11 | | 动宾关系 | VOB | 直接宾语，verb-object | 我送她一束花 (送 --> 花) | 12 | +------------+-----+----------------------------+----------------------------+ 13 | | 间宾关系 | IOB | 间接宾语，indirect-object | 我送她一束花 (送 --> 她) | 14 | +------------+-----+----------------------------+----------------------------+ 15 | | 前置宾语 | FOB | 前置宾语，fronting-object | 他什么书都读 (书 <-- 读) | 16 | +------------+-----+----------------------------+----------------------------+ 17 | | 兼语 | DBL | double | 他请我吃饭 (请 --> 我) | 18 | +------------+-----+----------------------------+----------------------------+ 19 | | 定中关系 | ATT | attribute | 红苹果 (红 <-- 苹果) | 20 | +------------+-----+----------------------------+----------------------------+ 21 | | 状中结构 | ADV | adverbial | 非常美丽 (非常 <-- 美丽) | 22 | +------------+-----+----------------------------+----------------------------+ 23 | | 动补结构 | CMP | complement | 做完了作业 (做 --> 完) | 24 | +------------+-----+----------------------------+----------------------------+ 25 | | 并列关系 | COO | coordinate | 大山和大海 (大山 --> 大海) | 26 | +------------+-----+----------------------------+----------------------------+ 27 | | 介宾关系 | POB | preposition-object | 在贸易区内 (在 --> 内) | 28 | +------------+-----+----------------------------+----------------------------+ 29 | | 左附加关系 | LAD | left adjunct | 大山和大海 (和 <-- 大海) | 30 | +------------+-----+----------------------------+----------------------------+ 31 | | 右附加关系 | RAD | right adjunct | 孩子们 (孩子 --> 们) | 32 | +------------+-----+----------------------------+----------------------------+ 33 | | 独立结构 | IS | independent structure | 两个单句在结构上彼此独立 | 34 | +------------+-----+----------------------------+----------------------------+ 35 | | 核心关系 | HED | head | 指整个句子的核心 | 36 | +------------+-----+----------------------------+----------------------------+ 37 | 38 | 语义角色类型 39 | ------------ 40 | 41 | +--------------+------------------------------------------------+ 42 | | 语义角色类型 | 说明 | 43 | +==============+================================================+ 44 | | ADV | adverbial, default tag ( 附加的，默认标记 ) | 45 | +--------------+------------------------------------------------+ 46 | | BNE | beneficiary ( 受益人 ) | 47 | +--------------+------------------------------------------------+ 48 | | CND | condition ( 条件 ) | 49 | +--------------+------------------------------------------------+ 50 | | DIR | direction ( 方向 ) | 51 | +--------------+------------------------------------------------+ 52 | | DGR | degree ( 程度 ) | 53 | +--------------+------------------------------------------------+ 54 | | EXT | extent ( 扩展 ) | 55 | +--------------+------------------------------------------------+ 56 | | FRQ | frequency ( 频率 ) | 57 | +--------------+------------------------------------------------+ 58 | | LOC | locative ( 地点 ) | 59 | +--------------+------------------------------------------------+ 60 | | MNR | manner ( 方式 ) | 61 | +--------------+------------------------------------------------+ 62 | | PRP | purpose or reason ( 目的或原因 ) | 63 | +--------------+------------------------------------------------+ 64 | | TMP | temporal ( 时间 ) | 65 | +--------------+------------------------------------------------+ 66 | | TPC | topic ( 主题 ) | 67 | +--------------+------------------------------------------------+ 68 | | CRD | coordinated arguments ( 并列参数 ) | 69 | +--------------+------------------------------------------------+ 70 | | PRD | predicate ( 谓语动词 ) | 71 | +--------------+------------------------------------------------+ 72 | | PSR | possessor ( 持有者 ) | 73 | +--------------+------------------------------------------------+ 74 | | PSE | possessee ( 被持有 ) | 75 | +--------------+------------------------------------------------+ 76 | -------------------------------------------------------------------------------- /alg_base/bpe.md: -------------------------------------------------------------------------------- 1 | 2 | # BPE 3 | 4 | BPE，（byte pair encoder）字节对编码，也可以叫做digram coding双字母组合编码，主要目的是为了数据压缩，算法描述为字符串里频率最常见的一对字符被一个没有在这个字符中出现的字符代替的层层迭代过程。具体在下面描述。该算法首先被提出是在Philip Gage的C Users Journal的 1994年2月的文章“A New Algorithm for Data Compression”。 5 | 6 | 算法过程 7 | 8 | 这个算法个人感觉很简单，下面就来讲解下： 9 | 10 | 比如我们想编码： 11 | 12 | aaabdaaabac 13 | 14 | 我们会发现这里的aa出现的词数最高（我们这里只看两个字符的频率），那么用这里没有的字符Z来替代aa： 15 | 16 | ``` 17 | ZabdZabac 18 | 19 | Z=aa 20 | ``` 21 | 22 | 此时，又发现ab出现的频率最高，那么同样的，Y来代替ab： 23 | 24 | ``` 25 | ZYdZYac 26 | 27 | Y=ab 28 | 29 | Z=aa 30 | ``` 31 | 32 | 同样的，ZY出现的频率大，我们用X来替代ZY： 33 | 34 | ``` 35 | XdXac 36 | 37 | X=ZY 38 | 39 | Y=ab 40 | 41 | Z=aa 42 | ``` 43 | 44 | 最后，连续两个字符的频率都为1了，也就结束了。就是这么简单。 45 | 46 | 解码的时候，就按照相反的顺序更新替换即可。 47 | 48 | 参考https://cloud.tencent.com/developer/article/1089017 49 | -------------------------------------------------------------------------------- /alg_base/cluster_concept.md: -------------------------------------------------------------------------------- 1 | # 聚类基本概念 2 | 3 | 聚类任务是无监督学习(unsupervised Learning)，训练样本的标记是未知的。目标是通过对无标记的训练样本的学习来揭示数据的内在性质规律。 4 | 5 | 聚类试图将数据集中的样本划分为若干个通常是不相交的自己，每个子集称为一个cluster。 6 | -------------------------------------------------------------------------------- /alg_base/cluster_k_means.md: -------------------------------------------------------------------------------- 1 | 2 | # k-means algorithm 3 | 4 | ## Model定义 5 | Input：A set S of n points,also a distance/dissimilarity来度量每个点的距离，例如d(x,y) 6 | 7 | Output:output a parttion of the data 8 | 9 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/1.png) 10 | 11 | ### coputation compexity 12 | * NP hard even for k=2 or d=2 13 | 14 | ### Easy case when k=1 15 | 16 | 17 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/2.png) 18 | 19 | 求导可解， 20 | 21 | 22 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/3.png) 23 | 24 | 其实右边还有一个多项式，从上面可以看出： 25 | 26 | 当C=u时第一个u-c=0, 27 | 28 | 同时summary(Xi-u)也是最小的 29 | 30 | ## 求解方法 31 | ### Lloyd's methold algorithm 32 | Lloyd's methold可以解决，Lloyd's methold如下： 33 | 34 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/4.png) 35 | 36 | #### 为什么Lloyd's methold（面试）？ 37 | 因为每一次迭代，目标函数都会减少，而且目标函数是一个非负的函数。 38 | 39 | 因为单调递减有下界的函数一定是收敛的 40 | 41 | #### initialization of Lloyd's methold 42 | 43 | * random center of datapoint 44 | 45 | * further travel最远遍历 46 | 47 | * k-means++work well and provable guarantees.在工业上实际应用，K-means++本质上与k-means没有区别，只是在初始化阶段有独到的方法 48 | 49 | initialization of Lloyd's methold random 50 | 51 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/5.png) 52 | 53 | 54 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/6.png) 55 | 56 | 57 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/7.png) 58 | 59 | 60 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/8.png) 61 | 62 | 63 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/9.png) 64 | 65 | 最后算法收敛成，如下所示： 66 | 67 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/10.png) 68 | 69 | #### random initialization bad performance 70 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/11.png) 71 | 72 | 73 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/12.png) 74 | 75 | 发生bad performance 的概率 76 | 77 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/13.png) 78 | 79 | 80 | 所以当k大一点的时候，random initialization是不行的。 81 | 82 | 83 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/14.png) 84 | 85 | 但是问题就是对抗噪声的能力差，如下图所示： 86 | 87 | 88 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/15.png) 89 | -------------------------------------------------------------------------------- /alg_base/cluster_k_means_plus.md: -------------------------------------------------------------------------------- 1 | # K-means++ 2 | 3 | ## 核心思想 4 | 5 | K-means++其实核心思想也是选择更远的点作为初始化中心点，不同的是加入了随机化的处理。 6 | 7 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering2/1.jpeg) 8 | 9 | 虽然单个噪声点的概率大，但我们的目的是使初始化点不落入噪声点， 10 | 11 | 如下图所示，除了最右侧的一个噪声点，落入其它点都可以， 12 | 13 | 而经过了归一化的处理之后，落入其它正常点的概率是远远大于落入噪声点的概率，这就是K-means算法的核心思想。 14 | 15 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/14.png) 16 | 17 | ## 效果 18 | 19 | K-means++ always attain an O(logk) approximation to optimal k-means solution in expectation. 20 | 21 | 随机化算法是一个非常常用的技巧， 22 | 23 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering2/2.jpeg) 24 | 25 | ## K-means++ running time 26 | 27 | K-means++ initialization: O(nd) and an pass over data to 28 | select next center. so O(nkd) time in total. 29 | 30 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering2/3.jpeg) 31 | 32 | **上面的图对面试十分重要** 33 | 34 | ## 怎么选择k到底是多少？ 35 | 36 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering2/4.jpeg) 37 | 38 | * k值越大，目标函数误差期望应该越小，尝试增大k的值，当k的值增大，到一定程度时下降越来越慢，找到拐点。 39 | 40 | * 交叉验证数据集，在训练集中训练不同的k，出来不同模型。然后在测试集上验证，找出最好k所在模型。 41 | 42 | ``` 43 | 对于大部分的机器学习，怎么选择合适合适的参数?（面试） 44 | 45 | 1.聚类有多少个类别？ 46 | 47 | 2.神经网络中有多少个神经元？ 48 | 49 | 标准答案用交叉验证，cross-validation做 50 | 51 | ``` 52 | -------------------------------------------------------------------------------- /alg_base/cnn_intro.md: -------------------------------------------------------------------------------- 1 | # CNN 2 | 3 | 参考链接：https://morvanzhou.github.io/tutorials/machine-learning/keras/2-3-A-CNN/ 4 | 5 | -------------------------------------------------------------------------------- /alg_base/data_clean.md: -------------------------------------------------------------------------------- 1 | # 数据清洗 2 | 3 | ## 基本概念 4 | 一个谚语： 5 | > garbage in, garbage out 6 | 7 | 所以好的训练集输入直接影响训练出的模型的泛化能力。于是在实际中，数据清洗这个过程会花掉一大部分时间，而且它会使得你对于业务的理解非常透彻。 8 | 9 | 简而言之： 10 | > 数据清洗做的事情 => 去掉脏数据 11 | 12 | 13 | ## 数据清洗示例/思考角度 14 | 15 | 简单的impossible 16 | > (1)身高3米+的人？ 17 | 18 | > (2)一个月买脸盆墩布买了10w的人 19 | 20 | > (3)… 21 | 22 | 组合或统计属性判定 23 | 24 | > (1)号称在米国却ip一直都是大陆的新闻阅读用户？ 25 | 26 | > (2)你要判定一个人是否会买篮球鞋，样本中女性用户85%？ 27 | 28 | 补齐可对应的缺省值 29 | 30 | > (1)不可信的样本丢掉，缺省值极多的字段考虑不用 31 | -------------------------------------------------------------------------------- /alg_base/data_normalization.md: -------------------------------------------------------------------------------- 1 | # 数据归一化问题 2 | 数据归一化属于数据的预处理。因为sigmoid函数根据不同的变换，输出在0到1或者－1到1之间， 3 | 因此如果不做归一，就会出现样本输出超出神经网络输出的范围。选择最大的值max和最小值min，做如下变换 4 | 5 | x＝(x－min)/(max-min) 6 | 7 | 就是归一化。 8 | 需要注意的是max和min不应该直接选择为x中的最大值和最小值。原因是样本只是有限的观测，有可能还有更大或者更小的观测， 9 | 因此合适的选择应该max选取xmax大一些和min比xmin小一些的。归一化并不总是合适的预处理， 10 | 因为它不能使分布不对称的样本变得更对称一些，标准化要好一些。另外，有时候主成分分析也能起到降维的作用。 11 | -------------------------------------------------------------------------------- /alg_base/data_sample.md: -------------------------------------------------------------------------------- 1 | # 数据采集 2 | ## 数据采集应该考虑的问题 3 | 1. 哪些数据对最后的结果预测有帮助； 4 | 2. 数据我们能够采集到吗； 5 | 3. 线上实时计算的时候获取是否快捷； 6 | 7 | ## 数据采用常遇到的问题 8 | 9 | 很多情况下，正负样本是不均衡的，比如： 10 | * 电商的用户点/买过的商品和没有行为的商品； 11 | * 某些疾病的患者与健康人； 12 | 13 | 大多数模型对正负样本比是敏感的（比如LR），则要采取分层采样的技巧，保证采样到的数据也保持平衡。 14 | 15 | ### 正负样本不平衡处理办法 16 | 1. 正样本远大于负样本，且正负样本的量都挺大，采用下采样。 17 | 2. 正样本远远大于负样本，且正负样本的量不大，主要方法： 18 | * 采集更多的数据； 19 | * 上采样(比如图像识别中的镜像和旋转)； 20 | * 修改损失函数（loss function）。 21 | 22 | *假设正样本数比负样本数远大，则会照顾正样本。所以应该调整代价。* 23 | 24 | [关于下采样和上采样，请参考](https://www.cnblogs.com/han1ning1/p/6924404.html) 25 | -------------------------------------------------------------------------------- /alg_base/dataset_classification.md: -------------------------------------------------------------------------------- 1 | # 数据集分类 2 | 在有监督(supervise)的机器学习中，数据集常被分成2~3个，即：训练集(train set) 验证集(validation set) 测试集(test set)。 3 | 训练集用来估计模型，验证集用来确定网络结构或者控制模型复杂程度的参数，而测试集则检验最终选择最优的模型的性能如何。 4 | Ripley, B.D（1996）在他的经典专著Pattern Recognition and Neural Networks中给出了这三个词的定义。 5 | 6 | ``` 7 | Training set: 8 | A set of examples used for learning, which is to fit the parameters [i.e., weights] of the classifier. 9 | Validation set: 10 | A set of examples used to tune the parameters [i.e., architecture, not weights] of a classifier, for example to choose the number of hidden units in a neural network. 11 | Test set: 12 | A set of examples used only to assess the performance [generalization] of a fully specified classi 13 | ``` 14 | -------------------------------------------------------------------------------- /alg_base/dataset_partition.md: -------------------------------------------------------------------------------- 1 | # 数据集划分 2 | 请参考博文，不再赘述。[点击查看](http://blog.csdn.net/chl033/article/details/4671750) 3 | 4 | [使用scikit learn中sklearn.cross_validation模块划分数据集。](http://scikit-learn.org/stable/modules/generated/sklearn.cross_validation.KFold.html#sklearn.cross_validation.KFold) 5 | -------------------------------------------------------------------------------- /alg_base/debug_ml_alg.md: -------------------------------------------------------------------------------- 1 | # 如何调试学习算法 2 | 现在假设我们已经实现了如下的一个正则化的线性回归模型用于预测房价 3 | 4 | 根据已有的训练集，我们已经将该模型训练完毕。但是，当我们需要在新的数据集上进行房价的预测时，发现预测的结果和实际有很大的误差。下面我们应该做什么？我们可以从下面的一些角度考虑: 5 | 6 | ## 获取更多的数据量 7 | 8 | * 有时数据量大并没有帮助 9 | * 通常数据量越大，学习模型训练得越好，但是即使这样，也应该做一些初步实验（见6.5节 学习曲线）来确保数据量越大，训练越好。(如果一开始就用大量的数据来训练模型，将会耗费大量的时间：收集数据，训练模型) 10 | 11 | ## 减少特征量 12 | * 细心的从已有的特征量中选出一个子集 13 | * 可以手工选择，也可以用一些降维( dimensionality reduction)技术 14 | 15 | ## 增加额外的特征量 16 | * 有时并不起作用 17 | * 仔细考虑数据集，是否遗漏了一些重要的特征量(可能花费较多的时间) 18 | * 添加的特征量可能只是训练集的特征，不适合全体数据集，可能会过拟合 19 | 4. 添加多项式的特征量 20 | * 减少正则化参数 21 | * 增加正则化参数 22 | 23 | 可以发现，我们似乎有很多种方法来改善学习模型，但是，有些方法可能要花费很多时间（或许还不起作用），有些方法可能是矛盾的。所以，需要一种方式来给我们指明方向：到底应该采用哪种或哪些方式来优化模型。我们将这种方式称为机器学习诊断(Machine Learning Diagnostics)。机器学习诊断是一种测试法，能够深入了解某种算法到底是否有用。这通常也能够告诉我们，要想改进一种算法的效果，什么样的尝试才是有意义的，从而节省时间，减少不必要的尝试。 24 | 。 25 | -------------------------------------------------------------------------------- /alg_base/decision_tree.md: -------------------------------------------------------------------------------- 1 | # 决策树 2 | 3 | ## 基本概念 4 | 通俗来说，决策树分类的思想类似于找对象。现想象一个女孩的母亲要给这个女孩介绍男朋友，于是有了下面的对话： 5 | ``` 6 | 女儿：多大年纪了？ 7 | 8 | 母亲：26。 9 | 10 | 女儿：长的帅不帅？ 11 | 12 | 母亲：挺帅的。 13 | 14 | 女儿：收入高不？ 15 | 16 | 母亲：不算很高，中等情况。 17 | 18 | 女儿：是公务员不？ 19 | 20 | 母亲：是，在税务局上班呢。 21 | 22 | 女儿：那好，我去见见。 23 | ``` 24 | 这个女孩的决策过程就是典型的分类树决策。相当于通过年龄、长相、收入和是否公务员对将男人分为两个类别：见和不见。 25 | 假设这个女孩对男人的要求是：30岁以下、长相中等以上并且是高收入者或中等以上收入的公务员，那么这个可以用下图表示女孩的决策逻辑 26 | （声明：此决策树纯属为了写文章而YY的产物，没有任何根据，也不代表任何女孩的择偶倾向，请各位女同胞莫质问我^_^）： 27 | 28 | ![](http://images.cnblogs.com/cnblogs_com/leoo2sk/WindowsLiveWriter/34d255f282ae_B984/1_3.png) 29 | 30 | 上图完整表达了这个女孩决定是否见一个约会对象的策略，其中绿色节点表示判断条件，橙色节点表示决策结果，箭头表示在一个判断条件在不同情况下的决策路径，图中红色箭头表示了上面例子中女孩的决策过程。 31 | 32 | 这幅图基本可以算是一颗决策树，说它“基本可以算”是因为图中的判定条件没有量化，如收入高中低等等，还不能算是严格意义上的决策树，如果将所有条件量化， 33 | 则就变成真正的决策树了。 34 | 35 | 有了上面直观的认识，我们可以正式定义决策树了 36 | 37 | **决策树（decision tree）是一个树结构（可以是二叉树或非二叉树）。其每个非叶节点表示一个特征属性上的测试，** 38 | **每个分支代表这个特征属性在某个值域上的输出，而每个叶节点存放一个类别。使用决策树进行决策的过程就是从根节点开始，** 39 | **测试待分类项中相应的特征属性，并按照其值选择输出分支，直到到达叶子节点，将叶子节点存放的类别作为决策结果。** 40 | 41 | 可以看到，决策树的决策过程非常直观，容易被人理解。目前决策树已经成功运用于医学、制造产业、天文学、分支生物学以及商业等诸多领域。 42 | 知道了决策树的定义以及其应用方法，下面介绍决策树的构造算法。 43 | 44 | 45 | 本文转自[博文](http://www.cnblogs.com/leoo2sk/archive/2010/09/19/decision-tree.html) 46 | -------------------------------------------------------------------------------- /alg_base/decision_tree_generate.md: -------------------------------------------------------------------------------- 1 | # 构造决策树 2 | 不同于贝叶斯算法，决策树的构造过程不依赖领域知识，它使用属性选择度量来选择将元组最好地划分成不同的类的属性。所谓决策树的构造就是进行属性选择度量确定各个特征属性之间的拓扑结构。 3 | 4 | 构造决策树的关键步骤是分裂属性。所谓分裂属性就是在某个节点处按照某一特征属性的不同划分构造不同的分支， 5 | 其目标是让各个分裂子集尽可能地“纯”。尽可能“纯”就是尽量让一个分裂子集中待分类项属于同一类别。分裂属性分为三种不同的情况： 6 | 7 | 1. 属性是离散值且不要求生成二叉决策树。此时用属性的每一个划分作为一个分支。 8 | 2. 属性是离散值且要求生成二叉决策树。此时使用属性划分的一个子集进行测试，按照“属于此子集”和“不属于此子集”分成两个分支。 9 | 3. 属性是连续值。此时确定一个值作为分裂点split_point，按照>split_point和<=split_point生成两个分支。 10 | 11 | 构造决策树的关键性内容是进行属性选择度量，属性选择度量是一种选择分裂准则， 12 | 是将给定的类标记的训练集合的数据划分D“最好”地分成个体类的启发式方法，它决定了拓扑结构及分裂点split_point的选择。 13 | 14 | 属性选择度量算法有很多，一般使用自顶向下递归分治法，并采用不回溯的贪心策略。 15 | -------------------------------------------------------------------------------- /alg_base/estimator.md: -------------------------------------------------------------------------------- 1 | # Choosing the right estimator 2 | 3 | Often the hardest part of solving a machine learning problem can be finding the right estimator for the job. 4 | 5 | Different estimators are better suited for different types of data and different problems. 6 | 7 | The flowchart below is designed to give users a bit of a rough guide on how to approach problems with regard to which estimators to try on your data. 8 | 9 | Click on any estimator in the chart below to see its documentation. 10 | 11 | ![](http://scikit-learn.org/stable/_static/ml_map.png) 12 | 13 | 14 | [Jump to scikit-learn](http://scikit-learn.org/stable/tutorial/machine_learning_map/index.html) 15 | 16 | ## 模型参数 17 | 交叉验证（cross validation） 18 | > 交叉验证集做参数/模型选择 19 | 20 | > 测试集只做模型效果评估 21 | -------------------------------------------------------------------------------- /alg_base/estimator_optimize.md: -------------------------------------------------------------------------------- 1 | # 模型效果优化 2 | 3 | 根据模型学习曲线可以判断模型的状态。[更多模型学习曲线点击跳转。](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/alg_base/learning_carve.md) 4 | 5 | ## 方法 6 | 模型不同状态的处理： 7 | 8 | 过拟合： 9 | * 找更多的数据来学习； 10 | * 增大正则化系数； 11 | * 减少特征个数(不是太推荐)。 12 | *注意：不要以为降维可以解决过拟合问题* 13 | 14 | 欠拟合： 15 | * 找更多的特征； 16 | * 减小正则化系数； 17 | *除了分析模型状态之外，还可以分析线性模型的权重，以及bad case。* 18 | 19 | ## 线性模型权重的分析 20 | 这里说的线性的模型，主要包括线性或者线性kernel的model，如： 21 | * Linear Regression； 22 | * Logistic Regression； 23 | * Linear SVM。 24 | 25 | 处理方法是对权重绝对值高或低的特征做： 26 | * 更细化的工作； 27 | * 特征组合。 28 | 29 | ## 验证集结果中的Bad case的分析 30 | 分类问题： 31 | * 哪些训练样本分错了？ 32 | * 我们哪部分特征使得它做了这个判定？ 33 | * 这些bad case有没有共性？ 34 | * 是否有还没挖掘的特性？ 35 | 36 | 回归问题： 37 | 38 | 哪些样本预测结果差距大，为什么？ 39 | -------------------------------------------------------------------------------- /alg_base/features.md: -------------------------------------------------------------------------------- 1 | # 特征选择 2 | * 过滤型 sklearn.feature_selection.SelectKBest （每个feature与label之间的相关性）; 3 | * 包裹型 sklearn.feature_selection.RFE （把feature排个序，再考察）; 4 | * 嵌入型 feature_selection.SelectFromModel Linear model，L1正则化（L1正则化可以截断特征，使W系数为0，L2对特征有缩放效应）. 5 | -------------------------------------------------------------------------------- /alg_base/features_concept.md: -------------------------------------------------------------------------------- 1 | # 特征工程 2 | 3 | ## 特征和特征工程 4 | 5 | 特征是数据中抽取出来的对结果预测有用的信息。 6 | 7 | 特征工程是使用专业背景知识和技巧处理数据，使得特征能在机器学习算法上发挥更好的作用的过程。 8 | 9 | ## 特征工程的意义 10 | 11 | 1. 更好的特征意味着更强的灵活度； 12 | 2. 更好的特征意味着只需用简单模型； 13 | 3. 更好的特征意味着更好的结果。 14 | 15 | ### 特征工程在应用举例 16 | 17 | 工业界的特征工程有多大作用呢？ 18 | 1. 某搜索引擎厂，广告部门； 19 | 2. 2周内完成的特征更新，AUC提升约3-5‰。 20 | 21 | 一个月完成的模型优化，AUC提升约5‰ 22 | 1. 某电商，商品推荐； 23 | 2. 推荐大赛第一名的组，基于特征工程，比工程师的推荐准确。 24 | 度提升16% 25 | 26 | 阿里天池比赛 27 | 1. 各种正交特征能做到上万维。 28 | -------------------------------------------------------------------------------- /alg_base/features_handle.md: -------------------------------------------------------------------------------- 1 | # 特征处理 2 | 根据数据类型，可以将特征处理分为： 3 | 4 | * 数值型 5 | * 类别型 6 | * 时间类 7 | * 文本型 8 | * 统计型 9 | * 组合特征 10 | 11 | ## 数值型 12 | * 幅度调整/归一化 13 | * Log等变化(例如等比变等差) 14 | * 统计值max, min, mean, std 15 | * 离散化（把连续值，切段） 16 | * Hash分桶 17 | * 每个类别下对应的变量统计值histogram(分布状况) 18 | * 试试 数值型 => 类别型 19 | [参考博文](http://www.cnblogs.com/chaosimple/p/4153167.html) 20 | 21 | ## 类别型 22 | ### 特征处理之类别型 23 | * one-hot编码 24 | * 哑变量 25 | * Hash与聚类处理 26 | * 统计每个类别变量下各个target比例，转成数值型 27 | 28 | ## 时间类型 29 | 既可以看做连续值，也可以看做离散值 30 | ### 连续值 31 | * 持续时间(单页浏览时长) 32 | * 间隔时间(上次购买/点击离现在的时间) 33 | ## 离散值 34 | * 一天中哪个时间段(hour_0-23) 35 | * 一周中星期几(week_monday...) 36 | * 一年中哪个星期 37 | * 一年中哪个季度 38 | * 工作日/周末 39 | 40 | ## 文本类型 41 | ### 词袋 42 | 文本数据预处理后，去掉停用词，剩下的词组成的list， 在词库中的映射稀疏向量。 43 | 44 | 词袋 => word2vec， 45 | word2vec之后可以更好的比较词之间的相似度。 46 | -------------------------------------------------------------------------------- /alg_base/features_handle.md.bak: -------------------------------------------------------------------------------- 1 | # 特征处理 2 | 根据数据类型，可以将特征处理分为： 3 | 4 | * 数值型 5 | * 类别型 6 | * 时间类 7 | * 文本型 8 | * 统计型 9 | * 组合特征 10 | 11 | ## 数值型 12 | * 幅度调整/归一化 13 | * Log等变化(例如等比变等差) 14 | * 统计值max, min, mean, std 15 | * 离散化（把连续值，切段） 16 | * Hash分桶 17 | * 每个类别下对应的变量统计值histogram(分布状况) 18 | * 试试 数值型 => 类别型 19 | 20 | ## 类别型 21 | ### 特征处理之类别型 22 | * one-hot编码 23 | * 哑变量 24 | * Hash与聚类处理 25 | * 统计每个类别变量下各个target比例，转成数值型 26 | 27 | ## 时间类型 28 | 既可以看做连续值，也可以看做离散值 29 | ### 连续值 30 | * 持续时间(单页浏览时长) 31 | * 间隔时间(上次购买/点击离现在的时间) 32 | ## 离散值 33 | * 一天中哪个时间段(hour_0-23) 34 | * 一周中星期几(week_monday...) 35 | * 一年中哪个星期 36 | * 一年中哪个季度 37 | * 工作日/周末 38 | 39 | ## 文本类型 40 | ### 词袋 41 | 文本数据预处理后，去掉停用词，剩下的词组成的list， 在词库中的映射稀疏向量。 42 | 43 | 词袋 => word2vec， 44 | word2vec之后可以更好的比较词之间的相似度。 45 | -------------------------------------------------------------------------------- /alg_base/generalization.md: -------------------------------------------------------------------------------- 1 | # generalization 2 | ML的central challenge就是model的泛化能力，也就是generalization. 3 | 4 | 5 | > The ability to perform well on previously unobserved inputs is called generalization. 6 | 7 | -------------------------------------------------------------------------------- /alg_base/gradient_descent.md: -------------------------------------------------------------------------------- 1 | # 梯度下降法(Gradient descent) 2 | 3 | ## 梯度的概念 4 | 在微积分里面，对多元函数的参数求∂偏导数，把求得的各个参数的偏导数以向量的形式写出来，就是梯度。比如函数f(x,y), 分别对x,y求偏导数，求得的梯度向量就是(∂f/∂x, ∂f/∂y)T,简称grad f(x,y)或者▽f(x,y)。对于在点(x0,y0)的具体梯度向量就是(∂f/∂x0, ∂f/∂y0)T.或者▽f(x0,y0)，如果是3个参数的向量梯度，就是(∂f/∂x, ∂f/∂y，∂f/∂z)T,以此类推。 5 | 6 | 那么这个梯度向量求出来有什么意义呢？他的意义从几何意义上讲，就是函数变化增加最快的地方。具体来说，对于函数f(x,y),在点(x0,y0)，沿着梯度向量的方向就是(∂f/∂x0, ∂f/∂y0)T的方向是f(x,y)增加最快的地方。或者说，沿着梯度向量的方向，更加容易找到函数的最大值。反过来说，沿着梯度向量相反的方向，也就是 -(∂f/∂x0, ∂f/∂y0)T的方向，梯度减少最快，也就是更加容易找到函数的最小值。 7 | 8 | ## 梯度下降的通俗解释 9 | 首先来看看梯度下降的一个直观的解释。比如我们在一座大山上的某处位置，由于我们不知道怎么下山，于是决定走一步算一步，也就是在每走到一个位置的时候，求解当前位置的梯度，沿着梯度的负方向，也就是当前最陡峭的位置向下走一步，然后继续求解当前位置梯度，向这一步所在位置沿着最陡峭最易下山的位置走一步。这样一步步的走下去，一直走到觉得我们已经到了山脚。当然这样走下去，有可能我们不能走到山脚，而是到了某一个局部的山峰低处。 10 | 11 | 从上面的解释可以看出，梯度下降不一定能够找到全局的最优解，有可能是一个局部最优解。当然，如果损失函数是凸函数，梯度下降法得到的解就一定是全局最优解。 12 | [上段话转自](http://www.cnblogs.com/pinard/p/5970503.html) 13 | 14 | ## 损失函数最优化用到梯度下降算法 15 | 16 | * 梯度学习算法做的事情就是最小化损失函数； 17 | * 梯度代表上升最快的方向，负梯度代表下降最快的方向； 18 | * 在深度学习（deep learning）中，也用到了梯度下降算法SGD； 19 | * 通过上图的递推公式，不断的迭代参数，找到损失函数最小点； 20 | * 学习率是一个超参数（hyper parameter），只有设定好了超参数的值，算法才可以学； 21 | 22 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/1.png) 23 | 24 | 在多元的情况下： 25 | 26 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/2.png) 27 | 28 | 在多元情况下求偏导，其实是在垂直于等高线的方向上，做梯度下降的。 29 | 30 | ### 学习率（learning rate） 31 | 步长（Learning rate）：步长决定了在梯度下降迭代的过程中，每一步沿梯度负方向前进的长度。用上面下山的例子，步长就是在当前这一步所在位置沿着最陡峭最易下山的位置走的那一步的长度。 32 | 33 | 在deep learning神经网络中， 很多时候算法不收敛的原因就是学习率。 34 | 35 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/1.png) 36 | 37 | 以线性回归模型为例： 38 | 1. 如果学习率α过大，会震荡的很厉害，甚至不收敛； 39 | 2. 如果过小，可能收敛很慢； 40 | 3. 在数学上，是可以找出比较优的学习率，但在工业应用上，找到一个差不多的α就可以了； 41 | 4. 随着逐步往下走，斜率会逐渐变小； 42 | 5. 工业上可能拍一组学习率，先去试一下，然后挑出一个； 43 | 6. 在学术上，有很多算法可以调整学习率，但是都会付出相应的代价； 44 | 45 | ### 梯度下降的代数方式描述和矩阵方式描述 46 | 梯度下降的代数方式描述和矩阵方式描述参考[博文](http://www.cnblogs.com/pinard/p/5970503.html)，这篇blog已经写的很好了，我没有必要再写一遍。 47 | 48 | 49 | ### 代码 50 | 51 | ``` 52 | """ 53 | @parameter 54 | X : samples 55 | y : labels 56 | h : hypothesis 57 | theta : W 58 | alpha : learning rate 59 | """ 60 | h = X.dot(theta) 61 | theta = theta - alpha * (1.0/m) * X.T.dot(h-y) 62 | ``` 63 | 64 | ## 梯度下降的算法调优 65 | 在使用梯度下降时，需要进行调优。哪些地方需要调优呢？ 66 | 67 | 1. 算法的步长选择。在前面的算法描述中，我提到取步长为1，但是实际上取值取决于数据样本，可以多取一些值，从大到小，分别运行算法，看看迭代效果，如果损失函数在变小，说明取值有效，否则要增大步长。前面说了。步长太大，会导致迭代过快，甚至有可能错过最优解。步长太小，迭代速度太慢，很长时间算法都不能结束。所以算法的步长需要多次运行后才能得到一个较为优的值。 68 | 69 | 2. 算法参数的初始值选择。 初始值不同，获得的最小值也有可能不同，因此梯度下降求得的只是局部最小值；当然如果损失函数是凸函数则一定是最优解。由于有局部最优解的风险，需要多次用不同初始值运行算法，关键损失函数的最小值，选择损失函数最小化的初值。 70 | 71 | 3.归一化。由于样本不同特征的取值范围不一样，可能导致迭代很慢，为了减少特征取值的影响，可以对特征数据归一化，也就是对于每个特征x，求出它的期望x⎯⎯⎯x¯和标准差std(x)，然后转化为： 72 | 73 | x−x⎯⎯⎯std(x)x−x¯std(x) 74 | 75 | 这样特征的新期望为0，新方差为1，迭代次数可以大大加快。 76 | 77 | 78 | 推荐看一下[博文](http://www.cnblogs.com/pinard/p/5970503.html) 79 | -------------------------------------------------------------------------------- /alg_base/hmm.md: -------------------------------------------------------------------------------- 1 | # HMM 2 | 3 | **首先我们来看看什么样的问题解决可以用HMM模型** 4 | 5 | 使用HMM模型时我们的问题一般有这两个特征： 6 | 7 | 1. 我们的问题是基于序列的，比如时间序列，或者状态序列。 8 | 2. 我们的问题中有两类数据，一类序列数据是可以观测到的，即观测序列；而另一类数据是不能观察到的，即隐藏状态序列，简称状态序列。 9 | 10 | **HMM模型做了两个很重要的假设如下：** 11 | 1. 齐次马尔科夫链假设。即任意时刻的隐藏状态只依赖于它前一个隐藏状态。当然这样假设有点极端，因为很多时候我们的某一个隐藏状态不仅仅只依赖于前一个隐藏状态，可能是前两个或者是前三个。但是这样假设的好处就是模型简单，便于求解。 12 | 2. 观测独立性假设。即任意时刻的观察状态只仅仅依赖于当前时刻的隐藏状态，这也是一个为了简化模型的假设。 13 | 14 | 公式请参考： 15 | > https://zhuanlan.zhihu.com/p/29938926 16 | -------------------------------------------------------------------------------- /alg_base/how_to_read_paper.md: -------------------------------------------------------------------------------- 1 | # 怎么样快速的阅读论文 2 | 3 | 阅读顺序： 4 | 根据阅读目的选择合适的顺序。 5 | * 一般先看abstract、introduction， 6 | * 然后看discussion， 7 | * 最后看result 和method（结合图表）。 8 | 9 | 10 | ## Abstsract 11 | 摘要里面一般包含：目的、结果、结论这三个要素。 12 | 所以看一篇论文，先搞懂这三个要素十分关键 13 | 14 | ## Discussion 15 | 1. 描述results部分最主要的结论； 16 | 2. 主要结论以及与前人观点的对比； 17 | 3. 最后稍微提及本文的不足，为下一步研究埋下伏笔； 18 | 19 | ## Figure 20 | 然后看Figure 及Title 与legend 一看 21 | 22 | ## 通读全文 23 | 读第一遍的时候一定要认真，争取明白每句的大意，能不查字典最好先不查字典。因为读论文的目的并不是学英语，而是获取信息，查了字典以后思维会非常混乱，往往读完全文不知所谓。可以在读的过程中将生字标记，待通读全文后再查找其意思。 24 | 25 | ## 归纳总结 26 | 较长的文章，容易遗忘。好在虽然论文的句子都长，但每段的句数并不多，可以每一段用一个词组标一个标题。 27 | 28 | ## 确立句子的架构 29 | 抓住主题：读英文原版文献有窍门的。我们每个单词都认识读完了却不知他在说什么，这是最大的问题。在阅读的时候一定要看到大量的关系连词，他们承上启下引领了全文。中国人喜欢罗列事实，给出一个观点然后就是大量的事实，这也是中文文献的特点，我们从小都在读这样的文章，很适应。西方人的文献注重逻辑和推理，从头到尾是非常严格的，就像GRE 里面的阅读是一样的，进行的是大量重复、新旧观点的支持和反驳，有严格的提纲，尤其是好的杂志体现得越突出。读每一段落都要找到他的主题，往往是很容易的，大量的无用信息可以一带而过，节约你大量的宝贵时间和精力。 30 | 31 | 32 | ## 论文整理 33 | 文献的整理1.下载电子版文献时（caj，pdf，html），把文章题目粘贴为文件名（文件名不能有特殊符号）2.不同主题存入不同文件夹。文件夹的题目要简短，如：PD，LTP,PKC，NO。3.看过的文献归入子文件夹，最起码要把有用的和没用的分开。4.重要文献根据重要程度在文件名前加001，002，003编号，然后按名称排列图标，最重要的文献就排在最前了。而且重要文献要注意追踪。运气好，你可以得到更多的线索；运气不好，发现别人抢先了。据此修正你的实验。 34 | 35 | ## Take home message 36 | 合上论文的时候，要思考一下Take home message是什么？ 37 | 如果不清楚，去abstract，conclusion里找 38 | 39 | # Others 40 | 1. 先把领域内的基础论文搞的明白（高引论文），其它论文主要看变化点，先把图表花处理。 41 | 42 | ## 关于论文复现 43 | 1. 先找别人的代码，在它的数据集上复现，如果能复现出论文上的效果； 44 | 2. 在自己的论文数据集上进行复现； 45 | 3. 以上步骤如果出现问题解决不了，问朋友，甚至发email联系作者。 46 | 47 | ## Reference： 48 | 49 | https://www.zhihu.com/question/19962502 50 | -------------------------------------------------------------------------------- /alg_base/kmeans.md: -------------------------------------------------------------------------------- 1 | # k-means算法 2 | ## 问题定义 3 | Input：点集合set D，度量点之间距离的函数d，聚类后划分为k个set 4 | Output：k个set 5 | 6 | ``` 7 | def k-means(D, d, k): 8 | # do something 9 | ``` 10 | 11 | 其实是一个最优化目标函数问题，目标函数是： 12 | 13 | ``` 14 | # xi是D中的一个点 15 | # c是xi属于的类的中间点 16 | # d是度量点与点之间距离的函数 17 | minimize(sum( min（ d(xi, c) ） )) 18 | 19 | ``` 20 | 21 | 当k=1时，目标函数最优解在全部点的平均值。 22 | 23 | ## Lloyd's methold algorithm解决k-means问题 24 | 核心思想： 25 | 1. 找到点所属的类（计算点与各个中心点之间距离，找到距离最小的中心点，归类）； 26 | 2. 计算各个类的中心点（一个类中的点求平均）； 27 | 3. 重复步骤1和步骤2直到中心点不再更新。 28 | 29 | #### 为什么Lloyd's methold（面试）？ 30 | 目标函数有下界0，而且每一次迭代，目标函数都会减少。 31 | 32 | 因为单调递减有下界的函数一定是收敛的。 33 | 34 | ### 初始化 35 | * random center of datapoint 36 | 37 | * further travel最远遍历 38 | 39 | * k-means++work well and provable guarantees.在工业上实际应用，K-means++本质上与k-means没有区别，只是在初始化阶段有独到的方法。 40 | 41 | ### random center of datapoint 运行过程 42 | 43 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/5.png) 44 | 45 | 46 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/6.png) 47 | 48 | 49 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/7.png) 50 | 51 | 52 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/8.png) 53 | 54 | 55 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/9.png) 56 | 57 | 最后算法收敛成，如下所示： 58 | 59 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/10.png) 60 | 61 | #### random initialization bad performance 62 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/11.png) 63 | 64 | 65 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/12.png) 66 | 67 | 发生bad performance 的概率（k个初始化中心点正好分在k个高斯分布中的概率） 68 | 69 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/13.png) 70 | 71 | 72 | 所以当k大一点的时候，random initialization是不行的。 73 | 74 | 75 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/14.png) 76 | 77 | 但是问题就是对抗噪声的能力差，如下图所示： 78 | 79 | 80 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clustering/15.png) 81 | 82 | ### further travel最远遍历 83 | 初始化时使初始化中心尽可能的远。 84 | 85 | 1. 随机选取中心点c1，然后在剩下的点选取离c1最远的点c2； 86 | 2. 再选离c1和c2最远的点； 87 | 3. 依次类推直到选出k个点。 88 | 89 | 但是further travel最远遍历初始化方法，对抗噪声能力较差。 90 | 91 | ### k-means++初始化 92 | 93 | 1. 随机选择中心点c1； 94 | 2. 计算各个点离c1的距离； 95 | 3. 归一化，计算出每个点被选择做c2的概率 96 | 4. 安装计算出的概率，选出c2 97 | 5. 依次类推直到选出k个点。 98 | 99 | 在这个过程中有个概念d，d是点距离已经选择出的中心点的距离之和。 100 | 101 | 在实际中常根据d的α次方计算： 102 | * α=0，随机初始化中心点； 103 | * α=正无穷，最远初始化中心点； 104 | * α=2，k-means++初始化； 105 | 106 | 107 | ## 时间复杂度 108 | 109 | k-means++初始化时间复杂度是O(nkd)。n个点，k个类别，d表示点的维度。 110 | 因为每初始化一个点需要计算n各点到中心点的距离，所以复杂度是O(nd),循环k次所以是O(nkd)。 111 | 112 | 113 | k-means的时间复杂度是：k-means每一轮循环的时间复杂度是O(nkd)。 114 | 115 | 因此k-means++初始化时间复杂度相对k-means不高。相当于多循环一次而已。 116 | 117 | ## 怎么选择k 118 | 1. 交叉验证法； 119 | 2. elbow's method：k越大分类效果越好，计算不同的k的时候的损失函数收敛的速度来解决； 120 | -------------------------------------------------------------------------------- /alg_base/knn.md: -------------------------------------------------------------------------------- 1 | # K-近邻算法（KNN）概述 2 | KNN是通过测量不同特征值之间的距离进行分类。它的的思路是：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。K通常是不大于20的整数。KNN算法中，所选择的邻居都是已经正确分类的对象。该方法在定类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。 3 | 4 | 下面通过一个简单的例子说明一下：如下图，绿色圆要被决定赋予哪个类，是红色三角形还是蓝色四方形？如果K=3，由于红色三角形所占比例为2/3，绿色圆将被赋予红色三角形那个类，如果K=5，由于蓝色四方形比例为3/5，因此绿色圆被赋予蓝色四方形类。 5 | 6 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/041623504236939.jpg) 7 | 8 | > [](http://www.cnblogs.com/ybjourney/p/4702562.html) 9 | -------------------------------------------------------------------------------- /alg_base/latent_factor_model.md: -------------------------------------------------------------------------------- 1 | # 隐语义模型(latent factor model，LFM) 2 | 3 | ## 基本思想 4 | 还有一种方法，可以对书和物品的兴趣进行分类。对于某个用户，首先得到他的兴趣分类， 5 | 然后从分类中挑选他可能喜欢的物品。 总结一下，这个基于兴趣分类的方法大概需要解决3个问题。 6 | 7 | 1. 如何给物品进行分类? 8 | 2. 如何确定用户对哪些类的物品感兴趣，以及感兴趣的程度? 9 | 3. 对于一个给定的类，选择哪些属于这个类的物品推荐给用户，以及如何确定这些物品在 10 | 一个类中的权重? 11 | 12 | ## 问题1 13 | 如果两个物品被很多用户同时喜欢，那么这两个物品就很有可能属于同一个类。 14 | 15 | LFM通过如下公式计算用户u对物品i的兴趣: 16 | 17 | ``` 18 | import numpy as np 19 | # puk度量用户u的兴趣和第k个隐类的关系 20 | pu = np.mat(...) 21 | # qik度量第k个隐类和物品i之间的关系 22 | qi = np.mat(...) 23 | # 用户u对物品i的兴趣 24 | rui = pu.T().dot(qi) 25 | 26 | 27 | ``` 28 | 29 | ## 损失函数 30 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/20170827-153201.png) 31 | 32 | ## 随机梯度下降求解puk和qik向量 33 | -------------------------------------------------------------------------------- /alg_base/learning_carve.md: -------------------------------------------------------------------------------- 1 | # 学习曲线（Learning curve） 2 | 3 | 学习曲线是验证模型状态的工具。Learning curve可以帮我们判定我们的模型现在所处的状态。 4 | 5 | 我们以样本数为横坐标，训练和交叉验证集上的错误率作为纵坐标，两种状态分别如下两张图所示： 6 | * 过拟合(overfitting/high variace) 7 | * 欠拟合(underfitting/high bias) 8 | 9 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170719-001228.png) 10 | 11 | 12 | ## 应用中例子： 13 | [一个CNN调参的例子](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/practice/tuning_e1.md) 14 | 15 | [做特征工程的例子](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/practice/code/feature_engineering/feature_engineering.ipynb) 16 | -------------------------------------------------------------------------------- /alg_base/linear_regression_model.md: -------------------------------------------------------------------------------- 1 | # 线性回归（Linear regression model） 2 | 3 | ## 模型描述 4 | 线性模型通过线性组合来预测函数的值。 5 | 6 | ![](http://images.cnitblog.com/blog2015/633472/201503/262037556613399.jpg) 7 | 8 | 现在我们需要根据给定的X求解W的值,假设有训练数据： 9 | 10 | ![](http://images.cnitblog.com/blog2015/633472/201503/262041198028564.jpg) 11 | 12 | 写成： 13 | 14 | ![](http://images.cnitblog.com/blog2015/633472/201503/262042295678545.jpg) 15 | 16 | ## 损失函数 17 | 线性模型的损失函数采样范数是L2的损失函数。 18 | 19 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170511184436.png) 20 | 21 | ## 求解方法 22 | 23 | ### 最小二乘法 24 | 基于均方误差最小化来进行模型求解的方法叫“最小二乘法”，在线性回归中，最小二乘法就是试图找到一条直线，使所有样本到直线上的欧式距离之和最小。 25 | 26 | 是一个凸函数，想下y=x^2是凸函数。对其关于w和x求偏导，得到： 27 | 28 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170511184601.png) 29 | 30 | 令等式等于0，求得： 31 | 32 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170511185148.png) 33 | 34 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170511185242.png) 35 | 36 | 更一般的情况：损失函数： 37 | 38 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/262045294426265.jpg) 39 | 40 | 在矩阵满秩的时候，有解： 41 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/201503/262057197703308.jpg) 42 | 43 | 44 | 然并卵，在实际中，往往是矩阵不满秩（条件向量多于数据条数，如金融数据），矩阵求逆矩阵的计算量也是很大的，所以工业上常用一些最优化算法如梯度下降算法。 45 | 46 | ### 梯度下降法 47 | 假设给定数据集： 48 | 49 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/262115482708161.jpg) 50 | 51 | 对损失函数求偏导如下： 52 | 53 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/image_thumb_12.png) 54 | 55 | 下面是更新的过程，也就是θi会向着梯度最小的方向进行减少。θi表示更新之前的值，后面的部分表示按梯度方向减少的量，α表示步长，也就是每次按照梯度减少的方向变化多少。 56 | 57 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/image_thumb_14.png) 58 | 59 | 关于梯度下降更多细节请参考。[点击查看](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/alg_base/gradient_descent.md) 60 | 61 | ## 代码实例 62 | 查看手撸的代码，加深理解。[Linear regression model](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/practice/linear-regression-practice.md) 63 | -------------------------------------------------------------------------------- /alg_base/logisticRegression.md: -------------------------------------------------------------------------------- 1 | # 逻辑回归（logistic Regression） 2 | 3 | ## 基本概念 4 | 线性模型在解决分类问题的时候健壮性很差，现实中很多时候样本集中包含脏数据，例如电商数据中的刷单行为等。当噪声来的时候，模型很容易走偏。 5 | 6 | 在分类问题中希望有一个函数能输出分类，可以在线性回归模型外加入一个压缩函数，逻辑回归（logistics model）就是加入了sigmoid函数作为压缩函数的广义线性模型。 7 | 8 | ## Sigmoid压缩函数 9 | Sigmoid函数图例： 10 | 11 | ![](https://gss3.bdstatic.com/-Po3dSag_xI4khGkpoWK1HF6hhy/baike/w%3D268%3Bg%3D0/sign=ba0ac7a864061d957d46303e43cf6dec/d009b3de9c82d158dfb4e7218a0a19d8bc3e426f.jpg) 12 | 13 | 14 | Sigmoid函数由下列公式定义: 15 | 16 | ![](https://gss3.bdstatic.com/-Po3dSag_xI4khGkpoWK1HF6hhy/baike/s%3D99/sign=a46bd6f1dd33c895a27e9472d01340df/0df3d7ca7bcb0a4659502a5f6f63f6246b60af62.jpg) 17 | 18 | 其对x的导数可以用自身表示: 19 | ![](https://gss1.bdstatic.com/-vo3dSag_xI4khGkpoWK1HF6hhy/baike/s%3D236/sign=375012cedfca7bcb797bc02c88086b3f/64380cd7912397dde41ab3095182b2b7d0a2875f.jpg) 20 | 21 | Sigmoid函数是对概率p做拟合，是0和1之间的一个值（不包括0和1），当x取0的时候，y取0.5。 22 | 23 | 24 | ## 决策边界（decision boundary） 25 | 26 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/201704313.png) 27 | 28 | ## 损失函数 29 | 逻辑回归L2损失不是凸函数。 30 | 31 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/201704314.jpg) 32 | 33 | 逻辑回归损失函数： 34 | 35 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/QQ20170817-172826.png) 36 | 37 | 当y=1时，假定这个样本为正类。如果此时hθ(x)=1,则单对这个样本而言的cost=0,表示这个样本的预测完全准确。那如果所有样本都预测准确，总的cost=0 38 | 39 | 但是如果此时预测的概率hθ(x)=0，那么cost→∞。直观解释的话，由于此时样本为一个正样本，但是预测的结果P(y=1|x;θ)=0, 也就是说预测 y=1的概率为0，那么此时就要对损失函数加一个很大的惩罚项。 40 | 41 | 当y=0时，推理过程跟上述完全一致，不再累赘。 42 | 43 | 将以上两个表达式合并为一个，则单个样本的损失函数可以描述为: 44 | 45 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/20170601182340.jpg) 46 | 47 | ## 损失函数最优化 48 | 一般用gradient descent，如果需要分布式可以考虑L-BFGS 49 | 50 | ## 代码实例 51 | [点击链接进入逻辑回归代码实战](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/practice/code/logisitic_regression_practice/logistic_regression_example.ipynb) 52 | -------------------------------------------------------------------------------- /alg_base/loss_function.md: -------------------------------------------------------------------------------- 1 | # 损失函数 loss function 2 | 3 | ### 基本概念 4 | 学习算法的目标是找到最好的参数，然而怎么衡量这个最好的问题？答案是**损失函数（loss function)**。 5 | 6 | 数据标签（label）与预测结果（predict）之间差距叫做损失，衡量损失的函数叫做损失函数。 7 | 8 | 在有监督学习（supervised learning）中，不同模型根据各自不同的目标，都会定义有各自的损失函数，例如： 9 | * 线性回归（linear regression）中的平方损失函数； 10 | * 逻辑回归（logistic regression）中的log损失函数； 11 | * svm算法中定义的hinge损失函数； 12 | 13 | *有很多paper就是对损失函数做优化。* 14 | 15 | # 常见的损失函数 16 | 17 | 机器学习或者统计机器学习常见的损失函数如下： 18 | 19 | 1.0-1损失函数 （0-1 loss function） 20 | 21 | L(Y,f(X))={1,Y ≠ f(X) 22 | 0,Y = f(X) 23 | 24 | 2.平方损失函数（quadratic loss function) 25 | 26 | L(Y,f(X))=(Y−f(x))2 27 | 28 | 3.绝对值损失函数(absolute loss function) 29 | 30 | L(Y,f(x))=|Y−f(X)| 31 | 32 | 4.对数损失函数（logarithmic loss function) 或对数似然损失函数(log-likehood loss function) 33 | 34 | L(Y,P(Y|X))=−logP(Y|X) 35 | 逻辑回归中，采用的则是对数损失函数。如果损失函数越小，表示模型越好。 36 | 37 | ### eg. 38 | 在线性回归中，model定义： 39 | 40 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170521165243.png) 41 | 42 | 在线性回归model中，损失函数是取predict value与label value的方差，定义如下： 43 | 44 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170521165348.png) 45 | 46 | 在参数是一元的情况下： 47 | 48 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170521171921.png) 49 | 50 | 在多元的情况下： 51 | 52 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170521171944.png) 53 | 54 | 平方loss在linear regression的情况下是一个凸函数，这意味着存在全局最优点，并且可能通过某些方法找到全局最优点。在deep learning中没有办法确保找到全局最优点，在工业上找到一个几乎是全局最优点的点，在工业上可以用就行了。 55 | 56 | ### 线性回归与梯度下降GD 57 | 梯度下降算法的细节在： 58 | 59 | [点此链接跳转到线性回归与梯度下降GD](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/alg_base/ch1/gradient_descent.md) 60 | 61 | 除了梯度下降算法外，还有牛顿法，拟牛顿法等等优化算法。 62 | -------------------------------------------------------------------------------- /alg_base/lstm.md: -------------------------------------------------------------------------------- 1 | # lstm 2 | 有一篇非常好的讲lstm的blog： 3 | 4 | * [Understanding LSTM Networks by colah翻译版](https://blog.csdn.net/Jerr__y/article/details/58598296) 5 | 6 | * [Understanding LSTM Networks by colah原版](http://colah.github.io/posts/2015-08-Understanding-LSTMs/) 7 | 8 | 9 | -------------------------------------------------------------------------------- /alg_base/lstm_param.md: -------------------------------------------------------------------------------- 1 | # LSTM参数个数计算 2 | 个人认为明白如何计算一个网络的参数个数，对于理解一个网络的流程特别重要。 3 | 4 | [参考链接](https://zhuanlan.zhihu.com/p/39262960) 5 | 6 | 7 | [这个链接里面直接有公式](https://www.cnblogs.com/wdmx/p/9284037.html) 8 | 9 | 首先声明： 10 | 11 | 参数个数与steps无关 12 | 13 | h_t 的维度与 c_t 相同 14 | 15 | 两个门来控制状态 ，一个门来控制状态 对输出的影响。 16 | 17 | 有四个交互的层，也就是拥有四组【w,b】参数；所以 总参数个数= (w的元素个数 + b的元素个数)*4 总参数个数的元素个数的元素个数 18 | 19 | 向量经过激活函数后，仍是一个向量：对向量中的每一个元素分别操作 20 | 21 | 22 | 重点：计算出 w,b 的维度，就计算出参数个数了 23 | 24 | ![](https://pic4.zhimg.com/80/v2-558af6af92912390c3f1371b9ac0469f_hd.jpg) 25 | 26 | 从上图中可以看出，每个交互的层的操作大致是一样的，主要都是： 27 | 28 | > w * []+b 29 | 30 | 然后再经过激活函数，之后再与状态 c 作用，与参数有关的就是 w*[]+b 。 31 | 32 | 33 | 34 | 因为输入输出向量的维度都是我们提前规定好的，假设维度是： 35 | 36 | > x:2024 * 1,h维度=c维度=50 * 1 37 | 38 | 39 | 40 | 所以，根据公式：已知 41 | 42 | 43 | 44 | > W*[h;x] + b= 输出维度 45 | 46 | > W*[(2024+50)*1] + 50 * 1 = 50 * 1 47 | 48 | > W [50*2074] 49 | 50 | 所以，可以根据维度倒推出维度： 51 | 52 | 53 | 54 | > w: 50*2074， b:50*1 55 | 56 | 57 | 58 | 四组【w,b】,所以总参数： 59 | 60 | > 4*（50*2074+50）= 415000 61 | -------------------------------------------------------------------------------- /alg_base/model_ensemble.md: -------------------------------------------------------------------------------- 1 | # 模型融合 2 | ## 模型融合（model ensemble）是什么 3 | Ensemble Learnig 是一组individual learner的组合： 4 | * 如果individual learner同质，称为base learner 5 | * 如果individual learner异质，称为component learner 6 | ## 集成学习分类 7 | 根据个体学习器间存在的关系，目前集成学习大致可以分为两大类： 8 | * 个体学习器存在强依赖关系，必须串行生成的序列化方法(Boosting)； 9 | * 个体学习器不存在强依赖关系，可以并行生成（Bagging、Random Forest）； 10 | ## 模型融合为什么能有效果 11 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170719-003836.png) 12 | ## 模型融合信奉几条信条 13 | 简单说来，我们信奉几条信条: 14 | 1. 群众的力量是伟大的，集体智慧是惊人的，包括：Bagging和随机森林（Random forest) 15 | 2. 站在巨人的肩膀上，能看得更远:模型stacking 16 | 3. 一万小时定律:Adaboost和逐步增强树（Gradient Boosting Tree） 17 | ### Bagging 18 | 过拟合了，bagging一下。 19 | 20 | 用一个算法: 21 | * 不用全部的数据集，每次取一个子集训练一个模型 22 | * 分类：用这些模型的结果做vote 23 | * 回归：对这些模型的结果取平均 24 | 25 | 用不同的算法: 26 | * 用这些模型的结果做vote 或 求平均 27 | ### stacking 28 | 用多种predictor结果作为特征训练 29 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170719-004725.png) 30 | ### boosting 31 | [adaboost参考博文，点我跳转。](http://blog.csdn.net/google19890102/article/details/46376603) 32 | [gdbt参考博文，点我跳转。](https://www.cnblogs.com/ModifyRong/p/7744987.html) 33 | -------------------------------------------------------------------------------- /alg_base/nb/1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/alg_base/nb/1.jpg -------------------------------------------------------------------------------- /alg_base/nb/2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/alg_base/nb/2.jpg -------------------------------------------------------------------------------- /alg_base/nb/3.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/alg_base/nb/3.jpg -------------------------------------------------------------------------------- /alg_base/nb/4.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/alg_base/nb/4.jpg -------------------------------------------------------------------------------- /alg_base/nb/5.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/alg_base/nb/5.jpg -------------------------------------------------------------------------------- /alg_base/nb/gram_model.md: -------------------------------------------------------------------------------- 1 |
2 | 3 |
4 | 5 |
6 | 7 |
8 | 9 |
10 | 11 | ## 1\. 引言：朴素贝叶斯的局限性[¶](#1.-引言：朴素贝叶斯的局限性) 12 | 13 | 我们知道朴素贝叶斯的局限性来源于其条件独立假设，它将文本看成是词袋子模型，不考虑词语之间的顺序信息，就会把“武松打死了老虎”与“老虎打死了武松”认作是一个意思。那么有没有一种方法提高其对词语顺序的识别能力呢？有，就是这里要提到的N-gram语言模型。 14 | 15 | ## 2\. N-gram语言模型是啥？[¶](#2.-N-gram语言模型是啥？) 16 | 17 | ### 2.1从假设性独立到联合概率链规则[¶](#2.1从假设性独立到联合概率链规则) 18 | 19 | 照抄我们垃圾邮件识别中的条件独立假设，长这个样子： 20 | 21 | > $P(（“我”,“司”,“可”,“办理”,“正规发票”,“保真”,“增值税”,“发票”,“点数”,“优惠”)|S)$ $=P(“我”|S)×P(“司”|S)×P(“可”|S)×P(“办理”|S)×P(“正规发票”|S)$ $×P(“保真”|S)×P(“增值税”|S)×P(“发票”|S)×P(“点数”|S)×P(“优惠”|S)$ 22 | 23 | 为了简化起见，我们以字母$x_i$表示每一个词语，并且先不考虑条件“S”。于是上式就变成了下面的独立性公式。 24 | 25 | > $P(x_1,x_2,x_3,x_4,x_5,x_6,x_7,x_8,x_9,x_{10})$ $=P(x_1)P(x_2)P(x_3)P(x_4)P(x_5)P(x_6)P(x_7)P(x_8)P(x_9)P(x_{10})$ $=P(“我”)P(“司”)P(“可”)P(“办理”)...P(“优惠”)$ 26 | 27 | 上面的公式要求满足独立性假设，如果去掉独立性假设，我们应该有下面这个**恒等式，即联合概率链规则(chain rule)** ： 28 | 29 | > $P(x_1,x_2,x_3,x_4,x_5,…,x_n)$ $=P(x_1)P(x_2|x_1)P(x_3|x_1,x_2)...P(x_n|x_1,x_2,...,x_{n-1})$ 30 | 31 | ### 2.2 从联合概率链规则到n-gram语言模型[¶](#2.2-从联合概率链规则到n-gram语言模型) 32 | 33 | 上面的联合概率链规则公式考虑到词和词之间的依赖关系，但是比较复杂，在实际生活中几乎没办法使用，于是我们就想了很多办法去近似这个公式，比如我们要讲到的语言模型n-gram就是它的一个简化。 34 | 35 | 如果我们考虑一个词语对上一个词语的依赖关系，公式就简化了如下形式，我们把它叫做二元语法（bigram，2-gram）: 36 | 37 | > $P(x_1,x_2,x_3,x_4,x_5,x_6,x_7,x_8,x_9,x_{10})$ $=P(x_1)P(x_2|x_1)P(x_3|x_2)P(x_4|x_3)..P(x_{10}|x_9)$ $=P(“我”)P(“司”|“我”)P(“可”|“司”)P(“办理”|“可”)...P(“优惠”|“点数”)$ 38 | 39 | 如果把依赖词长度再拉长一点，考虑一个词对前两个词的依赖关系，就叫做三元语法（trigram，3-gram），公式如下: 40 | 41 | > $P(x_1,x_2,x_3,x_4,x_5,x_6,x_7,x_8,x_9,x_{10})$ $=P(x_1)P(x_2|x_1)P(x_3|x_1,x_2)P(x_4|x_2,x_3)×...×P(x_{10}|x_8,x_9)$ $=P(“我”)P(“司”|“我”)P(“可”|“我”,“司”)P(“办理”|“司”,“可”)...P(“优惠”|“发票”,“点数”)$ 42 | 43 | 如果我们再考虑长一点，考虑n个词语之间的关系，恩恩，这就是n-gram的由来。歪果仁果然取名字简单粗暴又好记… 44 | 45 | 其实以上几个简化后的公式，就是著名的**马尔科夫假设（Markov Assumption）：下一个词的出现仅依赖于它前面的一个或几个词**。这相对于联合概率链规则，其实是一个有点粗糙的简化，不过很好地体现了就近思路，离得较远和关系比较弱的词语就被简化和省略了。实际应用中，这些简化后的n-gram语法比独立性假设还是强很多的。 46 | 47 | ### 2.3 怎样选择依赖词的个数"n"？[¶](#2.3-怎样选择依赖词的个数"n"？) 48 | 49 | 选择依赖词的个数"n"主要与计算条件概率有关。**理论上，只要有足够大的语料，n越大越好，毕竟这样考虑的信息更多嘛**。条件概率很好算，统计一下各个元组出现的次数就可以，比如: 50 | 51 | > $P(“优惠”|“发票”,“点数”)=\frac{(“发票”,“点数”，“优惠”)出现的次数}{(“发票”,“点数”)出现的次数}$ 52 | 53 | 但我们实际情况往往是**训练语料很有限，很容易产生数据稀疏**，不满足大数定律，算出来的概率失真。比如(“发票”,“点数”，“优惠”)在训练集中竟没有出现，就会导致零概率问题。 54 | 55 | 又比如在英文语料库IBM, Brown中，三四百兆的语料，其测试语料14.7%的trigram和2.2%的bigram在训练语料中竟未出现！ 56 | 57 | 另一方面，如果n很大，**参数空间过大，也无法实用**。假设词表的大小为$100,000$，那么n-gram模型的参数数量为$100,000^n$。这么多的参数，估计内存就不够放了。 58 | 59 | 那么，如何选择依赖词的个数n呢？从前人的经验来看： 60 | 61 | * 经验上，trigram用的最多。尽管如此，原则上，能用bigram解决，绝不使用trigram。n取≥4的情况较少。 62 | * 更大的n：对下一个词出现的约束信息更多，具有更大的**辨别力**； 63 | * 更小的n：在训练语料库中出现的次数更多，具有更可靠的统计信息，具有更高的**可靠性、实用性**。 64 | 65 | ## 3\. N-gram实际应用举例[¶](#3.-N-gram实际应用举例) 66 | 67 | 说了这么N-gram语言模型的背景知识，咱们再来看看N-gram语言模型在自然语言处理中有哪些常见应用。 PS：此部分以原理介绍为多，具体的技术实现细节请参考文中链接或者google。 68 | 69 | ### 3.1 词性标注[¶](#3.1-词性标注) 70 | 71 | **词性标注是一个典型的多分类问题**。常见的词性包括名词、动词、形容词、副词等。而一个词可能属于多种词性。如“爱”，可能是动词，可能是形容词，也可能是名词。但是一般来说，“爱”作为动词还是比较常见的。所以统一给“爱”分配为动词准确率也还足够高。这种最简单粗暴的思想非常好实现，如果准确率要求不高则也比较常用。**它只需要基于词性标注语料库做一个统计就够了，连贝叶斯方法、最大似然法都不要用**。词性标注语料库一般是由专业人员搜集好了的，长下面这个样子。其中斜线后面的字母表示一种词性，词性越多说明语料库分得越细： 72 | 73 | ![图](http://7xnkcs.com1.z0.glb.clouddn.com/longxinchen_02032971-d9dab327d7f9ff69.jpg) 74 | 75 | 需要比较以下各概率的大小，选择概率最大的词性即可： 76 | 77 | > $P(词性_i|“爱")=\frac{“爱"作为“词性_i”的次数}{“爱"出现的次数} ； i=1,2,3...$ 78 | 79 | **但这种方法没有考虑上下文的信息。而一般来说，形容词后面接名词居多，而不接动词，副词后面才接动词，而不接名词。** 考虑到词性会受前面一两个词的词性的影响，**可以引入2-gram模型提升匹配的精确度。** 我们匹配以下这句话（已被空格分好词）中“爱”的词性： 80 | 81 | > "闷骚的 李雷 很 爱 韩梅梅" 82 | 83 | 将公式进行以下改造，比较各概率的大小，选择概率最大的词性： 84 | 85 | > $P(词性_i|“很”的词性（副词），“爱")=\frac{前面被“副词”修饰的“爱"作为“词性_i”的次数}{前面被“副词”修饰的“爱"出现的次数} ； i=1,2,3...$ 86 | 87 | 计算这个概率需要对语料库进行统计。但前提是你得先判断好“很”的词性，因为采用2-gram模型，进而就需要提前判断“李雷”的词性，需要判断“闷骚的”词性。但是“闷骚的”作为第一个词语，已经找不比它更靠前的词语了。这时就可以考虑用之前最简单粗暴的方法判断“闷骚的”的词性，统一判断为形容词即可。 88 | 89 | PS:词性标注是自然语言处理中的一项基础性工作，有其细节实现远比我们介绍地更加丰富。感兴趣的同学可以看看这篇文章[《NLTK读书笔记 — 分类与标注》](https://superangevil.wordpress.com/2009/10/20/nltk5/) 90 | 91 | ### 3.2 垃圾邮件识别[¶](#3.2-垃圾邮件识别) 92 | 93 | 是的，亲，你！没！看！错！可以用N-gram进行垃圾邮件识别，而且是朴素贝叶斯方法的进化版。**下面我们用直观的例子探讨一下其在分类问题上是怎么发挥作用的**。一个可行的思路如下： 94 | 95 | * 先对邮件文本进行断句，以句尾标点符号（“。” “!” “？”等）为分隔符将邮件内容拆分成不同的句子。 96 | * 用N-gram分类器(马上提到)判断每个句子是否为垃圾邮件中的敏感句子。 97 | * 当被判断为敏感句子的数量超过一定数量（比如3个）的时候，认为整个邮件就是垃圾邮件。 98 | 99 | 咳咳，有同学问N-gram分类器是什么鬼，这个分类器靠谱么。N-gram分类器是结合贝叶斯方法和语言模型的分类器。这里用$Y_1,Y_2$分别表示这垃圾邮件和正常邮件，用$X$表示被判断的邮件的句子。根据贝叶斯公式有： 100 | 101 | > $P(Y_i|X)\propto P(X|Y_i)P(Y_i) ； i=1,2$ 102 | 103 | 比较i=1和2时两个概率值的大小即可得到$X$所属的分类。对于句子（“我”,“司”,“可”,“办理”,“正规发票”,“保真”,“增值税”,“发票”,“点数”,“优惠”)用字母$X$代表，每一个词语用字母$x_i$表示。$X$就可以写成一个$x_i$组成的向量，$x_i$就是这向量中某个维度的特征。**对$P(X|Y_i)$ 套用2-gram模型。** 则上式化简为： 104 | 105 | > $P(Y_i|X)\propto P(X|Y_i)P(Y_i) ； i=1,2$ $\propto P(x_1|Y_i)P(x_2|x_1，Y_i)P(x_3|x_2，Y_i)...P(x_{10}|x_9，Y_i)P(Y_i)$ $\propto P(“我”|Y_i)P(“司”|“我”，Y_i)P(“可”|“司”，Y_i)...P(“优惠”|“点数”，Y_i)P(Y_i)$ 106 | 107 | 公式中的条件概率也比较好求，举个例子： 108 | 109 | > $P(“优惠”|“点数”，Y_i)=\frac{在类别Y_i中，(“点数”，“优惠”)出现的次数}{在类别Y_i中，“点数”出现的次数}$ 110 | 111 | 剩下的就需要在语料库中间做一个的统计就是了。**因为这种方法考虑到了词语前面的一个词语的信息，同时也考虑到了部分语序信息，因此区分效果会比单纯用朴素贝叶斯方法更好。** 112 | 113 | 多提几句，N-gram方法在实际应用中有一些tricks需要注意： 114 | 115 | * 3-gram方法的公式与上面类似。此处省略。从区分度来看，3-gram方法更好些。 116 | * 句子开头的词，比如本例中的“我”，**因为要考虑其本身作为开头的特征，可以考虑在其前面再添加一个句子起始符号如"《S》"，这样我们就不必单独计算$P("我"|Y_i)$，而是替换为计算$P("我"|"《S》",Y_i)$。形式上与2-gram统一。** 这样统计和预测起来都比较方便。 117 | * 一般地，**如果采用N-gram模型，可以在文本开头加入n-1个虚拟的开始符号**，这样在所有情况下预测下一个词的可依赖词数都是一致的。 118 | * 与朴素贝叶斯方法一样，**N-gram模型也会发生零概率问题，也需要平滑技术。** ，别着急，下面马上讨论到。 119 | 120 | ### 3.3 中文分词[¶](#3.3-中文分词) 121 | 122 | 之前说过，中文分词技术是“中文NLP中，最最最重要的技术之一”，重要到某搜索引擎厂有专门的team在集中精力优化这一项工作，重要到能影响双语翻译10%的准确度，能影响某些query下搜索引擎几分之一的广告收入。不过简单的分词实现方式中，包含的原理其实也非常易懂。 123 | 124 | 说起来，**中文分词也可以理解成一个多分类的问题。** 这里用$X$表示被分词的句子“我司可办理正规发票”， **用$Y_i$表示该句子的一个分词方案。**，咱们继续套用贝叶斯公式： 125 | 126 | > $P(Y_i|X)\propto P(X|Y_i)P(Y_i) ； i=1,2,3...$ 127 | 128 | 比较这些概率的大小，找出使得$P(Y_i|X)$ 最大的$Y_i$即可得到$X$ 所属的分类(分词方案)了。 129 | 130 | $Y_i$作为分词方案，其实就是个词串，比如（“我司”，“可”，“办理”，“正规发票”）或者（“我”，“司可办”，“理正规”，“发票”），也**就是一个向量**了。 131 | 132 | 而上面贝叶斯公式中$P(X|Y_i)$ 项的意思就是在分类方案 $Y_i$ 的前提下，其对应句子为$X$ 的概率。而无论分词方案是（“我司”，“可”，“办理”，“正规发票”）还是（“我”，“司可办”，“理正规”，“发票”），或者其他什么方案，其对应的句子都是“我司可办理正规发票”。也就是说**任意假想的一种分词方式之下生成的句子总是唯一的**（只需把分词之间的分界符号扔掉剩下的内容都一样）。于是**可以将 $P(X|Y_i)$ 看作是恒等于1**的。这样贝叶斯公式又进一步化简成为： 133 | 134 | > $P(Y_i|X)\propto P(Y_i) ； i=1,2,3...$ 135 | 136 | 也就是说我们只要取最大化的$P(Y_i)$ 就成了。而$Y_i$就是一个词串，也就是一个向量，可以直接套用我们上面的N-gram语言模型。这里采用2-gram。于是有： 137 | 138 | > $P(Y_1)=P(“我司”，“可”，“办理”，“正规发票”)$ $=P(“我司”)P(“可”|“我司”)P(“办理”|“可”)P(“正规发票”|“办理”）$ 139 | 140 | 第二种分词方案的概率为： 141 | 142 | > $P(Y_2)=P(“我”，“司可办”，“理正规”，“发票”)$ $=P(“我”)P(“司可办”|“我”)P(“理正规”|“司可办”)P(“发票”|“理正规”）$ 143 | 144 | 由于在语料库中“司可办”与“理正规”一起连续出现的概率为0，于是$P(Y_2)=0$ ,$P(Y_1)$ 的概率更高，优先选择$Y_1$的分词方案。 145 | 146 | ### 3.4机器翻译与语音识别[¶](#3.4机器翻译与语音识别) 147 | 148 | 除了上述说到的应用，N-gram语言模型在机器翻译和语音识别等顶级NLP应用中也有很大的用途。 当然，机器翻译和语音识别是非常复杂的过程，N-gram语言模型只是其中的一部分，但是缺少它整个过程却进行不下去。对于这两个应用我们不打算罗列大量的公式，而只是举些例子，让大家了解一下语言模型是怎么发挥作用的。 对于机器翻译而言，比如中译英，我们对于同一句话『李雷出现在电视上』，得到的三个译文： 149 | 150 | * LiLei appeared in TV 151 | * In LiLei appeared TV 152 | * LiLei appeared on TV 153 | 154 | 其对应短语的翻译概率是一致的，从短语翻译的角度我们无法评定哪句才是正确的翻译结果。这时候，如果我们再使用语言模型(比如机器翻译里面最常见的是3-gram)，我们计算会得到最后一句话$P(“LiLei”|“《S》”,“《S》”)P(“appeared”|“LiLei”,“《S》”)P(“on”|“LiLei”,“appeared”)P(“TV”|“appeared”,“on”) $的概率高于第一句$P(“LiLei”|“《S》”,“《S》”)P(“appeared”|“LiLei”,“《S》”)P(“in”|“LiLei”,“appeared”)P(“TV”|“appeared”,“in”)$和第二句$P(“in”|“《S》”,“《S》”)P(“LiLei”|“in”,“《S》”)P(“appeared”|“LiLei”,“in”)P(“TV”|“appeared”,“appeared”)$，因此我们选择第三句作为正确的答案。这也表明大量语料上的语言模型能够在一定程度上，体现出我们表达某种语言时候的说话习惯。 155 | 156 | 对应到语音识别问题中，我们也会遇到相同的问题，对于以下的2个句子： 157 | 158 | * I went to a party 159 | * Eye went two a bar tea 160 | 161 | 或者对应下述2个句子： 162 | 163 | * 你现在在干什么？ 164 | * 你西安载感什么？ 165 | 166 | 其对应的发音是完全一致的，这时如果我们借助于语言模型，我们会发现$P(“I”|“《S》”,“《S》”)P(“went”|“I”,“《S》”)P(“to”|“I”,“went”)P(“a”|“went”,“to”)P(“party”|“to”,“a”)$的概率大于$P(“Eye”|“《S》”,“《S》”)P(“went”|“Eye”,“《S》”)P(“two”|“Eye”,“went”)P(“a”|“went”,“two”)P(“bar”|“two”,“a”)P(“tea”|“a”,“bar”)$，而$P(“你”|“《S》”,“《S》”)P(“现在”|“你”,“《S》”)P(“在”|“你”,“现在”)P(“干什么”|“在”,“现在”)$概率远大于 $P(“你”|“《S》”,“《S》”)P(“西安”|“你”,“《S》”)P(“载”|“西安”,“你”)P(“感”|“西安”,“载”)P(“什么”|“感”,“载”)$，因此我们会选择**I went to a party** 和 **你现在在干什么**作为正确的语音识别结果。 167 | 168 | 上面只是简单的举例，但是大家应该看出来了，在机器翻译和语音识别中，N-gram语言模型有着至关重要的地位。同样在现在最顶级的计算机视觉任务『图片内容表述』中，语言模型也发挥着至关重要的作用。语言模型的重要性可见一斑。 169 | 170 | ## 4\. 平滑技术[¶](#4.-平滑技术) 171 | 172 | 现在我们可以比较专门探讨平滑技术了。为了解决零概率问题呢，我们需要给 **“未出现的n-gram条件概率分布一个非零估计值，相应得需要降低已出现n-gram条件概率分布，且经数据平滑后一定保证概率和为1”**。这就是平滑技术的基本思想。 173 | 174 | ### 4.1 拉普拉斯平滑[¶](#4.1-拉普拉斯平滑) 175 | 176 | 这是最古老的一种平滑方法，又称加一平滑法，其**保证每个n-gram在训练语料中至少出现1次**。以计算概率$P(“优惠”|“发票”,“点数”)$ 为例，公式如下： 177 | 178 | > $P(“优惠”|“发票”,“点数”)=\frac{(“发票”,“点数”，“优惠”)出现的次数+1}{(“发票”,“点数”)出现的次数+所有不重复的三元组的个数}$ 179 | 180 | 在所有不重复的三元组的个数远大于(“发票”,“点数”)出现的次数时，即训练语料库中绝大部分n-gram都是未出现的情况（一般都是如此），**拉普拉斯平滑有“喧宾夺主”的现象，效果不佳。** 181 | 182 | ### 4.2 古德图灵(Good Turing)平滑[¶](#4.2-古德图灵(Good-Turing)平滑) 183 | 184 | 通过对语料库的统计，我们能够知道出现$r$次 $（r>0）$ 的n元组的个数为$N_r$。可以令从未出现的n元组的个数为$N_0$。古德图灵平滑的思想是: 185 | 186 | * **出现0次的n元组也不能认为其是0次，应该给它一个比较小的估计值**，比如为$d_0$次。 187 | * 为了保证总共的（出现和未出现的）n元组的次数不变，**其他所有已出现的n元组的次数r应该打一个折扣**，比如为$d_r$次。 188 | * 然后再**用新的$d_r$去计算各个条件概率。** 189 | 190 | 所以问题的关键是计算$d_r$。**为了保证平滑前后n元组的总共出现次数不变**，有： 191 | 192 | > $\sum_{r=0}^\infty d_r×N_r=\sum_{r=0}^\infty (r+1)×N_{r+1}$ 193 | 194 | 所以干脆令： 195 | 196 | > $d_r×N_r=(r+1)×N_{r+1}； r=0,1,2...$ 197 | 198 | 这样就可以求出$d_r$了。但是，当$N_r>N_{r+1}$ 时，使得模型质量变差，如下图所示： 199 | 200 | ![图](http://7xnkcs.com1.z0.glb.clouddn.com/longxinchen_0203gt.jpg) 201 | 202 | 直接的改进策略就是 **“对出现次数超过某个阈值的n元组，不进行平滑，阈值一般取8~10”**，其他方法请参见[“Simple Good-Turing”](http://faculty.cs.byu.edu/~ringger/CS479/papers/Gale-SimpleGoodTuring.pdf)。 203 | 204 | ### 4.3 组合估计平滑[¶](#4.3-组合估计平滑) 205 | 206 | **不管是拉普拉斯平滑，还是古德图灵平滑技术，对于未出现的n元组都一视同仁，而这难免存在不合理。** 因为哪怕是未发生的事件，相互之间真实的概率也会存在差别。 207 | 208 | 另一方面，一个n元组可能未出现，但是其(n-1)元组或者(n-2)元组是出现过的，这些信息如果不利用就直接浪费掉了。**在没有足够的数据对高元n-gram模型进行概率估计时，低元n-gram模型通常可以提供有用的信息。** 因此可以利用利用低元n-gram模型的信息对高元n-gram模型进行估计： 209 | 210 | * 如果低元n-gram模型的概率本来就很低，那么就给高元n-gram模型一个较低的估计值； 211 | * 如果低元n-gram模型有一个中等的概率，那么就给高元n-gram模型一个较高的估计值。 212 | 213 | 常用的组合估计算法有**线性差值法**和**Katz回退法**。具体公式比较复杂，这里就不列了。感兴趣的同学可参考 Christopher D. Manning 的[《统计自然语言处理基础》](http://book.douban.com/subject/1224802/) 214 | 215 | ## 5\. 从N-gram谈回贝叶斯方法[¶](#5.-从N-gram谈回贝叶斯方法) 216 | 217 | 聊了这么多N-gram语言模型，我们再回到贝叶斯方法，从实际应用中看看他们的关联。 最原始的用贝叶斯方法进行分类的公式其实非常简单： 218 | 219 | > $P(Y_i|X)\propto P(X|Y_i)P(Y_i) ； i=1,2,3...$ 220 | 221 | 具体到不同应用中，它就可以演化出多种玩法： 222 | 223 | * 对于**拼写纠错（非词错误）** ，$X$是错误的词语，$Y_i$是候选的改正词语，二者都是标量。 224 | * 对于**垃圾邮件识别**，$X$是邮件中的句子，$Y_i$是备选的邮件类别。$X$可以处理成向量，$Y_i$还是标量。 225 | * 如果对向量$X$采用条件独立假设，就是朴素贝叶斯方法。 226 | * 如果对向量$X$采用马尔科夫假设，就是N-gram语言模型。 227 | * 对于**中文分词**，$X$是被分词的句子，$Y_i$是备选的分词方案（词串）。这里把$X$看成是一个整体，所以可以理解成标量。而$Y_i$则是向量。这里对向量$Y_i$采用马尔科夫假设，也是N-gram语言模型。 228 | 229 | 那么有没有一种模型处理的$X$和$Y_i$都是向量呢？有的，这就是传说中的隐马尔科夫模型(HMM)。以后的课会讲到。 230 | 231 |
232 | 233 |
234 | 235 |
236 | 237 |
238 | 239 |
240 | -------------------------------------------------------------------------------- /alg_base/neural_network.md: -------------------------------------------------------------------------------- 1 | # 神经网络(neural network) 2 | 3 | ## 神经元模型 4 | 5 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170625005624.jpg) 6 | 7 | 把许多个这样的神经元按一定层次结构连接起来就得到了神经网络。 8 | 9 | 以计算机的角度来看，其实就是若干个函数嵌套相连而成。 10 | 11 | ## 感知机 12 | 13 | 感知机由两层网络组成，输入层和输出层。如下图所示： 14 | 15 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170625010537.jpg) 16 | 17 | 感知机只有输出层神经元进行激活函数处理，即只有一层功能神经元，只能处理线性可分问题。 18 | 19 | 线性可分：简单的说就是如果用一个线性函数可以将两类样本完全分开，就称这些样本是“线性可分”的。 更多内容参考： 20 | [](http://blog.csdn.net/u013300875/article/details/44081067) 21 | 22 | 对于线性不可分的问题，感知机不能够解决：例如下图所示的异或问题： 23 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170625011545.jpg) 24 | 25 | ## 多层神经元网络 26 | 27 | 未处理线性不可分问题，需要使用多层神经元。下图所示，输入层之间和输出层之间包含一层隐层神经元。 28 | 隐层神经元和输出层神经元都是含有激活函数的功能神经元。 29 | 30 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170625012454.jpg) 31 | 32 | 33 | 更一般的情况是，神经元之间不存在同层相连，也不存在跨层相连，这样的神经网络结构通常称为多层前馈神经网络： 34 | 35 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170625012522.jpg) 36 | 37 | 38 | 神经网络的学习过程，就是根据训练数据来调整神经元之间的“连接权”以及每个功能神经元的发指，换言之，神经网络学到的东西，蕴含在连接权与阈值之间。 39 | -------------------------------------------------------------------------------- /alg_base/nlp_opensource_dataset.md: -------------------------------------------------------------------------------- 1 | # 常见的几个对话机器人的数据集 2 | 3 | ``` 4 | UDC: Ubuntu Corpus V1; 5 | ATIS: 微软提供的公开数据集DSTC2，Airline Travel Information System; 6 | DSTC2: 对话状态跟踪挑战（Dialog State Tracking Challenge）2; 7 | MRDA: Meeting Recorder Dialogue Act; 8 | SWDA：Switchboard Dialogue Act Corpus; 9 | ``` 10 | -------------------------------------------------------------------------------- /alg_base/normalization.md: -------------------------------------------------------------------------------- 1 | # 归一化 2 | 在实际应用中，通过梯度下降法求解的模型一般都是需要归一化的，比如线性回归、logistic回归、KNN、SVM、神经网络等模型。 3 | 4 | 但树形模型不需要归一化，因为它们不关心变量的值，而是关心变量的分布和变量之间的条件概率，如决策树、随机森林(Random Forest)。 5 | 机器学习模型被互联网行业广泛应用，如排序（参见：排序学习实践http://www.cnblogs.com/LBSer/p/4439542.html）、推荐、反作弊、定位（参见：基于朴素贝叶斯的定位算法http://www.cnblogs.com/LBSer/p/4020370.html）等。 6 | 7 | 一般做机器学习应用的时候大部分时间是花费在特征处理上，其中很关键的一步就是对特征数据进行归一化。 8 | 9 | 为什么要归一化呢？很多同学并未搞清楚，维基百科给出的解释：1）归一化后加快了梯度下降求最优解的速度；2）归一化有可能提高精度。 10 | 11 | 下面再简单扩展解释下这两点。 12 | 13 | 1 归一化为什么能提高梯度下降法求解最优解的速度？ 14 | 15 | 如下两图所示（来源：斯坦福机器学习视频） 16 | 17 | ![](https://julyedu-img-public.oss-cn-beijing.aliyuncs.com/Public/Image/Question/1512811933_278.png) 18 | 19 | 蓝色的圈圈图代表的是两个特征的等高线。其中左图两个特征X1和X2的区间相差非常大，X1区间是[0,2000]，X2区间是[1,5]，像这种有的数据那么大，有的数据那么小，两类之间的幅度相差这么大，其所形成的等高线非常尖。当使用梯度下降法寻求最优解时，很有可能走“之字型”路线（垂直等高线走），从而导致需要迭代很多次才能收敛； 20 | 21 | 而右图对两个原始特征进行了归一化，其对应的等高线显得很圆，在梯度下降进行求解时能较快的收敛。 22 | 23 | 因此如果机器学习模型使用梯度下降法求最优解时，归一化往往非常有必要，否则很难收敛甚至不能收敛。 24 | 25 | 2 归一化有可能提高精度 26 | 一些分类器需要计算样本之间的距离（如欧氏距离），例如KNN。如果一个特征值域范围非常大，那么距离计算就主要取决于这个特征，从而与实际情况相悖（比如这时实际情况是值域范围小的特征更重要）。 27 | 28 | 3 归一化的类型 29 | 1）线性归一化 30 | 31 | ![](https://julyedu-img-public.oss-cn-beijing.aliyuncs.com/Public/Image/Question/1512811997_689.png) 32 | 33 | 这种归一化方法比较适用在数值比较集中的情况。这种方法有个缺陷，如果max和min不稳定，很容易使得归一化结果不稳定，使得后续使用效果也不稳定。实际使用中可以用经验常量值来替代max和min。 34 | 35 | 2）标准差标准化 36 | 经过处理的数据符合标准正态分布，即均值为0，标准差为1，其转化函数为： 37 | 38 | ![](https://julyedu-img-public.oss-cn-beijing.aliyuncs.com/Public/Image/Question/1512812012_794.png) 39 | 40 | 其中μ为所有样本数据的均值，σ为所有样本数据的标准差。 41 | 42 | 3）非线性归一化 43 | 经常用在数据分化比较大的场景，有些数值很大，有些很小。通过一些数学函数，将原始值进行映射。该方法包括 log、指数，正切等。需要根据数据分布的情况，决定非线性函数的曲线，比如log(V, 2)还是log(V, 10)等。 44 | 45 | 46 | > 本文转自https://www.julyedu.com/question/big/kp_id/23/ques_id/1011 47 | -------------------------------------------------------------------------------- /alg_base/one-hot.md: -------------------------------------------------------------------------------- 1 | 2 | # One-Hot Encoding 3 | 4 | ## 简介 5 | 又叫读热数据编码 6 | 7 | One-Hot编码，又称为一位有效编码，主要是采用位状态寄存器来对个状态进行编码，每个状态都由他独立的寄存器位，并且在任意时候只有一位有效。 8 | 9 | 10 | 在实际的应用场景中，有非常多的特征不是连续的数值变量，而是某一些离散的类别。比如在广告系统中，用户的性别，用户的地址，用户的兴趣爱好等等一系列特征，都是一些分类值。这些特征一般都无法直接应用在需要进行数值型计算的算法里，比如CTR预估中最常用的LR。那针对这种情况最简单的处理方式是将不同的类别映射为一个整数，比如男性是0号特征，女性为1号特征。这种方式最大的优点就是简单粗暴，实现简单。那最大的问题就是在这种处理方式中，各种类别的特征都被看成是有序的，这显然是非常不符合实际场景的。 11 | 12 | 为了解决上述问题，其中一种可能的解决方法是采用独热编码（One-Hot Encoding）。 13 | 独热编码即 One-Hot 编码，又称一位有效编码，其方法是使用N位状态寄存器来对N个状态进行编码，每个状态都由他独立的寄存器位，并且在任意时候，其中只有一位有效。可以这样理解，对于每一个特征，如果它有m个可能值，那么经过独热编码后，就变成了m个二元特征。并且，这些特征互斥，每次只有一个激活。因此，数据会变成稀疏的。（本段内容来自网络） 14 | 15 | ## 为什么能使用one hot 16 | 17 | 1. 使用one-hot编码，将离散特征的取值扩展到了欧式空间，离散特征的某个取值就对应欧式空间的某个点。 18 | 19 | 2. 将离散特征通过one-hot编码映射到欧式空间，是因为，在回归，分类，聚类等机器学习算法中，特征之间距离的计算或相似度的计算是非常重要的，而我们常用的距离或相似度的计算都是在欧式空间的相似度计算，计算余弦相似性，基于的就是欧式空间。 20 | 21 | 3. 将离散型特征使用one-hot编码，可以会让特征之间的距离计算更加合理。比如，有一个离散型特征，代表工作类型，该离散型特征，共有三个取值，不使用one-hot编码，其表示分别是x_1 = (1), x_2 = (2), x_3 = (3)。两个工作之间的距离是，(x_1, x_2) = 1, d(x_2, x_3) = 1, d(x_1, x_3) = 2。那么x_1和x_3工作之间就越不相似吗？显然这样的表示，计算出来的特征的距离是不合理。那如果使用one-hot编码，则得到x_1 = (1, 0, 0), x_2 = (0, 1, 0), x_3 = (0, 0, 1)，那么两个工作之间的距离就都是sqrt(2).即每两个工作之间的距离是一样的，显得更合理。 22 | 23 | 24 | ## One-Hot Encoding的处理方法 25 | 对于上述的问题，性别的属性是二维的，同理，地区是三维的，浏览器则是思维的，这样，我们可以采用One-Hot编码的方式对上述的样本“["male"，"US"，"Internet Explorer"]”编码，“male”则对应着[1，0]，同理“US”对应着[0，1，0]，“Internet Explorer”对应着[0,0,0,1]。则完整的特征数字化的结果为：[1,0,0,1,0,0,0,0,1]。这样导致的一个结果就是数据会变得非常的稀疏。 26 | 27 | 可以这样理解，对于每一个特征，如果它有m个可能值，那么经过独热编码后，就变成了m个二元特征。并且，这些特征互斥，每次只有一个激活。因此，数据会变成稀疏的。 28 | 29 | **这样做的好处主要有：**
30 | 31 | * 解决了分类器不好处理属性数据的问题 32 | * 在一定程度上也起到了扩充特征的作用 33 | 34 | 这篇blog写的挺好，我就直接拿过来粘上了，[出自](http://blog.csdn.net/google19890102/article/details/44039761) 35 | 36 | 37 | ## sklearn one hot encoder 38 | 39 | sklearn.preprocessing.OneHotEncoder 40 | 41 | one hot encoder 不仅对 label 可以进行编码，还可对 categorical feature 进行编码： 42 | 43 | ``` 44 | >>> from sklearn.preprocessing import OneHotEncoder 45 | >>> enc = OneHotEncoder() 46 | 47 | >>> enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]]) 48 | 49 | >>> enc.n_values_ 50 | array([2, 3, 4]) 51 | 52 | >>> enc.feature_indices_ 53 | array([0, 2, 5, 9]) 54 | 55 | >>> enc.transform([[0, 1, 1]]).toarray() 56 | array([[ 1., 0., 0., 1., 0., 0., 1., 0., 0.]]) 57 | 58 | 59 | ``` 60 | 61 | 62 | 为 OneHotEncoder 类传递进来的数据集： 63 | 64 | [[0, 0, 3], 65 | [1, 1, 0], 66 | [0, 2, 1], 67 | [1, 0, 2]] 68 | 69 | 每一列代表一个属性，fit 操作之后： 70 | 71 | * 对象enc的n_values_成员变量，记录着每一个属性的最大取值数目，如本例第一个属性：0, 1, 0, 1 ⇒ 2，0, 1, 2, 0 ⇒ 3，3, 0, 1, 2 ⇒ 4； 即各个属性（feature）在 one hot 编码下占据的位数； 72 | * 对象 enc 的 feature_indices_，则记录着属性在新 One hot 编码下的索引位置， 73 | feature_indices_ 是对 n_values_ 的累积值，不过 feature_indices 的首位是 0； 74 | 75 | 进一步通过 fit 好的 one hot encoder 对新来的特征向量进行编码： 76 | 77 | ``` 78 | >>> enc.transform([[0, 1, 1]]).toarray() 79 | array([[ 1., 0., 0., 1., 0., 0., 1., 0., 0.]]) 80 | ``` 81 | 82 | * 前 2 位 1, 0，对 0 进行编码 83 | * 中间 3 位 0, 1, 0 对 1 进行编码； 84 | * 末尾 4 位 0, 1, 0, 0 对 1 进行编码； 85 | 86 | 87 | # pandas get_dummy 88 | 另一种常用于统计建模或机器学习的转换方式是：将分类变量（categorical variable）转换为“哑变量矩阵”（dummy matrix）或“指标矩阵”（indicator matrix）。如果DataFrame的某一列中含有k个不同的值，则可以派生出一个k列矩阵或DataFrame（其值全为1和0）。pandas有一个get_dummies函数可以实现该功能（其实自己动手做一个也不难）。拿之前的一个例子来说：([本段转自](http://blog.csdn.net/eshaoliu/article/details/53557989)) 89 | 90 | ``` 91 | In [72]: df = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'], 92 | ....: 'data1': range(6)}) 93 | 94 | In [73]: pd.get_dummies(df['key']) 95 | Out[73]: 96 | a b c 97 | 0 0 1 0 98 | 1 0 1 0 99 | 2 1 0 0 100 | 3 0 0 1 101 | 4 1 0 0 102 | 5 0 1 0 103 | 104 | [6 rows x 3 columns] 105 | ``` 106 | -------------------------------------------------------------------------------- /alg_base/pca.md: -------------------------------------------------------------------------------- 1 | # 主成分分析 2 | 3 | ## 基本概念 4 | 主成分分析（Principal Component Analysis，PCA）， 是一种统计方法。通过正交变换将一组可能存在相关性的变量转换为一组线性不相关的变量，转换后的这组变量叫主成分。 5 | 6 | 在实际课题中，为了全面分析问题，往往提出很多与此有关的变量（或因素），因为每个变量都在不同程度上反映这个课题的某些信息。 7 | 8 | 主成分分析首先是由K.皮尔森（Karl Pearson）对非随机变量引入的，尔后H.霍特林将此方法推广到随机向量的情形。信息的大小通常用离差平方和或方差来衡量。 9 | 10 | > [来源于百度百科](https://baike.baidu.com/item/%E4%B8%BB%E6%88%90%E5%88%86%E5%88%86%E6%9E%90/829840?fr=aladdin) 11 | 12 | ## 基本原理 13 | 主成份分析是最经典的基于线性分类的分类系统。这个分类系统的最大特点就是利用线性拟合的思路把分布在多个维度的高维数据投射到几个轴上。如果每个样本只有两个数据变量，这种拟合就是 其中和分别是样本的两个变量，而和则被称为loading,计算出的P值就被称为主成份。实际上，当一个样本只有两个变量的时候，主成份分析本质上就是做一个线性回归。公式本质上就是一条直线。 14 | 15 | ![](http://images2015.cnblogs.com/blog/1036042/201610/1036042-20161016092028608-179450736.png) 16 | 17 | > [转自博文](http://www.cnblogs.com/SCUJIN/p/5965946.html) 18 | 19 | # pca原理 20 | 21 | > [参考博文](http://blog.jobbole.com/109015/) 22 | 23 | -------------------------------------------------------------------------------- /alg_base/precision_andrecall.md: -------------------------------------------------------------------------------- 1 | # 精确率与召回率，RoC曲线与PR曲线 2 | 3 | 在机器学习的算法评估中，尤其是分类算法评估中，我们经常听到精确率(precision)与召回率(recall)，RoC曲线与PR曲线这些概念，那这些概念到底有什么用处呢？ 4 | 5 | ## 精确率与召回率 6 | 首先，我们需要搞清楚几个拗口的概念： 7 | 8 | 1. TP, FP, TN, FN 9 | * True Positives,TP：预测为正样本，实际也为正样本的特征数 10 | * False Positives,FP：预测为正样本，实际为负样本的特征数 11 | * True Negatives,TN：预测为负样本，实际也为负样本的特征数 12 | * False Negatives,FN：预测为负样本，实际为正样本的特征数 13 | 14 | 15 | ### 精确率（Precision）: 16 | 17 | 预测对的结果占全部预测结果的比例，公式表示如下： 18 | 19 | ``` 20 | P = TP / (TP+FP) 21 | 22 | ``` 23 | 24 | 25 | ### 召回率(Recall)又称为查全率: 26 | 27 | 预测出的结果占真实情况的比例，公式表示如下： 28 | ``` 29 | R = TP / (TP+FN) 30 | 31 | ``` 32 | 33 | ## ROC曲线和PR曲线 34 | 35 | ![pic](http://images2015.cnblogs.com/blog/1042406/201610/1042406-20161024164359046-1869944207.png) 36 | -------------------------------------------------------------------------------- /alg_base/regularization.md: -------------------------------------------------------------------------------- 1 | # 正则化 2 | 3 | 正则化是一系列的方法： 4 | 5 | 6 | ## 正则化的目的是： 7 | * 控制参数幅度，不让模型无法无天 8 | * 限制参数搜索空间； 9 | 10 | ## 举例说明 11 | 线性回归来举例说明： 12 | loss function: 13 | 14 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170521165348.png) 15 | 16 | 加入正则化： 17 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170521-212109.png) 18 | 19 | 通常情况下，我们加入的正则化有两种： 20 | * L1正则化：θ平方 21 | * L1正则化：θ局对峙 22 | -------------------------------------------------------------------------------- /alg_base/sample_feature_label.md: -------------------------------------------------------------------------------- 1 | # sample & feature & label 2 | 3 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clipboard4.png) 4 | 5 | 上图中： 6 | * 每一行X是一个sample 7 | * 每一列是一个feature 8 | * y是label（标签） 9 | -------------------------------------------------------------------------------- /alg_base/scikit-plot.md: -------------------------------------------------------------------------------- 1 | # scikit-plot 2 | 3 | scikit-plot是一个画图神器，可以轻松的花常见的： 4 | * 混淆矩阵 5 | * PR-曲线 6 | * ROC曲线 7 | * 学习曲线 8 | * 特征重要性 9 | * 聚类的肘点等等 10 | 11 | 参考代码 12 | ``` 13 | # 画roc 14 | predicted_probas = best_tree.predict_proba(x_test) 15 | 16 | import scikitplot as skplt 17 | skplt.metrics.plot_roc(y_test, predicted_probas) 18 | plt.show() 19 | 20 | # 画PR曲线 21 | skplt.metrics.plot_precision_recall_curve(y_test, predicted_probas) 22 | plt.show() 23 | 24 | # 求AUC 25 | from sklearn.metrics import roc_auc_score 26 | roc_auc_score(y_test, predicted_probas[:,-1]) 27 | ``` 28 | 29 | 链接地址： 30 | 31 | https://github.com/reiinakano/scikit-plot 32 | -------------------------------------------------------------------------------- /alg_base/speed_up_training.md: -------------------------------------------------------------------------------- 1 | # 加速神经网络训练 (Speed Up Training) 2 | [参考链接]https://morvanzhou.github.io/tutorials/machine-learning/tensorflow/3-4-A-speed-up-learning/() 3 | 4 | 今天我们会来聊聊在怎么样加速你的神经网络训练过程. 5 | 6 | 注: 本文不会涉及数学推导. 大家可以在很多其他地方找到优秀的数学推导文章. 7 | 8 | 包括以下几种模式: 9 | 10 | * Stochastic Gradient Descent (SGD) 11 | * Momentum 12 | * AdaGrad 13 | * RMSProp 14 | * Adam 15 | 16 | 越复杂的神经网络 , 越多的数据 , 我们需要在训练神经网络的过程上花费的时间也就越多. 原因很简单, 就是因为计算量太大了. 可是往往有时候为了解决复杂的问题, 复杂的结构和大数据又是不能避免的, 所以我们需要寻找一些方法, 让神经网络聪明起来, 快起来. 17 | 18 | # Stochastic Gradient Descent (SGD) 19 | 20 | ![](https://morvanzhou.github.io/static/results/ML-intro/speedup2.png) 21 | 22 | 所以, 最基础的方法就是 SGD 啦, 想像红色方块是我们要训练的 data, 如果用普通的训练方法, 就需要重复不断的把整套数据放入神经网络 NN训练, 这样消耗的计算资源会很大. 23 | 24 | 我们换一种思路, 如果把这些数据拆分成小批小批的, 然后再分批不断放入 NN 中计算, 这就是我们常说的 SGD 的正确打开方式了. 每次使用批数据, 虽然不能反映整体数据的情况, 不过却很大程度上加速了 NN 的训练过程, 而且也不会丢失太多准确率.如果运用上了 SGD, 你还是嫌训练速度慢, 那怎么办? 25 | 26 | ![](https://morvanzhou.github.io/static/results/ML-intro/speedup3.png) 27 | 28 | 没问题, 事实证明, SGD 并不是最快速的训练方法, 红色的线是 SGD, 但它到达学习目标的时间是在这些方法中最长的一种. 我们还有很多其他的途径来加速训练. 29 | 30 | # Momentum 31 | ![](https://morvanzhou.github.io/static/results/ML-intro/speedup4.png) 32 | 33 | 大多数其他途径是在更新神经网络参数那一步上动动手脚. 传统的参数 W 的更新是把原始的 W 累加上一个负的学习率(learning rate) 乘以校正值 (dx). 这种方法可能会让学习过程曲折无比, 看起来像 喝醉的人回家时, 摇摇晃晃走了很多弯路. 34 | ![](https://morvanzhou.github.io/static/results/ML-intro/speedup5.png) 35 | 所以我们把这个人从平地上放到了一个斜坡上, 只要他往下坡的方向走一点点, 由于向下的惯性, 他不自觉地就一直往下走, 走的弯路也变少了. 这就是 Momentum 参数更新. 另外一种加速方法叫AdaGrad. 36 | 37 | # AdaGrad 更新方法 38 | ![](https://morvanzhou.github.io/static/results/ML-intro/speedup6.png) 39 | 40 | 这种方法是在学习率上面动手脚, 使得每一个参数更新都会有自己与众不同的学习率, 他的作用和 momentum 类似, 不过不是给喝醉酒的人安排另一个下坡, 而是给他一双不好走路的鞋子, 使得他一摇晃着走路就脚疼, 鞋子成为了走弯路的阻力, 逼着他往前直着走. 他的数学形式是这样的. 接下来又有什么方法呢? 如果把下坡和不好走路的鞋子合并起来, 是不是更好呢? 没错, 这样我们就有了 RMSProp 更新方法. 41 | 42 | # RMSProp 更新方法 43 | ![](https://morvanzhou.github.io/static/results/ML-intro/speedup7.png) 44 | 45 | 有了 momentum 的惯性原则 , 加上 adagrad 的对错误方向的阻力, 我们就能合并成这样. 让 RMSProp同时具备他们两种方法的优势. 不过细心的同学们肯定看出来了, 似乎在 RMSProp 中少了些什么. 原来是我们还没把 Momentum合并完全, RMSProp 还缺少了 momentum 中的 这一部分. 所以, 我们在 Adam 方法中补上了这种想法. 46 | 47 | # Adam 更新方法 48 | ![](https://morvanzhou.github.io/static/results/ML-intro/speedup8.png) 49 | 50 | 计算m 时有 momentum 下坡的属性, 计算 v 时有 adagrad 阻力的属性, 然后再更新参数时 把 m 和 V 都考虑进去. 实验证明, 大多数时候, 使用 adam 都能又快又好的达到目标, 迅速收敛. 所以说, 在加速神经网络训练的时候, 一个下坡, 一双破鞋子, 功不可没. 51 | -------------------------------------------------------------------------------- /alg_base/svm.md: -------------------------------------------------------------------------------- 1 | # A tutorial of SVM 2 | **Alexandre KOWALCZYK大神的SVM Tutorial写的非常好了，这里直接给出链接，以及我在网上看到的几篇比较好的blog。** 3 | 4 | * [Alexandre KOWALCZYK大神的SVM Tutorial](http://www.svm-tutorial.com/svm-tutorial/) 5 | * [July博客](https://blog.csdn.net/v_july_v/article/details/7624837) 6 | * [Youtube视频](https://www.youtube.com/watch?v=_PwhiWxHK8o&t=431s) 7 | 8 | **系列博客，6篇blog（1个小时）快速入门SVM** 9 | 1. [Margin（间隔）of svm](http://blog.csdn.net/han_xiaoyang/article/details/52678373) 10 | 2. [SVM中的向量与空间距离](http://blog.csdn.net/han_xiaoyang/article/details/52679559) 11 | 3. [如何找到最优分离超平面](http://blog.csdn.net/han_xiaoyang/article/details/52683653) 12 | 4. [无约束最小化问题](http://blog.csdn.net/han_xiaoyang/article/details/79079540) 13 | 5. [凸函数与优化](http://blog.csdn.net/han_xiaoyang/article/details/79080100) 14 | 6. [对偶和拉格朗日乘子](http://blog.csdn.net/han_xiaoyang/article/details/79080123) 15 | -------------------------------------------------------------------------------- /alg_base/task_nlp.md: -------------------------------------------------------------------------------- 1 | # 几个NLP任务 2 | 3 | ## 机器翻译 4 | 1. 机器翻译传统方法：概率模型和语法分析。现在常用方法基于深度学习seq2seq； 5 | 2. 回顾Transformer结构，引出self-attention； 6 | 3. Muti-head attention结构：用Muti-head思想有模型融合emsemble思想；从不同空间进行映射，再concat，取得更好效果 7 | 8 | ## 知识图谱 9 | 知识库可以做推理和表征关系 10 | 11 | 12 | ### 可以和bert一起联合训练模型 13 | 14 | 15 | > vec_entity1 in S1 16 | 17 | > vec_relationship in S2 18 | 19 | > vec_entity1 in S1 20 | 21 | > S1 == S2 or S1 != S2 22 | 23 | > vec_relationship * vec_entity1 = vec_entity2 24 | 25 | > concat(word_vec,vec_entity2) 26 | 27 | ### 上下位词 28 | 手机是苹果手机的上位词，苹果手机是iphone7的上位词 29 | 30 | ## 摘要和纠错 31 | * 摘要任务和文章改写比较像，是一个相对难的问题 32 | * 新闻摘要相对于简单，因为文章中重点部分相对集中。 33 | * 而其他问题难的原因是不确定那些信息是必要信息 34 | 35 | 36 | 文本纠错也可以用seq2seq模型来做，但关注的点不同 37 | 38 | 1. encoder layer要少忽略局部信息 39 | 2。 decoder layer要少见信息损失，尽量保留原始信息 40 | -------------------------------------------------------------------------------- /alg_base/the_division_of_ml.md: -------------------------------------------------------------------------------- 1 | # 机器学习领域划分 2 | 机器学习主要分为： 3 | * 有监督学习（supervised learning）； 4 | * 无监督学习（unsupervised learning）； 5 | * 增强学习（Reinforcement Learning）。 6 | ### Supervised learning 7 | Supervised learning又分为解决两类问题： 8 | * classification probleam 9 | * regression probleam 10 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clipboard2.png) 11 | ### Unsupervised learning 12 | Unsupervised learning分为聚类和数据降维两类算法，其中数据姜维算法包括PCA和T-sne等算法。 13 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/clipboard3.png) 14 | ### Reinforcement Learning 15 | Reinforcement Learning强调跟环境之间的交互；（游戏和机器人）； 16 | 17 | -------------------------------------------------------------------------------- /alg_base/todolist.md: -------------------------------------------------------------------------------- 1 | 1. AUC、roc咋算的，画的图啥含义 2 | -------------------------------------------------------------------------------- /alg_base/underfitting_vs_overfitting.md: -------------------------------------------------------------------------------- 1 | # 过拟合和正则化(underfitting vs overfitting) 2 | 3 | ## 模型的状态 4 | 5 | 模型很难训练到比较好的状态，很多时候模型会处于两种状态： 6 | * 欠拟合（underfitting） 7 | * 过拟合（overfitting） 8 | 9 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/alg_base/pic/20170521204631.png) 10 | 11 | 造成欠拟合可能原因： 12 | * 训练不够 13 | * 模型本身的容量或能力不够（主要原因） 14 | 15 | 过拟合问题： 16 | 如果有非常多的特征/模型过于复杂，我们假设的曲线可以对模型拟合的非常好，但丧失了一般性，所以导致对新给出的带预测样本，预测效果差。 17 | 18 | 在工业上，一般使用的模型的容量是够的， 19 | * 更多的参数，更复杂的模型，意味着更强的能力，但也更可能无法无天； 20 | * 眼见不一定为实，看到的内容不一定是全部的真实的分布，死记硬背不太好； 21 | 22 | ### 笑话一则 23 | 过拟合的笑话，来自于知乎： 24 | 25 | 作者：知乎用户 26 | 链接：https://www.zhihu.com/question/32246256/answer/55496955 27 | 28 | 29 | 30 | > 一個非洲酋長到倫敦訪問，一群記者在機場截住了他。早上好，酋長先生"， 其中一人問道：你的路途舒適嗎？ 31 | > 酋長發出了一連串刺耳的聲音哄、哼、啊、吱、嘶嘶，然后用純正的英語說 道 ：是的，非常地舒適。那麼！ 32 | > 您准備在這里待多久？他發出了同樣的一連串噪音，然後答：大約三星期，我想。酋長，告訴我， 33 | > 你是在哪學的這樣流利的英語？迷惑不解的記者問。又是一陣哄、吭、啊、吱、嘶嘶聲，酋長說：從短波收音機裡。 34 | 35 | 36 | -------------------------------------------------------------------------------- /alg_base/wiml.md: -------------------------------------------------------------------------------- 1 | # what is machine learning? 2 | 3 | 机器学习可以看做是数理统计的一个应用，在数理统计中一个常见的任务就是拟合，也就是给定一些样本点，用合适的曲线揭示这些样本点随着自变量的变化关系。 4 | -------------------------------------------------------------------------------- /alg_base/word2vec.md: -------------------------------------------------------------------------------- 1 | # word2vec 2 | ## 什么是word2vec 3 | word2vec 是 Google 在 2013 年年中开源的一款将词表征为实数值向量的高效 工具，采用的模型有 CBOW(Continuous Bag-Of-Words，即连续的词袋模型)和 Skip-Gram 两种。word2vec 代码链接为:https://code.google.com/p/word2vec/， 遵循 Apache License 2.0 开源协议，是一种对商业应用友好的许可，当然需要充 分尊重原作者的著作权。 4 | 5 | word2vec 一般被外界认为是一个 Deep Learning(深度学习)的模型，究其原因，可能和 word2vec 的作者 Tomas Mikolov 的 Deep Learning 背景以及 word2vec 是一种神经网络模型相关，但我们谨慎认为该模型层次较浅，严格来说还不能算 是深层模型。当然如果word2vec上层再套一层与具体应用相关的输出层，比如 Softmax，此时更像是一个深层模型。 6 | 7 | word2vec 通过训练，可以把对文本内容的处理简化为 K 维向量空间中的向量 运算，而向量空间上的相似度可以用来表示文本语义上的相似度。因此，word2vec 输出的词向量可以被用来做很多 NLP 相关的工作，比如聚类、找同义词、词性分 析等等。而 word2vec 被人广为传颂的地方是其向量的加法组合运算(Additive Compositionality )， 官 网 上 的 例 子 是 : vector('Paris') - vector('France') + vector('Italy')≈vector('Rome')，vector('king') - vector('man') + vector('woman')≈ vector('queen')。但我们认为这个多少有点被过度炒作了，很多其他降维或主题 模型在一定程度也能达到类似效果，而且 word2vec 也只是少量的例子完美符合 这种加减法操作，并不是所有的 case 都满足。 8 | 9 | word2vec 大受欢迎的另一个原因是其高效性，Mikolov 在论文[2]中指出一个 优化的单机版本一天可训练上千亿词。 10 | 11 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/word2vec.png) 12 | 13 | ## 背景知识 14 | ### 词向量 15 | 1. [One-hot representation](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/alg_base/One-hot-Representation.md) 16 | 2. [Distributed Representation](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/alg_base/Distributed_Representation.md) 17 | ### 主要思想 18 | **说起来word2vec，其实就是把词映射成一定维度的稠密向量，同时保持住词和词之间的关联性，主要体现在(欧式)距离的远近上。** 19 | 20 | ### 统计语言模型 21 | 传统的统计语言模型是表示语言基本单位(一般为句子)的概率分布函数， 这个概率分布也就是该语言的生成模型。一般语言模型可以使用各个词语条件概 率的形式表示: 22 | 23 | 𝑝(s) = 𝑝(𝑤1𝑇) = 𝑝(𝑤1, 𝑤2,... , 𝑤𝑇)=∏𝑇𝑡=1 𝑝( 𝑤𝑡|Context) 24 | 25 | 其中 Context 即为上下文，根据对 Context 不同的划分方法，可以分为五大类: 26 | 27 | #### (1)上下文无关模型(Context=NULL) 28 | 该模型仅仅考虑当前词本身的概率，不考虑该词所对应的上下文环境。这是一种最简单，易于实现，但没有多大实际应用价值的统计语言模型。 29 | 30 | 𝑝(𝑤𝑡|Context)= 𝑝(𝑤𝑡)=𝑁𝑤𝑡 / 𝑁 31 | 32 | 这个模型不考虑任何上下文信息，仅仅依赖于训练文本中的词频统计。它是 n-gram 模型中当 n=1 的特殊情形，所以有时也称作 Unigram Model(一元文法统计模型)。实际应用中，常被应用到一些商用语音识别系统中。 33 | 34 | #### (2)n-gram 模型(Context= 𝑤𝑡−n+1, 𝑤𝑡−n+2,... , 𝑤𝑡−1) 35 | n=1 时，就是上面所说的上下文无关模型，这里 n-gram 一般认为是 N>=2 是 的上下文相关模型。当 n=2 时，也称为 Bigram 语言模型，直观的想，在自然语 言中 “白色汽车”的概率比“白色飞翔”的概率要大很多，也就是 p(汽车|白色)> p(飞翔|白色)。n>2 也类似，只是往前看 n-1 个词而不是一个词。 36 | 37 | 一般 n-gram 模型优化的目标是最大 log 似然，即: 38 | 39 | ∏𝑇𝑡=1 𝑝𝑡( 𝑤𝑡|𝑤𝑡−n+1, 𝑤𝑡−n+2,... , 𝑤𝑡−1)log𝑝𝑚(𝑤𝑡|𝑤𝑡−n+1, 𝑤𝑡−n+2,... , 𝑤𝑡−1) 40 | 41 | n-gram 模型的优点包含了前 N-1 个词所能提供的全部信息，这些信息对当前词出现具有很强的约束力。同时因为只看 N-1 个词而不是所有词也使得模型的效率较高。 42 | 43 | n-gram 语言模型也存在一些问题: 44 | 45 | 1. n-gram 语言模型无法建模更远的关系，语料的不足使得无法训练更高阶的 语言模型。大部分研究或工作都是使用 Trigram，就算使用高阶的模型，其统计 到的概率可信度就大打折扣，还有一些比较小的问题采用 Bigram。 46 | 2. 这种模型无法建模出词之间的相似度，有时候两个具有某种相似性的词， 如果一个词经常出现在某段词之后，那么也许另一个词出现在这段词后面的概率 也比较大。比如“白色的汽车”经常出现，那完全可以认为“白色的轿车”也可 能经常出现。 47 | 3. 训练语料里面有些 n 元组没有出现过，其对应的条件概率就是 0，导致计 算一整句话的概率为 0。解决这个问题有两种常用方法: 48 | 49 | * 方法一为平滑法。最简单的方法是把每个 n 元组的出现次数加 1，那么原来 出现 k 次的某个 n 元组就会记为 k+1 次，原来出现 0 次的 n 元组就会记为出现 1 次。这种也称为 Laplace 平滑。当然还有很多更复杂的其他平滑方法，其本质都 是将模型变为贝叶斯模型，通过引入先验分布打破似然一统天下的局面。而引入 先验方法的不同也就产生了很多不同的平滑方法。 50 | 51 | * 方法二是回退法。有点像决策树中的后剪枝方法，即如果 n 元的概率不到， 那就往上回退一步，用 n-1 元的概率乘上一个权重来模拟。 52 | 53 | #### (3)n-pos模型(Context= 𝑐(𝑤𝑡−n+1),𝑐(𝑤𝑡−n+2),...,𝑐(𝑤𝑡−1)) 54 | 严格来说 n-pos 只是 n-gram 的一种衍生模型。n-gram 模型假定第 t 个词出现 概率条件依赖它前 N-1 个词，而现实中很多词出现的概率是条件依赖于它前面词 的语法功能的。n-pos 模型就是基于这种假设的模型，它将词按照其语法功能进 行分类，由这些词类决定下一个词出现的概率。这样的词类称为词性 (Part-of-Speech，简称为 POS)。n-pos 模型中的每个词的条件概率表示为: 55 | 56 | 𝑝(s) = 𝑝(𝑤1𝑇)= 𝑝(𝑤1,𝑤2,...,𝑤𝑇)=∏𝑇𝑡=1𝑝(𝑤𝑡|𝑐(𝑤𝑡−n+1),𝑐(𝑤𝑡−n+2),...,𝑐(𝑤𝑡−1)) 57 | 58 | c 为类别映射函数，即把 T 个词映射到 K 个类别。 59 | 60 | 实际上 n-Pos使用了一种聚类的思想，使得原来 n-gram 中𝑤𝑡−n+1, 𝑤𝑡−n+2,... , 𝑤𝑡−1中的可能为 61 | 62 | TN-1 减少到𝑐(𝑤𝑡−n+1),𝑐(𝑤𝑡−n+2),...,𝑐(𝑤𝑡−1)中的 KN-1，同时这种减少还采用了语义有意义的类别。 63 | 64 | #### (4)基于决策树的语言模型 65 | 上面提到的上下文无关语言模型、n-gram 语言模型、n-pos 语言模型等等， 66 | 都可以以统计决策树的形式表示出来。而统计决策树中每个结点的决策规则是一 个上下文相关的问题。这些问题可以是“前一个词时 w 吗?”“前一个词属于类 别 ci 吗?”。当然基于决策树的语言模型还可以更灵活一些，可以是一些“前一 个词是动词?”，“后面有介词吗?”之类的复杂语法语义问题。 67 | 68 | 基于决策树的语言模型优点是:分布数不是预先固定好的，而是根据训练预 料库中的实际情况确定，更为灵活。缺点是:构造统计决策树的问题很困难，且 时空开销很大。 69 | 70 | #### (5)最大熵模型 71 | 最大熵原理是E.T. Jayness于上世纪50年代提出的，其基本思想是:对一个 随机事件的概率分布进行预测时，在满足全部已知的条件下对未知的情况不做任 何主观假设。从信息论的角度来说就是:在只掌握关于未知分布的部分知识时， 应当选取符合这些知识但又能使得熵最大的概率分布。 72 | 𝑝(w|Context) =𝑒∑𝑖 𝜆𝑖𝑓𝑖(𝑐𝑜𝑛𝑡𝑒𝑥𝑡,𝑤) 𝑍(𝐶𝑜𝑛𝑡𝑒𝑥𝑡) 73 | 其中𝜆𝑖是参数，𝑍(𝐶𝑜𝑛𝑡𝑒𝑥𝑡)为归一化因子，因为采用的是这种 Softmax 形式， 所以最大熵模型有时候也称为指数模型。 74 | #### (6)自适应语言模型 75 | 前面的模型概率分布都是预先从训练语料库中估算好的，属于静态语言模型。 而自适应语言模型类似是 Online Learning 的过程，即根据少量新数据动态调整模 型，属于动态模型。在自然语言中，经常出现这样现象:某些在文本中通常很少 出现的词，在某一局部文本中突然大量地出现。能够根据词在局部文本中出现的 情况动态地调整语言模型中的概率分布数据的语言模型成为动态、自适应或者基 于缓存的语言模型。通常的做法是将静态模型与动态模型通过参数融合到一起， 这种混合模型可以有效地避免数据稀疏的问题。 76 | 77 | 还有一种主题相关的自适应语言模型，直观的例子为:专门针对体育相关内 容训练一个语言模型，同时保留所有语料训练的整体语言模型，当新来的数据属 于体育类别时，其应该使用的模型就是体育相关主题模型和整体语言模型相融合 的混合模型。 78 | 79 | ## NNLM 80 | NNLM 是 Neural Network Language Model 的缩写，即神经网络语言模型。神 经网络语言模型方面最值得阅读的文章是 Deep Learning 人物Bengio 的《A Neural Probabilistic Language Model》，JMLR 2003。 81 | 82 | NNLM 采用的是 Distributed Representation，即每个词被表示为一个浮点向量。 其模型图如下: 83 | 84 | ![](https://pic3.zhimg.com/61f31ca272dcd40ad0a3d05efc3172a2_b.jpg) 85 | 86 | 87 | > 本文参考blog[Deep Learning实战之word2vec](http://techblog.youdao.com/?p=915#LinkTarget_699) 88 | -------------------------------------------------------------------------------- /math_base/Comparison_Activation.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | https://zhuanlan.zhihu.com/p/32610035 4 | -------------------------------------------------------------------------------- /math_base/Hessian_Matrix.md: -------------------------------------------------------------------------------- 1 | # Hessian Matrix 2 | 3 | Hessian矩阵：在数学中，海森矩阵（Hessian matrix 或 Hessian） 4 | 是一个多变量实值函数的二阶偏导数组成的方阵，假设有一实数函数 f(x_1,x_2,…,x_n) ， 5 | 如果 f 所有的二阶偏导数都存在，那么 f 的Hessian矩阵的第 ij 项是 6 | ![](http://www.zhihu.com/equation?tex=%5Cfrac%7B%5Cpartial%5E2f%7D%7B%5Cpartial+x_i%5Cpartial+x_j%7D)， 7 | 即Hessian矩阵为 8 | 9 | ![](http://www.zhihu.com/equation?tex=H%28f%29%3D+%5Cleft%5B+%5Cbegin%7Bmatrix%7D+%5Cfrac%7B%5Cpartial%5E2f%7D%7B%5Cpartial+x_1%5E2%7D+%26+%5Cfrac%7B%5Cpartial%5E2f%7D%7B%5Cpartial+x_1%5Cpartial+x_2%7D+%26+%5Cldots+%26+%5Cfrac%7B%5Cpartial%5E2f%7D%7B%5Cpartial+x_1%5Cpartial+x_n%7D+%5C%5C+%5Cfrac%7B%5Cpartial%5E2f%7D%7B%5Cpartial+x_2%5Cpartial+x_1%7D+%26+%5Cfrac%7B%5Cpartial%5E2f%7D%7B%5Cpartial+x_2%5E2%7D+%26+%5Cldots+%26+%5Cfrac%7B%5Cpartial%5E2f%7D%7B%5Cpartial+x_2%5Cpartial+x_n%7D+%5C%5C+%5Cvdots+%26+%5Cvdots+%26+%5Cddots+%26+%5Cvdots+%5C%5C+%5Cfrac%7B%5Cpartial%5E2f%7D%7B%5Cpartial+x_n%5Cpartial+x_1%7D+%26+%5Cfrac%7B%5Cpartial%5E2f%7D%7B%5Cpartial+x_n%5Cpartial+x_2%7D+%26+%5Cldots+%26+%5Cfrac%7B%5Cpartial%5E2f%7D%7B%5Cpartial+x_n%5E2%7D+%5Cend%7Bmatrix%7D+%5Cright%5D) 10 | 11 | 如果函数 f 在定义域 D 内的每个二阶导数都是连续函数，那么 f 的海森矩阵在 D 区域内为对称矩阵。 12 | 13 | 极值点：基于Hessian矩阵 H 我们可以判断多元函数的极值情况： 14 | 15 | * 如果 H 是正定矩阵，则临界点一定是局部极小值点。 16 | * 如果 H 是负定矩阵，则临界点一定是局部极大值点。 17 | * 如果行列式 |H|=0 ，需要更高阶的导数来帮助判断。 18 | * 在其余情况下，临界点不是局部极值点。 19 | 20 | 实对称矩阵可对角化：若 A 是实对称矩阵， 21 | 则存在正交矩阵 Q 使得 22 | ![](http://www.zhihu.com/equation?tex=QAQ%5ET%3D%5CLambda%3Ddiag%28%5Clambda_1%2C%E2%80%A6%2C%5Clambda_n%29)， 23 | 其中 24 | ![](http://www.zhihu.com/equation?tex=%5Clambda_i) 25 | 是矩阵 A 的特征值。 26 | 27 | 若 A 可逆（即非奇异），则每个 28 | ![](http://www.zhihu.com/equation?tex=%5Clambda_i) 29 | 都非零且 30 | ![](http://www.zhihu.com/equation?tex=%5Clambda_i%5E%7B-1%7D) 31 | 是 32 | ![](http://www.zhihu.com/equation?tex=A%5E%7B-1%7D) 33 | 的特征值， i=1,2,…,n 。 34 | 35 | 36 | -------------------------------------------------------------------------------- /math_base/Lagrange.md: -------------------------------------------------------------------------------- 1 | # 拉格朗日乘子法和KKT条件 2 | 3 | 下面链接的中这位博主的博客已经讲的很清楚了哈，我就不赘述，发个链接吧： 4 | 5 | [深入理解拉格朗日乘子法（Lagrange Multiplier) 和KKT条件](http://www.cnblogs.com/mo-wang/p/4775548.html) 6 | -------------------------------------------------------------------------------- /math_base/MLE.md: -------------------------------------------------------------------------------- 1 | # 极大似然估计 2 | 3 | ## 好文链接 4 | https://zhuanlan.zhihu.com/p/26614750 5 | 6 | ## 贝叶斯公式带来的思考 7 | 8 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/think.png) 9 | 10 | 11 | 12 | *从而引出极大似然估计。* 13 | 14 | ## 极大似然估计 15 | 16 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/jidasiran.png) 17 | 18 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/shiji.png) 19 | 20 | 解方程组搞定 21 | 22 | 23 | ## 例子 24 | 25 | ### 二项分布 26 | 27 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/2017050221.png) 28 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/2017050222.png) 29 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/2017050223.png) 30 | 31 | 32 | ### 高斯分布 33 | 34 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/g1.png) 35 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/g2.png) 36 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/g3.png) 37 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/g4.png) 38 | 39 | 40 | ### 例子总结 41 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/sum2.png) 42 | 43 | 44 | ## 极大似然估计与过拟合 45 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/other.png) 46 | -------------------------------------------------------------------------------- /math_base/Prior_probability.md: -------------------------------------------------------------------------------- 1 | # 先验概率与后验概率 2 | * 事情还没有发生,要求这件事情发生的可能性的大小,是先验概率. 3 | 4 | * 事情已经发生,要求这件事情发生的原因是由某个因素引起的可能性的大小,是后验概率. 5 | 6 | 后验概率可以根据通过贝叶斯公式，用先验概率和似然函数计算出来。 7 | -------------------------------------------------------------------------------- /math_base/activation_relu_function.md: -------------------------------------------------------------------------------- 1 | # Relu 2 | ![](https://img-blog.csdn.net/20161113161105403) 3 | 4 | 从上图不难看出，ReLU函数其实是分段线性函数，把所有的负值都变为0，而正值不变，这种操作被成为单侧抑制。 可别小看这个简单的操作，正因为有了这单侧抑制，才使得神经网络中的神经元也具有了稀疏激活性。尤其体现在深度神经网络模型(如CNN)中，当模型增加N层之后，理论上ReLU神经元的激活率将降低2的N次方倍。这里或许有童鞋会问：ReLU的函数图像为什么一定要长这样？反过来，或者朝下延伸行不行？其实还不一定要长这样。只要能起到单侧抑制的作用，无论是镜面翻转还是180度翻转，最终神经元的输出也只是相当于加上了一个常数项系数，并不影响模型的训练结果。之所以这样定，或许是为了契合生物学角度，便于我们理解吧。 5 | 那么问题来了：这种稀疏性有何作用？换句话说，我们为什么需要让神经元稀疏？不妨举栗子来说明。当看名侦探柯南的时候，我们可以根据故事情节进行思考和推理，这时用到的是我们的大脑左半球；而当看蒙面唱将时，我们可以跟着歌手一起哼唱，这时用到的则是我们的右半球。左半球侧重理性思维，而右半球侧重感性思维。也就是说，当我们在进行运算或者欣赏时，都会有一部分神经元处于激活或是抑制状态，可以说是各司其职。再比如，生病了去医院看病，检查报告里面上百项指标，但跟病情相关的通常只有那么几个。与之类似，当训练一个深度分类模型的时候，和目标相关的特征往往也就那么几个，因此通过ReLU实现稀疏后的模型能够更好地挖掘相关特征，拟合训练数据。 6 | 7 | 此外，相比于其它激活函数来说，ReLU有以下优势： 8 | 对于线性函数而言，ReLU的表达能力更强，尤其体现在深度网络中； 9 | 而对于非线性函数而言，ReLU由于非负区间的梯度为常数，因此不存在梯度消失问题(Vanishing Gradient Problem)，使得模型的收敛速度维持在一个稳定状态。这里稍微描述一下什么是梯度消失问题：当梯度小于1时，预测值与真实值之间的误差每传播一层会衰减一次，如果在深层模型中使用sigmoid作为激活函数，这种现象尤为明显，将导致模型收敛停滞不前。 10 | 11 | 12 | 13 | 划重点： 14 | 1. CNN中Relu具单测抑制作用； 15 | 2. 对于线性函数而言，ReLU的表达能力更强 16 | 3. ReLU由于非负区间的梯度为常数，因此不存在梯度消失问题(Vanishing Gradient Problem) 17 | -------------------------------------------------------------------------------- /math_base/activation_sigmoid_function.md: -------------------------------------------------------------------------------- 1 | Sigmoid函数是一个有着优美S形曲线的数学函数，在逻辑回归、人工神经网络中有着广泛的应用。Sigmoid函数的数学形式是： 2 | 3 | ![](https://gss3.bdstatic.com/-Po3dSag_xI4khGkpoWK1HF6hhy/baike/s%3D99/sign=a46bd6f1dd33c895a27e9472d01340df/0df3d7ca7bcb0a4659502a5f6f63f6246b60af62.jpg) 4 | 5 | 其对x的导数可以用自身表示: 6 | 7 | ![](https://gss1.bdstatic.com/-vo3dSag_xI4khGkpoWK1HF6hhy/baike/s%3D236/sign=375012cedfca7bcb797bc02c88086b3f/64380cd7912397dde41ab3095182b2b7d0a2875f.jpg) 8 | 9 | ![](https://img-blog.csdn.net/20170226222316999?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc2FsdHJpdmVy/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast) 10 | -------------------------------------------------------------------------------- /math_base/activation_tanh_function.md: -------------------------------------------------------------------------------- 1 | # tanh 2 | 3 | ![](https://gss2.bdstatic.com/-fo3dSag_xI4khGkpoWK1HF6hhy/baike/s%3D177/sign=adf59bb1f51fbe09185ec7135c610c30/96dda144ad345982648941550bf431adcaef84f2.jpg) 4 | 5 | 6 | 导数： 7 | 8 | ![](https://gss3.bdstatic.com/-Po3dSag_xI4khGkpoWK1HF6hhy/baike/s%3D214/sign=d75f12b3ecf81a4c2232ebc8e32b6029/77094b36acaf2edd78a0e92e8a1001e9380193a0.jpg) 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /math_base/bayes.md: -------------------------------------------------------------------------------- 1 | # 2.概率论基本概念 2 | ## 概念 3 | ### PDF （probability density function） 4 | 5 | 概率密度函数简称PDF，这里指的是一维连续随机变量，多维连续变量也类似。随机数据的概率密度函数：表示瞬时幅值落在某指定范围内的概率，因此是幅值的函数。它随所取范围的幅值而变化。 6 | 密度函数f(x) 具有下列性质： 7 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/49.png) 8 | 9 | ### CDF（cumulative distribution function） 10 | CDF又名累计分布函数，用如下的例子说明： 11 | 12 | 13 | 14 | 15 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/48.png) 16 | 17 | 18 | ### 条件概率 19 | 20 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/1.png) 21 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/list.png) 22 | 23 | ### 全概率公式 24 | 25 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/3.png) 26 | 27 | ### 贝叶斯公式 28 | 29 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/4.png) 30 | 31 | 32 | ### 贝叶斯公式的推导过程 33 | 34 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/5.png) 35 | 36 | ### 频率学派和贝叶斯学派 37 | 举个现实点的例子，比如预测明天4月2号的气温，频率派可能抓取历史N年的4月2日的气温数据（为了稳定，可能也会4月2日前后一周的气温数据），然后得到均值和方差，然后得到一个温度范围及其置信度。贝叶斯学派可能根据之前的先验知识（地理位置，经济状况，政策……）估计到一个先验温度分布，然后根据当前这些因素的采样数据，用相似度去修正先验概率，得到一个修正后的后验概率分布。 38 | 39 | [更多内容，请参考链接](http://www.tuicool.com/articles/AfaU3ay) 40 | 41 | ### 二项分布 42 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/10.png) 43 | 44 | ### 均匀分布 45 | 46 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/8.png) 47 | 48 | ### 泊松分布 49 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/posong.png) 50 | 51 | ### 正态分布 52 | 53 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/zhengtai1.png) 54 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/zhengtai2.png) 55 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/zhengtai3.png) 56 | 57 | 58 | ### 指数分布 59 | 60 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/zhishu1.png) 61 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/zhishu2.png) 62 | 63 | ### 几何分布 64 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/11.png) 65 | 66 | ### 总结 67 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/sum.png) 68 | 69 | ### 补充说明 70 | Gamma分布在后续章节会有所涉及。 71 | 72 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/gamma.png) 73 | -------------------------------------------------------------------------------- /math_base/central_limit.md: -------------------------------------------------------------------------------- 1 | # 中心极限定理 2 | 3 | ## 切比雪夫不等式 4 | 5 | 6 | 7 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/qibixuefu.png) 8 | 9 | ## 大数定理 10 | 11 | *注意：事件Yn以概率1收敛于u ，但不是一定收敛于u* 12 | 13 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/dashudingli.png) 14 | 15 | 16 | 17 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/meaningOfdashudingli.png) 18 | 19 | ### 大数定理的一个推论 20 | 21 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/tuiliun.png) 22 | 23 | 24 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/theorem.png) 25 | 26 | 27 | ## 中心极限定理（Central Limit Theorem） 28 | -------------------------------------------------------------------------------- /math_base/conjugate.md: -------------------------------------------------------------------------------- 1 | # 共轭 2 | 3 | Collins词典的解释是 "joined together in pairs, coupled" ,Conjugate | Definition, meaning & more 然后举几个数学相关的例子，例如：连个互补的角度，两个虚数4+3j 和 4-3j 4 | 5 | # 共轭分布 6 | 7 | > 后验分布 = 似然函数* 先验分布/ P(X) 8 | 9 | 之所以采用共轭先验的原因是可以使得先验分布和后验分布的形式相同， 10 | -------------------------------------------------------------------------------- /math_base/cov.md: -------------------------------------------------------------------------------- 1 | # 协方差 2 | ## 一篇介绍方差、协方差概念的blog 3 | > [点击进入](http://www.cnblogs.com/chaosimple/p/3182157.html) 4 | ## 定义 5 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/define.png) 6 | 1. 当事件X和Y独立时，cov(X,Y) = 0； 7 | 2. 但cov(X,Y) = 0时，事件X和Y不是独立的，只是不相关。其实不相关的意思是事件X和Y线下独立； 8 | ## 性质 9 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/propty.png) 10 | 11 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/up.png) 12 | 13 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/2017050171.png) 14 | 15 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/20170501712.png) 16 | 17 | -------------------------------------------------------------------------------- /math_base/distribution.md: -------------------------------------------------------------------------------- 1 | # 3.各种分布 2 | 3 | ### 二项分布 4 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/10.png) 5 | 6 | ### 均匀分布 7 | 8 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/8.png) 9 | 10 | ### 泊松分布 11 | *日常生活中，大量事件是有固定频率的。* 12 | 13 | 14 | > *某医院平均每小时出生3个婴儿* 15 | > *某公司平均每10分钟接到1个电话* 16 | > *某超市平均每天销售4包xx牌奶粉* 17 | > *某网站平均每分钟有2次访问* 18 | 19 | 20 | 它们的特点就是，我们可以预估这些事件的总数，但是没法知道具体的发生时间。已知平均每小时出生3个婴儿，请问下一个小时，会出生几个？ 21 | 22 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/posong1.png) 23 | 24 | 25 | ### 指数分布 26 | 指数分布是事件的时间间隔的概率。下面这些都属于指数分布。 27 | 28 | 29 | > 婴儿出生的时间间隔 30 | > 来电的时间间隔 31 | > 奶粉销售的时间间隔 32 | > 网站访问的时间间隔 33 | 34 | 指数分布的公式可以从泊松分布推断出来。如果下一个婴儿要间隔时间 t ，就等同于 t 之内没有任何婴儿出生。 35 | 36 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/zhishu1.png) 37 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/zhishu2.png) 38 | 39 | ### 正态分布 40 | 41 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/zhengtai1.png) 42 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/zhengtai2.png) 43 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/zhengtai3.png) 44 | 45 | 46 | ### 几何分布 47 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/11.png) 48 | 49 | ### 总结 50 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/sum.png) 51 | 52 | # 补充说明 53 | 1. 关于对泊松分布和指数分布的理解，强烈建议大家看一下下面这个博客； 54 | [阮一峰的网络日志:泊松分布和指数分布：10分钟教程](http://www.ruanyifeng.com/blog/2015/06/poisson-distribution.html) 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 2. Gamma分布在后续章节会有所涉及。 65 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/gamma.png) 66 | -------------------------------------------------------------------------------- /math_base/expectation_variance.md: -------------------------------------------------------------------------------- 1 | # 期望和方差 2 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/ch3.jpg) 3 | -------------------------------------------------------------------------------- /math_base/likehood.md: -------------------------------------------------------------------------------- 1 | # 似然函数 2 | 3 | 参考自blog 4 | > http://www.cnblogs.com/zhsuiy/p/4822020.html 5 | 6 | 常说的概率是指给定参数后，预测即将发生的事件的可能性。拿硬币这个例子来说，我们已知一枚均匀硬币的正反面概率分别是0.5，要预测抛两次硬币，硬币都朝上的概率： 7 | 8 | H代表Head，表示头朝上 9 | 10 | p(HH | pH = 0.5) = 0.5*0.5 = 0.25. 11 | 12 | 这种写法其实有点误导，后面的这个p其实是作为参数存在的，而不是一个随机变量，因此不能算作是条件概率，更靠谱的写法应该是 p(HH;p=0.5)。 13 | 14 | 而似然概率正好与这个过程相反，我们关注的量不再是事件的发生概率，而是已知发生了某些事件，我们希望知道参数应该是多少。 15 | 16 | 现在我们已经抛了两次硬币，并且知道了结果是两次头朝上，这时候，我希望知道这枚硬币抛出去正面朝上的概率为0.5的概率是多少？正面朝上的概率为0.8的概率是多少？ 17 | 18 | 如果我们希望知道正面朝上概率为0.5的概率，这个东西就叫做似然函数，可以说成是对某一个参数的猜想（p=0.5）的概率，这样表示成(条件)概率就是 19 | 20 | L(pH=0.5|HH) = P(HH|pH=0.5) = （另一种写法）P(HH;pH=0.5). 21 | 22 | 为什么可以写成这样？我觉得可以这样来想： 23 | 24 | 似然函数本身也是一种概率，我们可以把L(pH=0.5|HH)写成P(pH=0.5|HH); 而根据贝叶斯公式，P(pH=0.5|HH) = P(pH=0.5,HH)/P(HH)；既然HH是已经发生的事件，理所当然P(HH) = 1,所以： 25 | 26 | P(pH=0.5|HH) = P(pH=0.5,HH) = P(HH;pH=0.5). 27 | 28 | 右边的这个计算我们很熟悉了，就是已知头朝上概率为0.5，求抛两次都是H的概率，即0.5*0.5=0.25。 29 | 30 | 所以，我们可以safely得到: 31 | 32 | L(pH=0.5|HH) = P(HH|pH=0.5) = 0.25. 33 | -------------------------------------------------------------------------------- /math_base/linearly_separable.md: -------------------------------------------------------------------------------- 1 | # 线性可分与线性不可分 2 | 3 | 简单的说就是如果用一个线性函数可以将两类样本完全分开，就称这些样本是“线性可分”的。 4 | 英文叫做linearly separable。 5 | 6 | 7 | 更多内容参考： 8 | [](http://blog.csdn.net/u013300875/article/details/44081067) 9 | -------------------------------------------------------------------------------- /math_base/matrix.md: -------------------------------------------------------------------------------- 1 | # 重新理解矩阵 2 | 3 | ## 序言 4 | 首先看一下数学符号表 5 | 6 | 7 | 8 | 9 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/math-symbol-list.png) 10 | 11 | 12 | ## 从新的视角看线性代数 13 | 14 | ## 基 15 | 16 | 17 | ## 子空间 18 | 19 | ## 特征值分解ED 20 | 21 | ### 对称矩阵的特征值分解 22 | 23 | ## 二次型 24 | 25 | ## SVD分解 26 | -------------------------------------------------------------------------------- /math_base/matrix_multi.md: -------------------------------------------------------------------------------- 1 | # 矩阵乘法规则 2 | 3 | ![](http://www.ruanyifeng.com/blogimg/asset/2015/bg2015090105.gif) 4 | 5 | more关于矩阵乘法的理解： 6 | [](http://www.ruanyifeng.com/blog/2015/09/matrix-multiplication.html) 7 | -------------------------------------------------------------------------------- /math_base/moment_estimation.md: -------------------------------------------------------------------------------- 1 | # 矩估计 2 | 3 | ## 样本统计量 4 | 5 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/yangben.png) 6 | 7 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/ju2.png) 8 | 9 | * 一阶样本原点矩就是期望； 10 | * 二阶样本中心矩/n-1是方差，除n是伪方差 11 | 12 | ## 思考 13 | 14 | 15 | 16 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/thinking.png) 17 | 18 | 19 | 20 | 21 | *引出矩估计* 22 | 23 | 24 | 25 | # 矩估计 26 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/define2.png) 27 | 28 | 29 | ## 矩估计的结论 30 | 31 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/jilun.png) 32 | -------------------------------------------------------------------------------- /math_base/pmf.md: -------------------------------------------------------------------------------- 1 | # 联合分布&边缘概率 2 | 3 | 下面的blog写的很好，包含：离散随机变量的联合分布，连续随机变量的联合分布，边缘概率。 4 | 5 | 6 | http://www.cnblogs.com/vamei/p/3224111.html 7 | -------------------------------------------------------------------------------- /math_base/skewness.md: -------------------------------------------------------------------------------- 1 | # 偏度和峰度 2 | 3 | ## 矩 4 | 5 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/ju.png) 6 | 7 | 从上面可以看到： 8 | * 期望就是k=1时的原点矩； 9 | * 方差就是k=2时的中心矩； 10 | 11 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/pianfeng.png) 12 | 13 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/pd.png) 14 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/pg.png) 15 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/fd.png) 16 | 17 | 18 | ## 数据分析 19 | 20 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/code.png) 21 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/p.png) 22 | 23 | ## 切比雪夫不等式 24 | 25 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/pic/qibixuefu.png) 26 | -------------------------------------------------------------------------------- /math_base/taylor.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | # 泰勒展开式和拟牛顿 5 | 6 | ### 一、泰勒展开式 7 | 8 | 如果f(x)在某一点n阶可导，则f(x)可泰勒展开： 9 | 10 | 11 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/20170501-1.png) 12 | 13 | ### 二、泰勒展开式的应用 14 | 15 | 1. 初等函数值计算，例如： 16 | 17 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/20170501-12.png) 18 | 19 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/20170501-13.png) 20 | 21 | 22 | 2. Taylor公式的应用2：解释Gini系数（在决策树章节会用到） 23 | 将f(x)=-lnx在x=1处一阶展开，忽略高阶无穷小，得到f(x)≈1-x 24 | 25 | 26 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/20170501-14.png) 27 | 28 | 29 | 3. Taylor公式的应用3：平方根算法 30 | 31 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/20170501-15.png) ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/20170501-16.png) ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/20170501-17.png) 32 | 33 | # 拟牛顿 34 | ### 一、梯度下降算法 35 | 36 | 下面的图是一个常见机器学习的流程： 37 | 38 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/604.png) 39 | 40 | 41 | 假说函数h(x)，损失函数J(θ)。其中J(θ)是衡量模型（假说函数）好坏的函数，如下图所示。 42 | 43 | 44 | ![假说函数h(x)]https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/hhx.png) 45 | 46 | 47 | 48 | 49 | ![损失函数J(θ)](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/20170501-18.png) 50 | 51 | 52 | 53 | 54 | 55 | 56 | **求min（ J(θ)** 57 | *初始化θ(随机初始化) 58 | *沿着负梯度方向迭代，更新后的θ使J(θ)更小 59 | 60 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/20170501-19.png) 61 | 62 | ### 利用泰勒展开式 63 | 若f(x)二阶导连续，将f(x)在xk处Taylor展开 64 | 65 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/20170501-110.png) 66 | 67 | 68 | 对其求导，因为求极值所以其导数为0，得到： 69 | 70 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/20170501-111.png) 71 | 72 | 73 | **上述公式就是牛顿法** 74 | 75 | 76 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/math_base/20170501-112.png) 77 | 78 | 79 | * 牛顿法是在Xk点做的虚线抛物线 80 | * 梯度下降算法是在Xk点做的切线 81 | 82 | # 牛顿法的特点： 83 | 1. 牛顿法具有二阶收敛性，在某些目标函数(如线性回归、Logistic回归等)的问题中，它的收敛速度比梯度下降要快。 84 | 2. 经典牛顿法虽然具有二次收敛性，但是要求初始点需要尽量靠近极小点，否则有可能不收敛。 85 | * 如果Hessian矩阵奇异，牛顿方向可能根本不存在。 86 | * 若Hessian矩阵不是正定，则牛顿方向有可能是反方向。 87 | 3. 计算过程中需要计算目标函数的二阶偏导数的逆，时间复杂度较大。 88 | 89 | **从而引出了拟牛顿，常用的拟牛顿算法有：** 90 | 91 | * DFS vidon – Fletcher – Powell 92 | * BFGS：Broyden – Fletcher – Goldfarb - Shanno 93 | -------------------------------------------------------------------------------- /papers/PIIA.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/papers/PIIA.pdf -------------------------------------------------------------------------------- /papers/nl2sql.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/papers/nl2sql.pdf -------------------------------------------------------------------------------- /practice/.recommendation_collaborative_filtering.md.swp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/practice/.recommendation_collaborative_filtering.md.swp -------------------------------------------------------------------------------- /practice/.rmse.md.swp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/practice/.rmse.md.swp -------------------------------------------------------------------------------- /practice/auto_ml_tools.md: -------------------------------------------------------------------------------- 1 | # 一些自动特征工程和模型选择和超参数优化的工具 2 | 3 | ![](http://inews.gtimg.com/newsapp_bt/0/4935913359/641) 4 | 5 | ## 特征工程 6 | 1. [Featuretools](https://github.com/Featuretools/featuretools) 7 | > Featuretools是一个自动特征工程的工具，它可以根据一组相关的表来自动构造特征。这个开源库是一个面向企业客户的商用前端服务的子集。 8 | 2. [Boruta-py](https://github.com/scikit-learn-contrib/boruta_py) 9 | > Boruta-py是Brouta特征降维策略的一种实现，以“全相关”方式来解决问题。 10 | 3. [Categorical-encoding](https://github.com/scikit-learn-contrib/categorical-encoding) 11 | > 这个库扩展了许多分类编码方法，可作为Scikit-learn中数据转换器的接口。 12 | 它还实现了常见的分类编码方法，如one-hot编码和hash编码，以及很多niche编码方法（包括base n编码和target编码）。 13 | 4. [Tsfresh] 14 | (https://github.com/blue-yonder/tsfresh) 15 | > 这个库专注于时间序列数据的特征生成，它由一个德国零售分析公司支持，是他们数据分析流程中的一步。 16 | 17 | ## 超参数优化 18 | 1. [Skopt] 19 | (https://scikit-optimize.github.io/) 20 | > Skopt是一个超参数优化库，包括随机搜索、贝叶斯搜索、决策森林和梯度提升树。 21 | 2. [Hyperopt] 22 | (https://github.com/hyperopt/hyperopt-sklearn) 23 | > Hyperopt是一个超参数优化库，针对具有一定条件或约束的搜索空间进行调优，其中包括随机搜索和Tree Parzen Estimators（贝叶斯优化的变体）等算法。 24 | 25 | 3. [Ray.tune] 26 | (https://github.com/ray-project/ray/tree/master/python/ray/tune) 27 | > Ray.tune是一个超参数优化库，主要适用于深度学习和强化学习模型。它结合了许多先进算法，如Hyperband算法（最低限度地训练模型来确定超参数的影响）、基于群体的训练算法（Population Based Training，在共享超参数下同时训练和优化一系列网络）、Hyperopt方法和中值停止规则（如果模型性能低于中等性能则停止训练）。 28 | 29 | 30 | ## 全流程解决方案 31 | 1. [ATM] 32 | (https://github.com/HDI-Project/ATM) 33 | > Auto-Tune Models是麻省理工学院HDI项目开发出的框架，可用于机器学习模型的快速训练，仅需很小的工作量。 34 | 它使用贝叶斯优化和Bandits库，利用穷举搜索和超参数优化来实现模型选择。要注意，ATM仅支持分类问题，也支持AWS上的分布式计算。 35 | 2. [MLBox] 36 | (https://github.com/AxeldeRomblay/MLBox) 37 | > MLBox是一个新出的框架，其目标是为自动机器学习提供一个最新和最先进的方法。 38 | > 除了许多现有框架实现的特征工程外，它还提供数据采集、数据清理和训练-测试漂移检测等功能。 39 | > 此外，它使用Tree Parzen Estimators来优化所选模型的超参数。 40 | 3. [auto_ml] 41 | (https://github.com/ClimbsRocks/auto_ml) 42 | > Auto_ml是一种实用工具，旨在提高从数据中获取的信息量，且无需除数据清洗外的过多工作。 43 | 该框架使用进化网格搜索算法来完成特征处理和模型优化的繁重工作。它利用其它成熟函数库（如XGBoost、TensorFlow、Keras、LightGBM和sklearn）来提高计算速度，还宣称只需最多1毫秒来实现预测，这也是这个库的亮点。 44 | > 该框架可快速洞察数据集（如特征重要性）来创建初始预测模型。 45 | 4. [auto-sklearn] 46 | (https://github.com/automl/auto-sklearn) 47 | > Auto-sklearn使用贝叶斯搜索来优化机器学习流程中使用的数据预处理器、特征预处理器和分类器，并把多个步骤经过训练后整合成一个完整模型。 48 | > 这个框架由弗莱堡大学的ML4AAD实验室编写，且其中的优化过程使用同一实验室编写的SMAC3框架完成。 49 | > 顾名思义，这个模型实现了sklearn中机器学习算法的自动构建。Auto-sklearn的主要特点是一致性和稳定性。 50 | 5. [H2O] 51 | (https://github.com/h2oai/h2o-3) 52 | > H2O是一个用Java编写的机器学习平台，它和sklearn等机器学习库的使用体验相似。但是，它还包含一个自动机器学习模块，这个模块利用其内置算法来创建机器学习模型。 53 | > 该框架对内置于H2O系统的预处理器实施穷举搜索，并使用笛卡尔网格搜索或随机网格搜索来优化超参数。 54 | > H2O的优势在于它能够形成大型计算机集群，这使得它在规模上有所增长。它还可在python、javascript、tableau、R和Flow（web UI）等环境中使用。 55 | 6. [TPOT] 56 | (https://github.com/EpistasisLab/tpot) 57 | > TPOT为基于树的流程优化工具，是一种用于查找和生成最佳数据科学流程代码的遗传编程框架。TPOT和其他自动机器学习框架一样，从sklearn库中获取算法。 58 | > TPOT的优势在于其独特的优化方法，可以提供更有效的优化流程。 59 | > 它还包括一个能把训练好的流程直接转换为代码的工具，这对希望能进一步调整生成模型的数据科学家来说是一个主要亮点。 60 | 61 | 62 | **原文：https://medium.com/georgian-impact-blog/automatic-machine-learning-aml-landscape-survey-f75c3ae3bbf2** 63 | -------------------------------------------------------------------------------- /practice/awesome-chatbot.md: -------------------------------------------------------------------------------- 1 | # awesome-chatbot 2 | A collection of awesome things regarding chat bots 3 | 4 | ## Chat or chatbot based startups 5 | - [msg.ai - AI for Conversational Commerce](http://msg.ai/) 6 | - [wit.ai - Natural Language for Developers 7 | ](https://wit.ai/) 8 | - [api.ai - Conversational UX platform](https://api.ai/) 9 | - [Chatfuel - Chatbot platform](http://chatfuel.com/) 10 | - [Prompt - Chatbot platform](http://promptapp.io/) 11 | - [Gupshup - Chatbot platform](https://www.gupshup.io) 12 | - [Magic - Text to get anything ondemand](https://getmagicnow.com/) 13 | - [Good service - get anything done over chat](http://www.goodservice.in/) 14 | - [Hyper - chat based Travel Agent](https://www.usehyper.com/) 15 | - [Cleverbot](http://www.cleverbot.com/) 16 | - [Sensay - The most helpful person you've never met](http://www.sensay.it/) 17 | - [Assist - Bring services to messaging apps](https://www.assi.st/) 18 | - [Botsociety - Chatbot design: preview, mockups, and export](https://botsociety.io) 19 | - [Notify - Conversational experiences that drive revenue] (http://www.notify.io) 20 | - [Backchannel - developer platform for building messaging bots] (http://dev.backchannel.net/) 21 | 22 | ## Big chatbot platforms 23 | - [IBM Bot Asset Exchange](https://developer.ibm.com/code/exchanges/bots/) 24 | - [Wechat official account](https://admin.wechat.com/) 25 | - [Slack](https://api.slack.com/bot-users) 26 | - [Facebook messenger](https://developers.facebook.com/docs/messenger-platform) 27 | - [Telegram](https://core.telegram.org/) 28 | - [Microsoft Bot Framework](https://dev.botframework.com/) 29 | 30 | ## Existing chatbots: 31 | - [ A. L. I. C. E.](http://alice.pandorabots.com/) 32 | - [Mitsuku](http://www.mitsuku.com/) 33 | - [Microsoft XiaoIce in Chinese ](http://www.msxiaoice.com/DesktopLanding) 34 | - [Microsoft Tay](https://twitter.com/tayandyou) 35 | 36 | ## Chatbot tools 37 | - [TuringRobot－The most intelligent robot brain](http://www.tuling123.com/) 38 | - [Facebook Messenger DevKit](https://github.com/olegakbarov/facebook-messenger-devkit) 39 | - [Broid - Multiple Messaging Channels with One OpenSource Language.](https://github.com/broidHQ/integrations/tree/master) 40 | 41 | ## Note: 42 | - Resources gathered during a hackathon 43 | - Feel free to pull request to add more resources 44 | 45 | ## One graph to rule it all [ref](http://www.economist.com/news/business-and-finance/21696477-market-apps-maturing-now-one-text-based-services-or-chatbots-looks-poised): 46 | ![20160409_wbc033](https://cloud.githubusercontent.com/assets/806173/14470823/7a0c8958-00a0-11e6-9d79-c871c7d3bd4f.png) 47 | -------------------------------------------------------------------------------- /practice/code/.ipynb_checkpoints/example_code_of_decision_tree-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 2 6 | } 7 | -------------------------------------------------------------------------------- /practice/code/deeplearning/Attention_on_seq2seq.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Attention on seq2seq\n", 8 | "实现一个Attention在seq2seq，使用keras\n", 9 | "\n", 10 | "[参考链接](https://zhuanlan.zhihu.com/p/40920384)" 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "metadata": {}, 16 | "source": [ 17 | "> seq2seq 是一个Encoder–Decoder 结构的网络，它的输入是一个序列，输出也是一个序列， Encoder 中将一个可变长度的信号序列变为固定长度的向量表达，Decoder 将这个固定长度的向量变成可变长度的目标的信号序列。" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "![](https://pic1.zhimg.com/80/v2-d90b7f4c45a9641296ce0862fe8ce0ac_hd.jpg)" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "想象一下翻译任务，input是一段英文，output是一段中文。" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "![](https://pic4.zhimg.com/80/v2-8ddf993a95ee6e525fe2cd5ccd49bba7_hd.jpg)" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": {}, 44 | "source": [ 45 | "左侧为Encoder+输入，右侧为Decoder+输出。中间为Attention。" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "![](https://pic3.zhimg.com/80/v2-ea1fa8ee06cabc119c16ee0feafb5eaa_hd.jpg)" 53 | ] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "metadata": {}, 58 | "source": [ 59 | "从左边Encoder开始，输入转换为word embedding, 进入LSTM。LSTM会在每一个时间点上输出hidden states。如图中的h1,h2,...,h8。" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "![](https://pic2.zhimg.com/80/v2-fcf2a510f1b7ff7f9e73d8140ec77f39_hd.jpg)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "Decoder方面接受的是目标句子里单词的word embedding，和上一个时间点的hidden state。" 74 | ] 75 | }, 76 | { 77 | "cell_type": "markdown", 78 | "metadata": {}, 79 | "source": [ 80 | "Decoder的hidden state与Encoder所有的hidden states作为输入，放入Attention模块开始计算一个context vector。之后会介绍attention的计算方法。\n" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "metadata": {}, 86 | "source": [ 87 | "![](https://pic1.zhimg.com/80/v2-73800a1528f84104d804f7d9a8951e24_hd.jpg)" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "来到时间点2，之前的context vector可以作为输入和目标的单词串起来作为lstm的输入。之后又回到一个hiddn state。以此循环。\n" 95 | ] 96 | }, 97 | { 98 | "cell_type": "markdown", 99 | "metadata": {}, 100 | "source": [ 101 | "![](https://pic1.zhimg.com/80/v2-bdf257055df55c4cc08bff527519f8cc_hd.jpg)" 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "另一方面，context vector和decoder的hidden state合起来通过一系列非线性转换以及softmax最后计算出概率。\n" 109 | ] 110 | }, 111 | { 112 | "attachments": {}, 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "在luong中提到了三种score的计算方法。这里图解前两种：\n", 117 | "\n", 118 | "![image.png](https://pic3.zhimg.com/80/v2-129287642af2e34d7e9e0afea9ae766e_hd.jpg)\n", 119 | "\n", 120 | "**Attention score function: dot**" 121 | ] 122 | }, 123 | { 124 | "cell_type": "markdown", 125 | "metadata": {}, 126 | "source": [ 127 | "![](https://pic4.zhimg.com/80/v2-79f411f6569f9867bed489ff15415eaf_hd.jpg)" 128 | ] 129 | }, 130 | { 131 | "cell_type": "markdown", 132 | "metadata": {}, 133 | "source": [ 134 | "输入是encoder的所有hidden states H: 大小为(hid dim, sequence length)。decoder在一个时间点上的hidden state， s： 大小为（hid dim, 1）。\n", 135 | "\n", 136 | "第一步：旋转H为（sequence length, hid dim) 与s做点乘得到一个 大小为(sequence length, 1)的分数。\n", 137 | "\n", 138 | "第二步：对分数做softmax得到一个合为1的权重。\n", 139 | "\n", 140 | "第三步：将H与第二步得到的权重做点乘得到一个大小为(hid dim, 1)的context vector。\n", 141 | "\n" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "metadata": {}, 147 | "source": [ 148 | "**Attention score function: general**" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "\n", 156 | "![](https://pic1.zhimg.com/80/v2-4a57e750deb2c5c6f82040b88f05266c_hd.jpg)\n", 157 | "\n", 158 | "输入是encoder的所有hidden states H: 大小为(hid dim1, sequence length)。decoder在一个时间点上的hidden state， s： 大小为（hid dim2, 1）。此处两个hidden state的纬度并不一样。\n", 159 | "\n", 160 | "第一步：旋转H为（sequence length, hid dim1) 与 Wa [大小为 hid dim1, hid dim 2)] 做点乘， 再和s做点乘得到一个 大小为(sequence length, 1)的分数。\n", 161 | "\n", 162 | "第二步：对分数做softmax得到一个合为1的权重。\n", 163 | "\n", 164 | "第三步：将H与第二步得到的权重做点乘得到一个大小为(hid dim, 1)的context vector。\n", 165 | "\n" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": null, 171 | "metadata": {}, 172 | "outputs": [], 173 | "source": [] 174 | } 175 | ], 176 | "metadata": { 177 | "kernelspec": { 178 | "display_name": "tensorflow-py3.5", 179 | "language": "python", 180 | "name": "tensorflow-py3.5" 181 | }, 182 | "language_info": { 183 | "codemirror_mode": { 184 | "name": "ipython", 185 | "version": 3 186 | }, 187 | "file_extension": ".py", 188 | "mimetype": "text/x-python", 189 | "name": "python", 190 | "nbconvert_exporter": "python", 191 | "pygments_lexer": "ipython3", 192 | "version": "3.5.2" 193 | } 194 | }, 195 | "nbformat": 4, 196 | "nbformat_minor": 2 197 | } 198 | -------------------------------------------------------------------------------- /practice/code/deeplearning/Classifier_with_keras.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Classitier with keras\n", 8 | "[参考链接](https://morvanzhou.github.io/tutorials/machine-learning/keras/2-2-classifier/)" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "metadata": {}, 14 | "source": [ 15 | "今天用 Keras 来构建一个分类神经网络，用到的数据集是 MNIST，就是 0 到 9 这几个数字的图片数据集。" 16 | ] 17 | }, 18 | { 19 | "cell_type": "code", 20 | "execution_count": 1, 21 | "metadata": {}, 22 | "outputs": [ 23 | { 24 | "name": "stderr", 25 | "output_type": "stream", 26 | "text": [ 27 | "/home/liyang22/tensorflow-py3.5/lib/python3.5/importlib/_bootstrap.py:222: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n", 28 | " return f(*args, **kwds)\n", 29 | "Using TensorFlow backend.\n", 30 | "/home/liyang22/tensorflow-py3.5/lib/python3.5/importlib/_bootstrap.py:222: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n", 31 | " return f(*args, **kwds)\n", 32 | "/home/liyang22/tensorflow-py3.5/lib/python3.5/importlib/_bootstrap.py:222: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n", 33 | " return f(*args, **kwds)\n", 34 | "/home/liyang22/tensorflow-py3.5/lib/python3.5/importlib/_bootstrap.py:222: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility. Expected 96, got 88\n", 35 | " return f(*args, **kwds)\n" 36 | ] 37 | } 38 | ], 39 | "source": [ 40 | "import numpy as np\n", 41 | "np.random.seed(1337) # for reproducibility\n", 42 | "from keras.datasets import mnist\n", 43 | "from keras.utils import np_utils\n", 44 | "from keras.models import Sequential\n", 45 | "from keras.layers import Dense, Activation\n", 46 | "from keras.optimizers import RMSprop\n", 47 | "\n", 48 | "# download the mnist to the path '~/.keras/datasets/' if it is the first time to be called\n", 49 | "# X shape (60,000 28x28), y shape (10,000, )\n", 50 | "(X_train, y_train), (X_test, y_test) = mnist.load_data()" 51 | ] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": 2, 56 | "metadata": {}, 57 | "outputs": [ 58 | { 59 | "data": { 60 | "text/plain": [ 61 | "(60000, 28, 28)" 62 | ] 63 | }, 64 | "execution_count": 2, 65 | "metadata": {}, 66 | "output_type": "execute_result" 67 | } 68 | ], 69 | "source": [ 70 | "X_train.shape" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": 3, 76 | "metadata": {}, 77 | "outputs": [ 78 | { 79 | "data": { 80 | "text/plain": [ 81 | "(60000,)" 82 | ] 83 | }, 84 | "execution_count": 3, 85 | "metadata": {}, 86 | "output_type": "execute_result" 87 | } 88 | ], 89 | "source": [ 90 | "y_train.shape" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": 4, 96 | "metadata": {}, 97 | "outputs": [ 98 | { 99 | "name": "stdout", 100 | "output_type": "stream", 101 | "text": [ 102 | "[7 2 1 ... 4 5 6]\n" 103 | ] 104 | } 105 | ], 106 | "source": [ 107 | "print(y_test)" 108 | ] 109 | }, 110 | { 111 | "cell_type": "code", 112 | "execution_count": 5, 113 | "metadata": {}, 114 | "outputs": [], 115 | "source": [ 116 | "# data pre-processing\n", 117 | "X_train = X_train.reshape(X_train.shape[0], -1) / 255. # normalize\n", 118 | "X_test = X_test.reshape(X_test.shape[0], -1) / 255. # normalize\n", 119 | "y_train = np_utils.to_categorical(y_train, num_classes=10)\n", 120 | "y_test = np_utils.to_categorical(y_test, num_classes=10)" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 6, 126 | "metadata": {}, 127 | "outputs": [ 128 | { 129 | "data": { 130 | "text/plain": [ 131 | "(60000, 784)" 132 | ] 133 | }, 134 | "execution_count": 6, 135 | "metadata": {}, 136 | "output_type": "execute_result" 137 | } 138 | ], 139 | "source": [ 140 | "X_train.shape" 141 | ] 142 | }, 143 | { 144 | "cell_type": "code", 145 | "execution_count": 7, 146 | "metadata": {}, 147 | "outputs": [ 148 | { 149 | "data": { 150 | "text/plain": [ 151 | "(60000, 10)" 152 | ] 153 | }, 154 | "execution_count": 7, 155 | "metadata": {}, 156 | "output_type": "execute_result" 157 | } 158 | ], 159 | "source": [ 160 | "y_train.shape" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": 8, 166 | "metadata": {}, 167 | "outputs": [ 168 | { 169 | "name": "stdout", 170 | "output_type": "stream", 171 | "text": [ 172 | "[[0. 0. 0. ... 1. 0. 0.]\n", 173 | " [0. 0. 1. ... 0. 0. 0.]\n", 174 | " [0. 1. 0. ... 0. 0. 0.]\n", 175 | " ...\n", 176 | " [0. 0. 0. ... 0. 0. 0.]\n", 177 | " [0. 0. 0. ... 0. 0. 0.]\n", 178 | " [0. 0. 0. ... 0. 0. 0.]]\n" 179 | ] 180 | } 181 | ], 182 | "source": [ 183 | "print(y_test)" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 9, 189 | "metadata": {}, 190 | "outputs": [ 191 | { 192 | "name": "stderr", 193 | "output_type": "stream", 194 | "text": [ 195 | "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:3: UserWarning: Update your `Dense` call to the Keras 2 API: `Dense(input_dim=784, units=32)`\n", 196 | " This is separate from the ipykernel package so we can avoid doing imports until\n", 197 | "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:5: UserWarning: Update your `Dense` call to the Keras 2 API: `Dense(units=10)`\n", 198 | " \"\"\"\n" 199 | ] 200 | } 201 | ], 202 | "source": [ 203 | "model = Sequential(\n", 204 | " [\n", 205 | " Dense(output_dim=32, input_dim=784),\n", 206 | " Activation('relu'),\n", 207 | " Dense(output_dim=10),\n", 208 | " Activation('softmax')\n", 209 | " ]\n", 210 | ")" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": 10, 216 | "metadata": {}, 217 | "outputs": [], 218 | "source": [ 219 | "# Another way to define your optimizer\n", 220 | "rmsprop = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)\n" 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": 11, 226 | "metadata": {}, 227 | "outputs": [], 228 | "source": [ 229 | "# We add metrics to get more results you want to see\n", 230 | "model.compile(optimizer=rmsprop,\n", 231 | " loss='categorical_crossentropy',\n", 232 | " metrics=['accuracy'])" 233 | ] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": 13, 238 | "metadata": {}, 239 | "outputs": [ 240 | { 241 | "name": "stdout", 242 | "output_type": "stream", 243 | "text": [ 244 | "Training ------------\n", 245 | "Epoch 1/2\n", 246 | "60000/60000 [==============================] - 13s 222us/step - loss: 0.3434 - acc: 0.9045\n", 247 | "Epoch 2/2\n", 248 | "60000/60000 [==============================] - 12s 202us/step - loss: 0.1947 - acc: 0.9438\n" 249 | ] 250 | }, 251 | { 252 | "data": { 253 | "text/plain": [ 254 | "" 255 | ] 256 | }, 257 | "execution_count": 13, 258 | "metadata": {}, 259 | "output_type": "execute_result" 260 | } 261 | ], 262 | "source": [ 263 | "print('Training ------------')\n", 264 | "# Another way to train the model\n", 265 | "model.fit(X_train, y_train, epochs=2, batch_size=32)" 266 | ] 267 | }, 268 | { 269 | "cell_type": "markdown", 270 | "metadata": {}, 271 | "source": [ 272 | "# 测试模型 \n", 273 | "接下来就是用测试集来检验一下模型，方法和回归网络中是一样的，运行代码之后，可以输出 accuracy 和 loss。" 274 | ] 275 | }, 276 | { 277 | "cell_type": "code", 278 | "execution_count": 14, 279 | "metadata": {}, 280 | "outputs": [ 281 | { 282 | "name": "stdout", 283 | "output_type": "stream", 284 | "text": [ 285 | "\n", 286 | "Testing ------------\n", 287 | "10000/10000 [==============================] - 1s 76us/step\n", 288 | "test loss: 0.17381608184352518\n", 289 | "test accuracy: 0.951\n" 290 | ] 291 | } 292 | ], 293 | "source": [ 294 | "print('\\nTesting ------------')\n", 295 | "# Evaluate the model with the metrics we defined earlier\n", 296 | "loss, accuracy = model.evaluate(X_test, y_test)\n", 297 | "\n", 298 | "print('test loss: ', loss)\n", 299 | "print('test accuracy: ', accuracy)\n" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": null, 305 | "metadata": {}, 306 | "outputs": [], 307 | "source": [] 308 | } 309 | ], 310 | "metadata": { 311 | "kernelspec": { 312 | "display_name": "tensorflow-py3.5", 313 | "language": "python", 314 | "name": "tensorflow-py3.5" 315 | }, 316 | "language_info": { 317 | "codemirror_mode": { 318 | "name": "ipython", 319 | "version": 3 320 | }, 321 | "file_extension": ".py", 322 | "mimetype": "text/x-python", 323 | "name": "python", 324 | "nbconvert_exporter": "python", 325 | "pygments_lexer": "ipython3", 326 | "version": "3.5.2" 327 | } 328 | }, 329 | "nbformat": 4, 330 | "nbformat_minor": 2 331 | } 332 | -------------------------------------------------------------------------------- /practice/code/deeplearning/Cnn_with_keras.py: -------------------------------------------------------------------------------- 1 | 2 | # coding: utf-8 3 | 4 | # # CNN 卷积神经网络 5 | 6 | # In[1]: 7 | 8 | 9 | import numpy as np 10 | np.random.seed(1337) # for reproducibility 11 | from keras.datasets import mnist 12 | from keras.utils import np_utils 13 | from keras.models import Sequential 14 | from keras.layers import Dense, Activation, Convolution2D, MaxPooling2D, Flatten 15 | from keras.optimizers import Adam 16 | 17 | 18 | # # 加载数据 19 | 20 | # In[2]: 21 | 22 | 23 | # download the mnist to the path '~/.keras/datasets/' if it is the first time to be called 24 | # training X shape (60000, 28x28), Y shape (60000, ). test X shape (10000, 28x28), Y shape (10000, ) 25 | (X_train, y_train), (X_test, y_test) = mnist.load_data() 26 | 27 | 28 | # In[3]: 29 | 30 | 31 | print(X_train.shape) 32 | 33 | 34 | # In[4]: 35 | 36 | 37 | print(X_train[0]) 38 | 39 | 40 | # In[5]: 41 | 42 | 43 | print(y_train.shape) 44 | 45 | 46 | # In[6]: 47 | 48 | 49 | y_test[1:10] 50 | 51 | 52 | # 上面代码可以看到X_Train是一个28*28的矩阵，y是一个表示数字的列表 53 | 54 | # In[7]: 55 | 56 | 57 | # data pre-processing 58 | X_train = X_train.reshape(-1,28, 28,1)/255. 59 | X_test = X_test.reshape(-1, 28, 28,1)/255. 60 | y_train = np_utils.to_categorical(y_train, num_classes=10) 61 | y_test = np_utils.to_categorical(y_test, num_classes=10) 62 | 63 | 64 | # In[8]: 65 | 66 | 67 | # Another way to build your CNN 68 | model = Sequential() 69 | 70 | 71 | # In[9]: 72 | 73 | 74 | X_test.shape 75 | 76 | 77 | # In[10]: 78 | 79 | 80 | model.add(Convolution2D( 81 | input_shape=(28, 28, 1), 82 | nb_filter=32, 83 | nb_row=5, 84 | nb_col=5, 85 | border_mode='same' 86 | )) 87 | 88 | 89 | # In[11]: 90 | 91 | 92 | model.add(Activation('relu')) 93 | 94 | 95 | # In[12]: 96 | 97 | 98 | model.add(MaxPooling2D( 99 | pool_size=(2,2), 100 | strides=(2,2), 101 | border_mode='same' 102 | )) 103 | 104 | 105 | # In[13]: 106 | 107 | 108 | model.add(Convolution2D( 109 | nb_filter=64, 110 | nb_row=5, 111 | nb_col=5, 112 | border_mode='same' 113 | )) 114 | 115 | 116 | # In[14]: 117 | 118 | 119 | model.add(Activation('relu')) 120 | 121 | 122 | # In[15]: 123 | 124 | 125 | model.add(MaxPooling2D( 126 | pool_size=(2,2), 127 | strides=(2,2), 128 | border_mode='same' 129 | )) 130 | 131 | 132 | # In[16]: 133 | 134 | 135 | # Fully connected layer 1 input shape (64 * 7 * 7) = (3136), output shape (1024) 136 | model.add(Flatten()) 137 | model.add(Dense(1024)) 138 | model.add(Activation('relu')) 139 | 140 | # Fully connected layer 2 to shape (10) for 10 classes 141 | model.add(Dense(10)) 142 | model.add(Activation('softmax')) 143 | 144 | 145 | # In[17]: 146 | 147 | 148 | # Another way to define your optimizer 149 | adam = Adam(lr=1e-4) 150 | 151 | 152 | # In[18]: 153 | 154 | 155 | model.compile(loss='categorical_crossentropy', 156 | optimizer=adam, 157 | metrics=['accuracy'] 158 | ) 159 | 160 | 161 | # In[19]: 162 | 163 | print('Training ------------') 164 | model.fit(X_train, y_train, batch_size=32, nb_epoch=1) 165 | 166 | 167 | print('\nTesting ------------') 168 | # Evaluate the model with the metrics we defined earlier 169 | loss, accuracy = model.evaluate(X_test, y_test) 170 | 171 | print('\ntest loss: ', loss) 172 | print('\ntest accuracy: ', accuracy) 173 | 174 | -------------------------------------------------------------------------------- /practice/code/deeplearning/variable_with_pytorch.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 12, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "tensor([[1., 2.],\n", 13 | " [3., 4.]])\n", 14 | "tensor([[1., 2.],\n", 15 | " [3., 4.]], requires_grad=True)\n", 16 | "tensor(7.5000)\n", 17 | "tensor(7.5000, grad_fn=)\n", 18 | "tensor([[0.5000, 1.0000],\n", 19 | " [1.5000, 2.0000]])\n", 20 | "tensor([[1., 2.],\n", 21 | " [3., 4.]], requires_grad=True)\n", 22 | "tensor([[1., 2.],\n", 23 | " [3., 4.]])\n", 24 | "[[1. 2.]\n", 25 | " [3. 4.]]\n" 26 | ] 27 | }, 28 | { 29 | "data": { 30 | "text/plain": [ 31 | "'\\n[[ 1. 2.]\\n [ 3. 4.]]\\n'" 32 | ] 33 | }, 34 | "execution_count": 12, 35 | "metadata": {}, 36 | "output_type": "execute_result" 37 | } 38 | ], 39 | "source": [ 40 | "\"\"\"\n", 41 | "View more, visit my tutorial page: https://morvanzhou.github.io/tutorials/\n", 42 | "My Youtube Channel: https://www.youtube.com/user/MorvanZhou\n", 43 | "Dependencies:\n", 44 | "torch: 0.1.11\n", 45 | "\"\"\"\n", 46 | "import torch\n", 47 | "from torch.autograd import Variable\n", 48 | "\n", 49 | "# Variable in torch is to build a computational graph,\n", 50 | "# but this graph is dynamic compared with a static graph in Tensorflow or Theano.\n", 51 | "# So torch does not have placeholder, torch can just pass variable to the computational graph.\n", 52 | "\n", 53 | "tensor = torch.FloatTensor([[1,2],[3,4]]) # build a tensor\n", 54 | "variable = Variable(tensor, requires_grad=True) # build a variable, usually for compute gradients\n", 55 | "\n", 56 | "print(tensor) # [torch.FloatTensor of size 2x2]\n", 57 | "print(variable) # [torch.FloatTensor of size 2x2]\n", 58 | "\n", 59 | "# till now the tensor and variable seem the same.\n", 60 | "# However, the variable is a part of the graph, it's a part of the auto-gradient.\n", 61 | "\n", 62 | "t_out = torch.mean(tensor*tensor) # x^2\n", 63 | "v_out = torch.mean(variable*variable) # x^2\n", 64 | "print(t_out)\n", 65 | "print(v_out) # 7.5\n", 66 | "\n", 67 | "v_out.backward() # backpropagation from v_out\n", 68 | "# v_out = 1/4 * sum(variable*variable)\n", 69 | "# the gradients w.r.t the variable, d(v_out)/d(variable) = 1/4*2*variable = variable/2\n", 70 | "print(variable.grad)\n", 71 | "'''\n", 72 | " 0.5000 1.0000\n", 73 | " 1.5000 2.0000\n", 74 | "'''\n", 75 | "\n", 76 | "print(variable) # this is data in variable format\n", 77 | "\"\"\"\n", 78 | "Variable containing:\n", 79 | " 1 2\n", 80 | " 3 4\n", 81 | "[torch.FloatTensor of size 2x2]\n", 82 | "\"\"\"\n", 83 | "\n", 84 | "print(variable.data) # this is data in tensor format\n", 85 | "\"\"\"\n", 86 | " 1 2\n", 87 | " 3 4\n", 88 | "[torch.FloatTensor of size 2x2]\n", 89 | "\"\"\"\n", 90 | "\n", 91 | "print(variable.data.numpy()) # numpy format\n", 92 | "\"\"\"\n", 93 | "[[ 1. 2.]\n", 94 | " [ 3. 4.]]\n", 95 | "\"\"\"" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": null, 101 | "metadata": {}, 102 | "outputs": [], 103 | "source": [] 104 | } 105 | ], 106 | "metadata": { 107 | "kernelspec": { 108 | "display_name": "pytorch-py3.5", 109 | "language": "python", 110 | "name": "pytorch-py3.5" 111 | }, 112 | "language_info": { 113 | "codemirror_mode": { 114 | "name": "ipython", 115 | "version": 3 116 | }, 117 | "file_extension": ".py", 118 | "mimetype": "text/x-python", 119 | "name": "python", 120 | "nbconvert_exporter": "python", 121 | "pygments_lexer": "ipython3", 122 | "version": "3.5.2" 123 | } 124 | }, 125 | "nbformat": 4, 126 | "nbformat_minor": 2 127 | } 128 | -------------------------------------------------------------------------------- /practice/code/example_code_of_decision_tree.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 4, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "{'Michael': 95, 'Bob': 75, 'name': 'lee'}\n" 13 | ] 14 | } 15 | ], 16 | "source": [ 17 | "d1 = {'Michael': 95, 'Bob': 75, 'name': 85}\n", 18 | "def foo(d):\n", 19 | " d[\"name\"] = \"lee\"\n", 20 | " return\n", 21 | "foo(d1)\n", 22 | "print(d1)" 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "metadata": {}, 28 | "source": [ 29 | "\n", 30 | "\n", 31 | "[本文参考博客](https://machinelearningmastery.com/implement-decision-tree-algorithm-scratch-python/)\n" 32 | ] 33 | } 34 | ], 35 | "metadata": { 36 | "kernelspec": { 37 | "display_name": "Python 3", 38 | "language": "python", 39 | "name": "python3" 40 | }, 41 | "language_info": { 42 | "codemirror_mode": { 43 | "name": "ipython", 44 | "version": 3 45 | }, 46 | "file_extension": ".py", 47 | "mimetype": "text/x-python", 48 | "name": "python", 49 | "nbconvert_exporter": "python", 50 | "pygments_lexer": "ipython3", 51 | "version": "3.6.1" 52 | } 53 | }, 54 | "nbformat": 4, 55 | "nbformat_minor": 2 56 | } 57 | -------------------------------------------------------------------------------- /practice/code/feature_engineering/.ipynb_checkpoints/Untitled-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": { 7 | "collapsed": true 8 | }, 9 | "outputs": [], 10 | "source": [] 11 | } 12 | ], 13 | "metadata": { 14 | "kernelspec": { 15 | "display_name": "Python 3", 16 | "language": "python", 17 | "name": "python3" 18 | }, 19 | "language_info": { 20 | "codemirror_mode": { 21 | "name": "ipython", 22 | "version": 3 23 | }, 24 | "file_extension": ".py", 25 | "mimetype": "text/x-python", 26 | "name": "python", 27 | "nbconvert_exporter": "python", 28 | "pygments_lexer": "ipython3", 29 | "version": "3.6.1" 30 | } 31 | }, 32 | "nbformat": 4, 33 | "nbformat_minor": 2 34 | } 35 | -------------------------------------------------------------------------------- /practice/code/feature_engineering/D805EAA4-5FCA-4CB1-B788-BEF90B34D9F3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/practice/code/feature_engineering/D805EAA4-5FCA-4CB1-B788-BEF90B34D9F3.png -------------------------------------------------------------------------------- /practice/code/input/kaggle_titanic_data/gender_submission.csv: -------------------------------------------------------------------------------- 1 | PassengerId,Survived 2 | 892,0 3 | 893,1 4 | 894,0 5 | 895,0 6 | 896,1 7 | 897,0 8 | 898,1 9 | 899,0 10 | 900,1 11 | 901,0 12 | 902,0 13 | 903,0 14 | 904,1 15 | 905,0 16 | 906,1 17 | 907,1 18 | 908,0 19 | 909,0 20 | 910,1 21 | 911,1 22 | 912,0 23 | 913,0 24 | 914,1 25 | 915,0 26 | 916,1 27 | 917,0 28 | 918,1 29 | 919,0 30 | 920,0 31 | 921,0 32 | 922,0 33 | 923,0 34 | 924,1 35 | 925,1 36 | 926,0 37 | 927,0 38 | 928,1 39 | 929,1 40 | 930,0 41 | 931,0 42 | 932,0 43 | 933,0 44 | 934,0 45 | 935,1 46 | 936,1 47 | 937,0 48 | 938,0 49 | 939,0 50 | 940,1 51 | 941,1 52 | 942,0 53 | 943,0 54 | 944,1 55 | 945,1 56 | 946,0 57 | 947,0 58 | 948,0 59 | 949,0 60 | 950,0 61 | 951,1 62 | 952,0 63 | 953,0 64 | 954,0 65 | 955,1 66 | 956,0 67 | 957,1 68 | 958,1 69 | 959,0 70 | 960,0 71 | 961,1 72 | 962,1 73 | 963,0 74 | 964,1 75 | 965,0 76 | 966,1 77 | 967,0 78 | 968,0 79 | 969,1 80 | 970,0 81 | 971,1 82 | 972,0 83 | 973,0 84 | 974,0 85 | 975,0 86 | 976,0 87 | 977,0 88 | 978,1 89 | 979,1 90 | 980,1 91 | 981,0 92 | 982,1 93 | 983,0 94 | 984,1 95 | 985,0 96 | 986,0 97 | 987,0 98 | 988,1 99 | 989,0 100 | 990,1 101 | 991,0 102 | 992,1 103 | 993,0 104 | 994,0 105 | 995,0 106 | 996,1 107 | 997,0 108 | 998,0 109 | 999,0 110 | 1000,0 111 | 1001,0 112 | 1002,0 113 | 1003,1 114 | 1004,1 115 | 1005,1 116 | 1006,1 117 | 1007,0 118 | 1008,0 119 | 1009,1 120 | 1010,0 121 | 1011,1 122 | 1012,1 123 | 1013,0 124 | 1014,1 125 | 1015,0 126 | 1016,0 127 | 1017,1 128 | 1018,0 129 | 1019,1 130 | 1020,0 131 | 1021,0 132 | 1022,0 133 | 1023,0 134 | 1024,1 135 | 1025,0 136 | 1026,0 137 | 1027,0 138 | 1028,0 139 | 1029,0 140 | 1030,1 141 | 1031,0 142 | 1032,1 143 | 1033,1 144 | 1034,0 145 | 1035,0 146 | 1036,0 147 | 1037,0 148 | 1038,0 149 | 1039,0 150 | 1040,0 151 | 1041,0 152 | 1042,1 153 | 1043,0 154 | 1044,0 155 | 1045,1 156 | 1046,0 157 | 1047,0 158 | 1048,1 159 | 1049,1 160 | 1050,0 161 | 1051,1 162 | 1052,1 163 | 1053,0 164 | 1054,1 165 | 1055,0 166 | 1056,0 167 | 1057,1 168 | 1058,0 169 | 1059,0 170 | 1060,1 171 | 1061,1 172 | 1062,0 173 | 1063,0 174 | 1064,0 175 | 1065,0 176 | 1066,0 177 | 1067,1 178 | 1068,1 179 | 1069,0 180 | 1070,1 181 | 1071,1 182 | 1072,0 183 | 1073,0 184 | 1074,1 185 | 1075,0 186 | 1076,1 187 | 1077,0 188 | 1078,1 189 | 1079,0 190 | 1080,1 191 | 1081,0 192 | 1082,0 193 | 1083,0 194 | 1084,0 195 | 1085,0 196 | 1086,0 197 | 1087,0 198 | 1088,0 199 | 1089,1 200 | 1090,0 201 | 1091,1 202 | 1092,1 203 | 1093,0 204 | 1094,0 205 | 1095,1 206 | 1096,0 207 | 1097,0 208 | 1098,1 209 | 1099,0 210 | 1100,1 211 | 1101,0 212 | 1102,0 213 | 1103,0 214 | 1104,0 215 | 1105,1 216 | 1106,1 217 | 1107,0 218 | 1108,1 219 | 1109,0 220 | 1110,1 221 | 1111,0 222 | 1112,1 223 | 1113,0 224 | 1114,1 225 | 1115,0 226 | 1116,1 227 | 1117,1 228 | 1118,0 229 | 1119,1 230 | 1120,0 231 | 1121,0 232 | 1122,0 233 | 1123,1 234 | 1124,0 235 | 1125,0 236 | 1126,0 237 | 1127,0 238 | 1128,0 239 | 1129,0 240 | 1130,1 241 | 1131,1 242 | 1132,1 243 | 1133,1 244 | 1134,0 245 | 1135,0 246 | 1136,0 247 | 1137,0 248 | 1138,1 249 | 1139,0 250 | 1140,1 251 | 1141,1 252 | 1142,1 253 | 1143,0 254 | 1144,0 255 | 1145,0 256 | 1146,0 257 | 1147,0 258 | 1148,0 259 | 1149,0 260 | 1150,1 261 | 1151,0 262 | 1152,0 263 | 1153,0 264 | 1154,1 265 | 1155,1 266 | 1156,0 267 | 1157,0 268 | 1158,0 269 | 1159,0 270 | 1160,1 271 | 1161,0 272 | 1162,0 273 | 1163,0 274 | 1164,1 275 | 1165,1 276 | 1166,0 277 | 1167,1 278 | 1168,0 279 | 1169,0 280 | 1170,0 281 | 1171,0 282 | 1172,1 283 | 1173,0 284 | 1174,1 285 | 1175,1 286 | 1176,1 287 | 1177,0 288 | 1178,0 289 | 1179,0 290 | 1180,0 291 | 1181,0 292 | 1182,0 293 | 1183,1 294 | 1184,0 295 | 1185,0 296 | 1186,0 297 | 1187,0 298 | 1188,1 299 | 1189,0 300 | 1190,0 301 | 1191,0 302 | 1192,0 303 | 1193,0 304 | 1194,0 305 | 1195,0 306 | 1196,1 307 | 1197,1 308 | 1198,0 309 | 1199,0 310 | 1200,0 311 | 1201,1 312 | 1202,0 313 | 1203,0 314 | 1204,0 315 | 1205,1 316 | 1206,1 317 | 1207,1 318 | 1208,0 319 | 1209,0 320 | 1210,0 321 | 1211,0 322 | 1212,0 323 | 1213,0 324 | 1214,0 325 | 1215,0 326 | 1216,1 327 | 1217,0 328 | 1218,1 329 | 1219,0 330 | 1220,0 331 | 1221,0 332 | 1222,1 333 | 1223,0 334 | 1224,0 335 | 1225,1 336 | 1226,0 337 | 1227,0 338 | 1228,0 339 | 1229,0 340 | 1230,0 341 | 1231,0 342 | 1232,0 343 | 1233,0 344 | 1234,0 345 | 1235,1 346 | 1236,0 347 | 1237,1 348 | 1238,0 349 | 1239,1 350 | 1240,0 351 | 1241,1 352 | 1242,1 353 | 1243,0 354 | 1244,0 355 | 1245,0 356 | 1246,1 357 | 1247,0 358 | 1248,1 359 | 1249,0 360 | 1250,0 361 | 1251,1 362 | 1252,0 363 | 1253,1 364 | 1254,1 365 | 1255,0 366 | 1256,1 367 | 1257,1 368 | 1258,0 369 | 1259,1 370 | 1260,1 371 | 1261,0 372 | 1262,0 373 | 1263,1 374 | 1264,0 375 | 1265,0 376 | 1266,1 377 | 1267,1 378 | 1268,1 379 | 1269,0 380 | 1270,0 381 | 1271,0 382 | 1272,0 383 | 1273,0 384 | 1274,1 385 | 1275,1 386 | 1276,0 387 | 1277,1 388 | 1278,0 389 | 1279,0 390 | 1280,0 391 | 1281,0 392 | 1282,0 393 | 1283,1 394 | 1284,0 395 | 1285,0 396 | 1286,0 397 | 1287,1 398 | 1288,0 399 | 1289,1 400 | 1290,0 401 | 1291,0 402 | 1292,1 403 | 1293,0 404 | 1294,1 405 | 1295,0 406 | 1296,0 407 | 1297,0 408 | 1298,0 409 | 1299,0 410 | 1300,1 411 | 1301,1 412 | 1302,1 413 | 1303,1 414 | 1304,1 415 | 1305,0 416 | 1306,1 417 | 1307,0 418 | 1308,0 419 | 1309,0 420 | -------------------------------------------------------------------------------- /practice/code/linear_regression_practice/linear_regression_data1.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 | -------------------------------------------------------------------------------- /practice/code/logisitic_regression_practice/.ipynb_checkpoints/Untitled-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 2 6 | } 7 | -------------------------------------------------------------------------------- /practice/code/logisitic_regression_practice/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 | -------------------------------------------------------------------------------- /practice/code/logisitic_regression_practice/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 | -------------------------------------------------------------------------------- /practice/code/output/Titanic_data/logistic_regression_bagging_predictions.csv: -------------------------------------------------------------------------------- 1 | PassengerId,Survived 2 | 892,0 3 | 893,0 4 | 894,0 5 | 895,0 6 | 896,0 7 | 897,0 8 | 898,0 9 | 899,0 10 | 900,1 11 | 901,0 12 | 902,0 13 | 903,0 14 | 904,0 15 | 905,0 16 | 906,0 17 | 907,1 18 | 908,0 19 | 909,1 20 | 910,0 21 | 911,1 22 | 912,0 23 | 913,0 24 | 914,0 25 | 915,1 26 | 916,0 27 | 917,0 28 | 918,1 29 | 919,1 30 | 920,0 31 | 921,0 32 | 922,0 33 | 923,0 34 | 924,0 35 | 925,0 36 | 926,1 37 | 927,1 38 | 928,0 39 | 929,0 40 | 930,0 41 | 931,0 42 | 932,0 43 | 933,0 44 | 934,0 45 | 935,0 46 | 936,0 47 | 937,0 48 | 938,0 49 | 939,0 50 | 940,0 51 | 941,0 52 | 942,0 53 | 943,1 54 | 944,0 55 | 945,0 56 | 946,1 57 | 947,0 58 | 948,0 59 | 949,0 60 | 950,0 61 | 951,1 62 | 952,0 63 | 953,0 64 | 954,0 65 | 955,0 66 | 956,0 67 | 957,0 68 | 958,0 69 | 959,0 70 | 960,1 71 | 961,0 72 | 962,0 73 | 963,0 74 | 964,0 75 | 965,1 76 | 966,1 77 | 967,1 78 | 968,0 79 | 969,0 80 | 970,0 81 | 971,0 82 | 972,1 83 | 973,0 84 | 974,0 85 | 975,0 86 | 976,0 87 | 977,0 88 | 978,0 89 | 979,0 90 | 980,0 91 | 981,0 92 | 982,0 93 | 983,0 94 | 984,0 95 | 985,0 96 | 986,1 97 | 987,0 98 | 988,0 99 | 989,0 100 | 990,0 101 | 991,0 102 | 992,1 103 | 993,0 104 | 994,0 105 | 995,0 106 | 996,1 107 | 997,0 108 | 998,0 109 | 999,0 110 | 1000,0 111 | 1001,0 112 | 1002,1 113 | 1003,0 114 | 1004,1 115 | 1005,0 116 | 1006,0 117 | 1007,1 118 | 1008,1 119 | 1009,0 120 | 1010,1 121 | 1011,0 122 | 1012,1 123 | 1013,0 124 | 1014,1 125 | 1015,0 126 | 1016,0 127 | 1017,0 128 | 1018,0 129 | 1019,0 130 | 1020,0 131 | 1021,0 132 | 1022,0 133 | 1023,0 134 | 1024,0 135 | 1025,0 136 | 1026,0 137 | 1027,0 138 | 1028,1 139 | 1029,0 140 | 1030,0 141 | 1031,0 142 | 1032,0 143 | 1033,0 144 | 1034,0 145 | 1035,0 146 | 1036,0 147 | 1037,0 148 | 1038,0 149 | 1039,0 150 | 1040,0 151 | 1041,0 152 | 1042,1 153 | 1043,1 154 | 1044,0 155 | 1045,0 156 | 1046,0 157 | 1047,0 158 | 1048,1 159 | 1049,0 160 | 1050,0 161 | 1051,0 162 | 1052,0 163 | 1053,1 164 | 1054,0 165 | 1055,0 166 | 1056,0 167 | 1057,0 168 | 1058,0 169 | 1059,0 170 | 1060,1 171 | 1061,0 172 | 1062,0 173 | 1063,1 174 | 1064,0 175 | 1065,1 176 | 1066,0 177 | 1067,0 178 | 1068,0 179 | 1069,0 180 | 1070,0 181 | 1071,0 182 | 1072,0 183 | 1073,0 184 | 1074,0 185 | 1075,0 186 | 1076,1 187 | 1077,0 188 | 1078,0 189 | 1079,0 190 | 1080,0 191 | 1081,0 192 | 1082,0 193 | 1083,0 194 | 1084,0 195 | 1085,0 196 | 1086,0 197 | 1087,0 198 | 1088,1 199 | 1089,0 200 | 1090,0 201 | 1091,0 202 | 1092,0 203 | 1093,0 204 | 1094,0 205 | 1095,0 206 | 1096,0 207 | 1097,1 208 | 1098,0 209 | 1099,0 210 | 1100,1 211 | 1101,0 212 | 1102,0 213 | 1103,0 214 | 1104,0 215 | 1105,0 216 | 1106,0 217 | 1107,0 218 | 1108,0 219 | 1109,0 220 | 1110,1 221 | 1111,0 222 | 1112,1 223 | 1113,0 224 | 1114,0 225 | 1115,0 226 | 1116,1 227 | 1117,1 228 | 1118,0 229 | 1119,0 230 | 1120,0 231 | 1121,0 232 | 1122,1 233 | 1123,1 234 | 1124,0 235 | 1125,0 236 | 1126,0 237 | 1127,0 238 | 1128,0 239 | 1129,1 240 | 1130,0 241 | 1131,0 242 | 1132,1 243 | 1133,0 244 | 1134,0 245 | 1135,0 246 | 1136,0 247 | 1137,0 248 | 1138,0 249 | 1139,0 250 | 1140,1 251 | 1141,1 252 | 1142,0 253 | 1143,0 254 | 1144,1 255 | 1145,0 256 | 1146,0 257 | 1147,0 258 | 1148,0 259 | 1149,0 260 | 1150,0 261 | 1151,0 262 | 1152,0 263 | 1153,0 264 | 1154,0 265 | 1155,1 266 | 1156,1 267 | 1157,0 268 | 1158,0 269 | 1159,0 270 | 1160,1 271 | 1161,0 272 | 1162,0 273 | 1163,0 274 | 1164,1 275 | 1165,0 276 | 1166,1 277 | 1167,1 278 | 1168,0 279 | 1169,0 280 | 1170,0 281 | 1171,0 282 | 1172,0 283 | 1173,0 284 | 1174,0 285 | 1175,1 286 | 1176,1 287 | 1177,0 288 | 1178,0 289 | 1179,0 290 | 1180,1 291 | 1181,0 292 | 1182,0 293 | 1183,0 294 | 1184,1 295 | 1185,0 296 | 1186,0 297 | 1187,0 298 | 1188,1 299 | 1189,0 300 | 1190,0 301 | 1191,0 302 | 1192,0 303 | 1193,0 304 | 1194,0 305 | 1195,0 306 | 1196,0 307 | 1197,0 308 | 1198,0 309 | 1199,0 310 | 1200,0 311 | 1201,0 312 | 1202,0 313 | 1203,1 314 | 1204,0 315 | 1205,0 316 | 1206,0 317 | 1207,0 318 | 1208,0 319 | 1209,0 320 | 1210,0 321 | 1211,0 322 | 1212,0 323 | 1213,1 324 | 1214,0 325 | 1215,0 326 | 1216,0 327 | 1217,0 328 | 1218,0 329 | 1219,1 330 | 1220,0 331 | 1221,0 332 | 1222,0 333 | 1223,1 334 | 1224,1 335 | 1225,1 336 | 1226,0 337 | 1227,0 338 | 1228,0 339 | 1229,0 340 | 1230,0 341 | 1231,1 342 | 1232,0 343 | 1233,0 344 | 1234,0 345 | 1235,0 346 | 1236,0 347 | 1237,1 348 | 1238,0 349 | 1239,1 350 | 1240,0 351 | 1241,0 352 | 1242,1 353 | 1243,0 354 | 1244,0 355 | 1245,0 356 | 1246,0 357 | 1247,0 358 | 1248,0 359 | 1249,0 360 | 1250,0 361 | 1251,0 362 | 1252,0 363 | 1253,1 364 | 1254,0 365 | 1255,0 366 | 1256,1 367 | 1257,0 368 | 1258,1 369 | 1259,0 370 | 1260,1 371 | 1261,1 372 | 1262,0 373 | 1263,1 374 | 1264,0 375 | 1265,0 376 | 1266,0 377 | 1267,0 378 | 1268,0 379 | 1269,0 380 | 1270,0 381 | 1271,0 382 | 1272,0 383 | 1273,0 384 | 1274,0 385 | 1275,0 386 | 1276,0 387 | 1277,0 388 | 1278,0 389 | 1279,0 390 | 1280,0 391 | 1281,0 392 | 1282,0 393 | 1283,0 394 | 1284,0 395 | 1285,0 396 | 1286,0 397 | 1287,0 398 | 1288,0 399 | 1289,0 400 | 1290,0 401 | 1291,0 402 | 1292,0 403 | 1293,0 404 | 1294,1 405 | 1295,0 406 | 1296,0 407 | 1297,1 408 | 1298,0 409 | 1299,0 410 | 1300,0 411 | 1301,0 412 | 1302,0 413 | 1303,0 414 | 1304,1 415 | 1305,0 416 | 1306,1 417 | 1307,0 418 | 1308,0 419 | 1309,0 420 | -------------------------------------------------------------------------------- /practice/code/output/Titanic_data/logistic_regression_predictions.csv: -------------------------------------------------------------------------------- 1 | PassengerId,Survived 2 | 892,0 3 | 893,0 4 | 894,0 5 | 895,0 6 | 896,0 7 | 897,0 8 | 898,0 9 | 899,0 10 | 900,1 11 | 901,0 12 | 902,0 13 | 903,0 14 | 904,1 15 | 905,0 16 | 906,0 17 | 907,1 18 | 908,0 19 | 909,1 20 | 910,0 21 | 911,1 22 | 912,0 23 | 913,1 24 | 914,1 25 | 915,1 26 | 916,1 27 | 917,0 28 | 918,1 29 | 919,1 30 | 920,0 31 | 921,0 32 | 922,0 33 | 923,0 34 | 924,0 35 | 925,0 36 | 926,1 37 | 927,1 38 | 928,1 39 | 929,1 40 | 930,0 41 | 931,0 42 | 932,0 43 | 933,0 44 | 934,0 45 | 935,1 46 | 936,0 47 | 937,0 48 | 938,1 49 | 939,0 50 | 940,1 51 | 941,0 52 | 942,0 53 | 943,1 54 | 944,1 55 | 945,0 56 | 946,1 57 | 947,0 58 | 948,0 59 | 949,0 60 | 950,0 61 | 951,1 62 | 952,0 63 | 953,0 64 | 954,1 65 | 955,0 66 | 956,1 67 | 957,1 68 | 958,1 69 | 959,0 70 | 960,1 71 | 961,0 72 | 962,0 73 | 963,0 74 | 964,0 75 | 965,1 76 | 966,1 77 | 967,1 78 | 968,0 79 | 969,0 80 | 970,0 81 | 971,0 82 | 972,1 83 | 973,0 84 | 974,0 85 | 975,0 86 | 976,0 87 | 977,1 88 | 978,0 89 | 979,1 90 | 980,0 91 | 981,0 92 | 982,0 93 | 983,0 94 | 984,1 95 | 985,0 96 | 986,1 97 | 987,0 98 | 988,0 99 | 989,0 100 | 990,1 101 | 991,0 102 | 992,1 103 | 993,0 104 | 994,0 105 | 995,0 106 | 996,1 107 | 997,0 108 | 998,0 109 | 999,0 110 | 1000,0 111 | 1001,0 112 | 1002,1 113 | 1003,0 114 | 1004,1 115 | 1005,0 116 | 1006,0 117 | 1007,1 118 | 1008,1 119 | 1009,1 120 | 1010,1 121 | 1011,0 122 | 1012,1 123 | 1013,0 124 | 1014,1 125 | 1015,0 126 | 1016,0 127 | 1017,1 128 | 1018,0 129 | 1019,0 130 | 1020,0 131 | 1021,0 132 | 1022,0 133 | 1023,0 134 | 1024,0 135 | 1025,1 136 | 1026,0 137 | 1027,0 138 | 1028,1 139 | 1029,1 140 | 1030,1 141 | 1031,0 142 | 1032,0 143 | 1033,1 144 | 1034,0 145 | 1035,0 146 | 1036,0 147 | 1037,0 148 | 1038,0 149 | 1039,0 150 | 1040,0 151 | 1041,0 152 | 1042,1 153 | 1043,1 154 | 1044,0 155 | 1045,0 156 | 1046,0 157 | 1047,0 158 | 1048,1 159 | 1049,1 160 | 1050,0 161 | 1051,0 162 | 1052,0 163 | 1053,1 164 | 1054,1 165 | 1055,0 166 | 1056,0 167 | 1057,0 168 | 1058,1 169 | 1059,0 170 | 1060,1 171 | 1061,1 172 | 1062,0 173 | 1063,1 174 | 1064,0 175 | 1065,1 176 | 1066,0 177 | 1067,1 178 | 1068,1 179 | 1069,1 180 | 1070,0 181 | 1071,1 182 | 1072,0 183 | 1073,1 184 | 1074,1 185 | 1075,0 186 | 1076,1 187 | 1077,0 188 | 1078,1 189 | 1079,0 190 | 1080,0 191 | 1081,0 192 | 1082,0 193 | 1083,0 194 | 1084,0 195 | 1085,0 196 | 1086,1 197 | 1087,0 198 | 1088,1 199 | 1089,1 200 | 1090,0 201 | 1091,1 202 | 1092,0 203 | 1093,0 204 | 1094,0 205 | 1095,1 206 | 1096,0 207 | 1097,1 208 | 1098,0 209 | 1099,0 210 | 1100,1 211 | 1101,0 212 | 1102,0 213 | 1103,0 214 | 1104,0 215 | 1105,0 216 | 1106,0 217 | 1107,0 218 | 1108,0 219 | 1109,0 220 | 1110,1 221 | 1111,0 222 | 1112,1 223 | 1113,0 224 | 1114,1 225 | 1115,0 226 | 1116,1 227 | 1117,1 228 | 1118,0 229 | 1119,0 230 | 1120,0 231 | 1121,0 232 | 1122,1 233 | 1123,1 234 | 1124,0 235 | 1125,0 236 | 1126,1 237 | 1127,0 238 | 1128,0 239 | 1129,1 240 | 1130,1 241 | 1131,1 242 | 1132,1 243 | 1133,0 244 | 1134,0 245 | 1135,0 246 | 1136,0 247 | 1137,0 248 | 1138,1 249 | 1139,0 250 | 1140,1 251 | 1141,1 252 | 1142,1 253 | 1143,0 254 | 1144,1 255 | 1145,0 256 | 1146,0 257 | 1147,0 258 | 1148,0 259 | 1149,0 260 | 1150,1 261 | 1151,0 262 | 1152,0 263 | 1153,0 264 | 1154,1 265 | 1155,1 266 | 1156,1 267 | 1157,0 268 | 1158,0 269 | 1159,0 270 | 1160,1 271 | 1161,1 272 | 1162,1 273 | 1163,0 274 | 1164,1 275 | 1165,0 276 | 1166,1 277 | 1167,1 278 | 1168,0 279 | 1169,0 280 | 1170,0 281 | 1171,0 282 | 1172,1 283 | 1173,0 284 | 1174,0 285 | 1175,1 286 | 1176,1 287 | 1177,0 288 | 1178,0 289 | 1179,0 290 | 1180,1 291 | 1181,0 292 | 1182,0 293 | 1183,0 294 | 1184,1 295 | 1185,0 296 | 1186,0 297 | 1187,0 298 | 1188,1 299 | 1189,1 300 | 1190,1 301 | 1191,0 302 | 1192,0 303 | 1193,1 304 | 1194,0 305 | 1195,0 306 | 1196,0 307 | 1197,0 308 | 1198,0 309 | 1199,1 310 | 1200,0 311 | 1201,0 312 | 1202,1 313 | 1203,1 314 | 1204,0 315 | 1205,0 316 | 1206,1 317 | 1207,0 318 | 1208,0 319 | 1209,0 320 | 1210,0 321 | 1211,0 322 | 1212,0 323 | 1213,1 324 | 1214,0 325 | 1215,0 326 | 1216,1 327 | 1217,0 328 | 1218,1 329 | 1219,1 330 | 1220,0 331 | 1221,1 332 | 1222,0 333 | 1223,1 334 | 1224,1 335 | 1225,1 336 | 1226,0 337 | 1227,0 338 | 1228,0 339 | 1229,1 340 | 1230,0 341 | 1231,1 342 | 1232,1 343 | 1233,0 344 | 1234,0 345 | 1235,1 346 | 1236,0 347 | 1237,1 348 | 1238,0 349 | 1239,1 350 | 1240,0 351 | 1241,1 352 | 1242,1 353 | 1243,1 354 | 1244,0 355 | 1245,0 356 | 1246,1 357 | 1247,0 358 | 1248,0 359 | 1249,0 360 | 1250,0 361 | 1251,0 362 | 1252,0 363 | 1253,1 364 | 1254,1 365 | 1255,0 366 | 1256,1 367 | 1257,0 368 | 1258,1 369 | 1259,1 370 | 1260,1 371 | 1261,1 372 | 1262,1 373 | 1263,1 374 | 1264,0 375 | 1265,0 376 | 1266,0 377 | 1267,1 378 | 1268,0 379 | 1269,1 380 | 1270,0 381 | 1271,0 382 | 1272,0 383 | 1273,0 384 | 1274,1 385 | 1275,0 386 | 1276,0 387 | 1277,1 388 | 1278,0 389 | 1279,0 390 | 1280,0 391 | 1281,0 392 | 1282,1 393 | 1283,0 394 | 1284,0 395 | 1285,0 396 | 1286,0 397 | 1287,1 398 | 1288,0 399 | 1289,1 400 | 1290,0 401 | 1291,0 402 | 1292,1 403 | 1293,0 404 | 1294,1 405 | 1295,0 406 | 1296,0 407 | 1297,1 408 | 1298,0 409 | 1299,0 410 | 1300,0 411 | 1301,1 412 | 1302,0 413 | 1303,0 414 | 1304,1 415 | 1305,0 416 | 1306,1 417 | 1307,0 418 | 1308,0 419 | 1309,1 420 | -------------------------------------------------------------------------------- /practice/jieba_part_of_speech: -------------------------------------------------------------------------------- 1 | a 形容词 (取英语形容词 adjective 的第 1 个字母。) 2 | ad 副形词 (直接作状语的形容词，形容词代码 a 和副词代码 d 并在一起。) 3 | ag 形容词性语素 (形容词性语素，形容词代码为 a，语素代码 ｇ 前面置以 a。) 4 | an 名形词 (具有名词功能的形容词，形容词代码 a 和名词代码 n 并在一起。) 5 | b 区别词 (取汉字「别」的声母。) 6 | c 连词 (取英语连词 conjunction 的第 1 个字母。) 7 | d 副词 (取 adverb 的第 2 个字母，因其第 1 个字母已用于形容词。) 8 | df 副词* 9 | dg 副语素 (副词性语素，副词代码为 d，语素代码 ｇ 前面置以 d。) 10 | e 叹词 (取英语叹词 exclamation 的第 1 个字母。) 11 | eng 外语 12 | f 方位词 (取汉字「方」的声母。) 13 | g 语素 (绝大多数语素都能作为合成词的「词根」，取汉字「根」的声母。) 14 | h 前接成分 (取英语 head 的第 1 个字母。) 15 | i 成语 (取英语成语 idiom 的第 1 个字母。) 16 | j 简称略语 (取汉字「简」的声母。) 17 | k 后接成分 18 | l 习用语 (习用语尚未成为成语，有点「临时性」，取「临」的声母。) 19 | m 数词 (取英语 numeral 的第 3 个字母，n，u 已有他用。) 20 | mg 数语素 21 | mq 数词* 22 | n 名词 (取英语名词 noun 的第 1 个字母。) 23 | ng 名语素 (名词性语素，名词代码为 n，语素代码 ｇ 前面置以 n。) 24 | nr 人名 (名词代码n和「人(ren)」的声母并在一起。) 25 | nrfg 名词* 26 | nrt 名词* 27 | ns 地名 (名词代码 n 和处所词代码 s 并在一起。) 28 | nt 机构团体 (「团」的声母为 t，名词代码 n 和 t 并在一起。) 29 | nz 其他专名 (「专」的声母的第 1 个字母为 z，名词代码 n 和 z 并在一起。) 30 | o 拟声词 (取英语拟声词 onomatopoeia 的第 1 个字母。) 31 | p 介词 (取英语介词 prepositional 的第 1 个字母。) 32 | q 量词 (取英语 quantity 的第 1 个字母。) 33 | r 代词 (取英语代词 pronoun的 第 2 个字母，因 p 已用于介词。) 34 | rg 代词语素 35 | rr 代词* 36 | rz 代词* 37 | s 处所词 (取英语 space 的第 1 个字母。) 38 | t 时间词 (取英语 time 的第 1 个字母。) 39 | tg 时语素 (时间词性语素，时间词代码为 t，在语素的代码 g 前面置以 t。) 40 | u 助词 (取英语助词 auxiliary 的第 2 个字母，因 a 已用于形容词。) 41 | ud 助词* 42 | ug 助词* 43 | uj 助词* 44 | ul 助词* 45 | uv 助词* 46 | uz 助词* 47 | v 动词 (取英语动词 verb 的第一个字母。) 48 | vd 副动词 (直接作状语的动词，动词和副词的代码并在一起。) 49 | vg 动语素 50 | vi 动词* 51 | vn 名动词 (指具有名词功能的动词，动词和名词的代码并在一起。) 52 | vq 动词* 53 | w 标点符号 54 | x 非语素字 (非语素字只是一个符号，字母 x 通常用于代表未知数、符号。) 55 | y 语气词 (取汉字「语」的声母。) 56 | z 状态词 (取汉字「状」的声母的前一个字母。) 57 | zg 状态词* 58 | -------------------------------------------------------------------------------- /practice/linear-regression-practice.md: -------------------------------------------------------------------------------- 1 | # 线性回归模型代码实战（Linear regression practice） 2 | 3 | ## 摘要（brief） 4 | 5 | 使用[python数据分析环境搭建](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/practice/python-environment-install.md)中搭建的python环境，一个线性回归的例子，最后用梯度下降算法做最优化。 6 | 7 | ## 包导入（package import） 8 | 9 | ``` 10 | # %load ../../standard_import.txt 11 | import pandas as pd 12 | import numpy as np 13 | import matplotlib.pyplot as plt 14 | 15 | from sklearn.linear_model import LinearRegression 16 | from mpl_toolkits.mplot3d import axes3d 17 | 18 | pd.set_option('display.notebook_repr_html', False) 19 | pd.set_option('display.max_columns', None) 20 | pd.set_option('display.max_rows', 150) 21 | pd.set_option('display.max_seq_items', None) 22 | 23 | #%config InlineBackend.figure_formats = {'pdf',} 24 | %matplotlib inline 25 | 26 | import seaborn as sns 27 | sns.set_context('notebook') 28 | sns.set_style('white') 29 | ``` 30 | ### 样本集导入（sample set import） 31 | 32 | ``` 33 | # 导入当前目录下的样本集文件linear_regression_data1.txt 34 | # 样本feature之间以逗号分隔 35 | data = np.loadtxt('linear_regression_data1.txt', delimiter=',') 36 | 37 | # features 38 | # np.ones(data.shape[0])是偏执项b 39 | X = np.c_[np.ones(data.shape[0]),data[:,0]] 40 | 41 | # labels 42 | y = np.c_[data[:,1]] 43 | 44 | ``` 45 | 46 | ### 画单变量的样本散点图（plot） 47 | 48 | ``` 49 | plt.scatter(X[:,1], y, s=30, c='r', marker='x', linewidths=1) 50 | plt.xlim(4,24) 51 | plt.xlabel('Population of City in 10,000s') 52 | plt.ylabel('Profit in $10,000s'); 53 | ``` 54 | [更多关于scatter的用法](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/practice/[matplotlib_pyplot/scatter.md) 55 | 56 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/20170527145408.jpg) 57 | 58 | ### 损失函数（loss function） 59 | 60 | 线性回归损失函数： 61 | 62 | ![](http://images.cnitblog.com/blog2015/633472/201503/262045294426265.jpg) 63 | 64 | 代码如下： 65 | 66 | ``` 67 | # 计算损失函数 68 | def computeCost(X, y, theta=[[0],[0]]): 69 | m = y.size 70 | J = 0 71 | 72 |    # dot()函数用于计算矩阵乘法 73 |    h = X.dot(theta) 74 | 75 | J = 1.0/(2*m)*(np.sum(np.square(h-y))) 76 | 77 | return J 78 | ``` 79 | 80 | #### 关于numpy运算: 81 | * *numpy.sum： 82 | [点我跳转查看官方文档](https://docs.scipy.org/doc/numpy/reference/generated/numpy.sum.html#numpy.sum)* 83 | * *numpy.square： 84 | [点我跳转查看官方文档](https://docs.scipy.org/doc/numpy/reference/generated/numpy.square.html#numpy.square)* 85 | * *更多运算请参考： 86 | [点我跳转查看官方文档](https://docs.scipy.org/doc/numpy/reference/routines.math.html)* 87 | 88 | ### 线性回归与梯度下降算法（linear regression and gradient descent） 89 | 90 | #### 公式： 91 | 92 | 根据梯度下降算法的推导公式： 93 | 94 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/20170527192321.jpg) 95 | 96 | ``` 97 | def gradientDescent(X, y, theta=[[0],[0]], alpha=0.01, num_iters=2000): 98 | m = y.size 99 | J_history = np.zeros(num_iters) 100 | for iter in np.arange(num_iters): 101 | h = X.dot(theta) 102 | theta = theta - alpha * (1.0/m) * X.T.dot(h-y) 103 | J_history[iter] = computeCost(X,y,theta) 104 | return (theta, J_history) 105 | ``` 106 | 107 | ### 画出每一次迭代和损失函数变化(plot loss function) 108 | 109 | ``` 110 | # 画出每一次迭代和损失函数变化 111 | theta , Cost_J = gradientDescent(X, y) 112 | print('theta: ',theta.ravel()) 113 | 114 | plt.plot(Cost_J) 115 | plt.ylabel('Cost J') 116 | plt.xlabel('Iterations'); 117 | ``` 118 | 119 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/20170527193711.jpg) 120 | 121 | ### 画出h曲线，并与scikit-learn库中的线性回归对比一下 122 | 123 | ``` 124 | xx = np.arange(5,23) 125 | yy = theta[0]+theta[1]*xx 126 | 127 | # 画出我们自己写的线性回归梯度下降收敛的情况 128 | plt.scatter(X[:,1], y, s=30, c='r', marker='x', linewidths=1) 129 | plt.plot(xx,yy, label='Linear regression (Gradient descent)') 130 | 131 | # 和Scikit-learn中的线性回归对比一下 132 | regr = LinearRegression() 133 | regr.fit(X[:,1].reshape(-1,1), y.ravel()) 134 | plt.plot(xx, regr.intercept_+regr.coef_*xx, label='Linear regression (Scikit-learn GLM)') 135 | 136 | plt.xlim(4,24) 137 | plt.xlabel('Population of City in 10,000s') 138 | plt.ylabel('Profit in $10,000s') 139 | plt.legend(loc=4); 140 | ``` 141 | 142 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/20170527200139.jpg) 143 | 144 | 更多关于scikit-learn LinearRegression 的使用方法： 145 | [点击链接下载](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) 146 | 147 | ### 预测一下(predict) 148 | ``` 149 | # 预测一下人口为35000和70000的城市的结果 150 | print(theta.T.dot([1, 3.5])*10000) 151 | print(theta.T.dot([1, 7])*10000) 152 | ``` 153 | 154 | **预测结果** 155 | [ 4519.7678677] 156 | [ 45342.45012945] 157 | 158 | ### 完整的代码(code download) 159 | [点击链接跳转完整的代码](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/practice/code/linear_regression_practice/linear_regression_practice.ipynb) 160 | -------------------------------------------------------------------------------- /practice/major_task.md: -------------------------------------------------------------------------------- 1 | # 机器学习工程师大部分工作日常 2 | 1. 工作中可能70%的时间处理数据，30%的时间建模、模型状态评估、ensemble。 3 | 2. 算法、模型的研究是一些算法专家、专业人员在做。 4 | 3. 大部分人的工作： 5 | * 1. 跑数据，各种map-reduce, Hive sql，数据库搬砖 6 | * 2. 数据清洗，数据清洗，数据清洗... 7 | * 3.业务分析，分析case， 找特征，找特征... 8 | * 4. 一招LR打天下 （一般机器学习部分都有一个LR作为baseline, 可控； svm在小的数据集上效果很好，但很大的数据，例如电商每天数据很大，不太实用svm） 9 | -------------------------------------------------------------------------------- /practice/matplotlib_pyplot/axis.md: -------------------------------------------------------------------------------- 1 | # axis 2 | 3 | axis()函数给出了形如[xmin,xmax,ymin,ymax]的列表，指定了坐标轴的范围。 4 | 5 | ## example 6 | 7 | ``` 8 | import matplotlib.pyplot as plt 9 | plt.plot([1,2,3,4], [1,4,9,16], 'ro') 10 | plt.axis([0, 6, 0, 20]) 11 | plt.show() 12 | ``` 13 | 14 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/20170601101424.jpg) 15 | -------------------------------------------------------------------------------- /practice/matplotlib_pyplot/content.md: -------------------------------------------------------------------------------- 1 | # Content 2 | 3 | * **[offical_api _doc](http://matplotlib.org/api/pyplot_api.html)** 4 | * **[scatter](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/practice/matplotlib_pyplot/scatter.md)** 5 | * **[axis](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/practice/matplotlib_pyplot/axis.md)** 6 | * **[gca](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/practice/matplotlib_pyplot/axis.md)** 7 | * **[gcf](https://github.com/bobkentt/Learning-machine-from-scratch-/blob/master/practice/matplotlib_pyplot/axis.md)** 8 | -------------------------------------------------------------------------------- /practice/matplotlib_pyplot/gca.md: -------------------------------------------------------------------------------- 1 | # gca & gcf 2 | 3 | pyplot和MATLAB一样，都有当前图像和当前坐标的概念，所有命令都是对当前的坐标进行设置。 4 | 5 | gca()返回当前的坐标实例（a matplotlib.axes.Axes instance），gcf()返回当前图像（matplotlib.figure.Figure instance）。 6 | -------------------------------------------------------------------------------- /practice/matplotlib_pyplot/scatter.md: -------------------------------------------------------------------------------- 1 | # scatter用法 2 | scatter()所绘制的散列图却可以指定每个点的颜色和大小。 3 | 参数说明： 4 | 5 | * scatter()的前两个参数是数组，分别指定每个点的X轴和Y轴的坐标。 6 | * s参数指定点的大小，值和点的面积成正比。它可以是一个数，指定所有点的大小；也可以是数组，分别对每个点指定大小。 7 | * c参数指定每个点的颜色，可以是数值或数组。这里使用一维数组为每个点指定了一个数值。通过颜色映射表，每个数值都会与一个颜色相对应。默认的颜色映射表中蓝色与最小值对应，红色与最大值对应。当c参数是形状为(N,3)或(N,4)的二维数组时，则直接表示每个点的RGB颜色。 8 | * marker参数设置点的形状，可以是个表示形状的字符串，也可以是表示多边形的两个元素的元组，第一个元素表示多边形的边数，第二个元素表示多边形的样式，取值范围为0、1、2、3。0表示多边形，1表示星形，2表示放射形，3表示忽略边数而显示为圆形。 9 | * alpha参数设置点的透明度。 10 | * lw参数设置线宽，lw是line width的缩写。 11 | facecolors参数为“none”时，表示散列点没有填充色。 -------------------------------------------------------------------------------- /practice/ml-hello-world-program.md: -------------------------------------------------------------------------------- 1 | 2 | # ml-hello-world-program 3 | 使用开源库scikit-learn，来写机器学习的第一个hello world程序。 4 | 5 | 6 | 解决的问题是： 7 | > Iris也称鸢尾花卉数据集，是一类多重变量分析的数据集。通过花萼长度，花萼宽度，花瓣长度，花瓣宽度4个属性预测鸢尾花卉属于（Setosa，Versicolour，Virginica）三个种类中的哪一类。 8 | 9 | scikit-learn中刚好提供Iris数据集，也可以去下面地址下载： 10 | 11 | [Iris数据集下载地址](http://archive.ics.uci.edu/ml/datasets/Iris) 12 | 13 | 在scikit-learn中，分类的预测器是一个Python对象，来实现fit(X, y)和predict(T)方法。下面这个预测器的例子是classsklearn.svm.SVC，实现了支持向量机分类 。 14 | 15 | 16 | ``` 17 | #!/usr/bin/env python 18 | # -*- coding: utf-8 -*- 19 | #Author: bobkentt@163.com 20 | #Date: 21 | 22 | from sklearn import svm 23 | from sklearn import datasets 24 | 25 | def main(): 26 | clf = svm.SVC() 27 | iris = datasets.load_iris() 28 | X, y = iris.data, iris.target 29 | clf.fit(X, y) 30 | print(clf.predict([X[0]])) 31 | exit(0) 32 | 33 | 34 | if __name__ == "__main__": 35 | main() 36 | ``` 37 | -------------------------------------------------------------------------------- /practice/mse.md: -------------------------------------------------------------------------------- 1 | # MSE(Mean squared error) 2 | 3 | 4 | [MSE on WIKIPEDIA,click here](https://en.wikipedia.org/wiki/Mean_squared_error) 5 | 6 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/20180106-124829.png) 7 | 8 | -------------------------------------------------------------------------------- /practice/python-environment-install.md: -------------------------------------------------------------------------------- 1 | # python environment install 2 | 3 | ## Python安装配置 4 | * Windows一键安装 5 | * Mac OSX/Linux 6 | * 系统自带，可以通过homebrew（Mac OSX）和pyenv安装维护多个版本。 7 | * pip安装第三方库 8 | * pip install package（Mac在sudo后可能要加—user参数） 9 | * 因为GFW影响，可以采用豆瓣源： pip install package -i --trusted-host http://pypi.douban.com/simple 10 | * Windows专用已编译包下载 11 | 12 | ## Anaconda环境安装和使用 13 | * 安装包下载： https://www.continuum.io/downloads 14 | * 一键安装，别没事挑战自己！ 15 | 优点: 16 | 17 | 省时省心： Anaconda通过管理工具包、开发环境、Python版本，大大简化了你的工作流程。不仅可以方便地安装、更新、卸载工具包，而且安装时能自动安装相应的依赖包，同时还能使用不同的虚拟环境隔离不同要求的项目。 18 | 19 | 分析利器： 在 Anaconda 官网中是这么宣传自己的：适用于企业级大数据分析的Python工具。其包含了720多个数据科学相关的开源包，在数据可视化、机器学习、深度学习等多方面都有涉及。不仅可以做数据分析，甚至可以用在大数据和人工智能领域。 20 | 21 | ## Anaconda常用命令 22 | * 更新包：conda upgrade –all 23 | * 列出已安装包：conda list 24 | * 安装包：conda install package(=version) 25 | * 删除包：conda remove package 26 | * 搜索包名：conda search xxx 27 | 28 | ### 常用工具 29 | * spyder集成环境 30 | * **Jupyter-notebook**网页交互环境 31 | -------------------------------------------------------------------------------- /practice/recommendation_basic_concept.md: -------------------------------------------------------------------------------- 1 | # 推荐系统基本概念(Recommendation system basic concept) 2 | 3 | ## 什么是推荐系统 4 | > 本小节内容摘自[推荐系统实践](http://cache.baiducontent.com/c?m=9d78d513d9d430d94f9c90697d67c0121d4381132ba6a4020fd38439e5732b40506793ac56510774d4d20c1616db4248adb0687d6d4566f5dadf8939c0a6c27572d13034074adb06428045b8cb31749c7f8d1baeff41b0ebb62f90acd7d7d45155c14e&p=8464cc0685cc43f008e2947d07449c&newp=9e78c64ad49918ff57ed97741b4296231610db2151d4d2116b82c825d7331b001c3bbfb423241702d0cf7e620aab4b5aeef73478350221a3dda5c91d9fb4c57479d27e&user=baidu&fm=sc&query=%CD%C6%BC%F6%CF%B5%CD%B3%CA%B5%BC%F9&qid=acdfa27900003142&p1=3) 5 | 6 | 如果想买一包花生米，你有多少种办法？假设附近有一个24小时便利店，你可以走进店里，看看所有的货架，转一圈找到花生米，然后比较几个牌子的口碑或者价格找到自己喜欢的牌子，掏钱付款。如果家附近有一家沃尔玛，你可以走进店里，按照分类指示牌走到食品所在的楼层，接着按照指示牌找到卖干果的货架，然后在货架上仔细寻找你需要的花生米，找到后付款。如果你很懒，不想出门，可以打开当当或者淘宝，在一个叫做搜索框的东西里输入花生米3个字，然后你会看到一堆花生米，找到喜欢的牌子，付费，然后等待送货上门。上面这几个例子描述了用户在有明确需求的情况下，面对信息过载所采用的措施。在24小时便利店，因为店面很小，用户可以凭自己的经验浏览所有货架找到自己需要的东西。在沃尔玛，商品已经被放在无数的货架上，此时用户就需要借用分类信息找到自己需要的商品。而在淘宝或者当当，由于商品数目巨大，用户只能通过搜索引擎找到自己需要的商品。 7 | 8 | 但是，如果用户没有明确的需求呢？比如你今天很无聊，想下载一部电影看看。但当你打开某个下载网站，面对100年来发行的数不胜数的电影，你会手足无措，不知道该看哪一部。此时，你遇到了信息过载的问题，需要一个人或者工具来帮助你做筛选，给出一些建议供你选择。如果这时候有个喜欢看电影的朋友在身边，你可能会请他推荐几部电影。不过，总不能时时刻刻都去麻烦"专家"给你推荐，你需要的是一个自动化的工具，它可以分析你的历史兴趣，从庞大的电影库中找到几部符合你兴趣的电影供你选择。这个工具就是个性化推荐系统。 9 | 10 | 随着信息技术和互联网的发展，人们逐渐从信息匮乏的时代走入了信息过载（information overload）的时代 。在这个时代，无论是信息消费者还是信息生产者都遇到了很大的挑战：对于信息消费者，从大量信息中找到自己感兴趣的信息是一件非常困难的事情；对于信息生产者，让自己生产的信息脱颖而出，受到广大用户的关注，也是一件非常困难的事情。推荐系统就是解决这一矛盾的重要工具。推荐系统的任务就是联系用户和信息，一方面帮助用户发现对自己有价值的信息，另一方面让信息能够展现在对它感兴趣的用户面前，从而实现信息消费者和信息生产者的双赢（如图1-1所示）。（本书后面将信息统称为"物品"，即可以供用户消费的东西。） 11 | 12 | 13 | ![](http://images.51cto.com/files/uploadimg/20120614/1223240.jpg) 14 | 15 | ## 什么是好的推荐系统 16 | 一个完整的推荐系统一般 17 | 存在3个参与方(用户、物品提供者和提供推荐系统的网站), 18 | 在评测一个推荐算法时，需要同时考虑三方的利益， 一个好的推荐系统是能够令三方共赢的系统。 19 | 20 | 好的推荐系统不仅仅能够准确预测用户的行为，而且能够扩展用户的视野，帮助用户 21 | 发现那些他们可能会感兴趣，但却不那么容易发现的东西。同时，推荐系统还要能够帮助商家将那些被埋没在长尾中的好商品介绍给可能会对它们感兴趣的用户。 22 | 23 | 这些 24 | 指标包括**准确度、覆盖度、新颖度、惊喜度、信任度、透明度等**。这些指标中，有些可以离线计算，有些只有在线才能计算，有些只能通过用户问卷获得。 25 | 26 | 在推荐系统 27 | 中，主要有3种评测推荐效果的实验方法，即离线实验(offline experiment)、用户调查(user study) 28 | 和在线实验(online experiment)。 29 | 30 | ### 离线实验 31 | 离线实验的方法一般由如下几个步骤构成: 32 | 1. 通过日志系统获得用户行为数据，并按照一定格式生成一个标准的数据集; 33 | 2. 将数据集按照一定的规则分成训练集和测试集; 34 | 3. 在训练集上训练用户兴趣模型，在测试集上进行预测; 35 | 4. 通过事先定义的离线指标评测算法在测试集上的预测结果。 36 | 从上面的步骤可以看到，推荐系统的离线实验都是在数据集上完成的，也就是说它不需要一 37 | 个实际的系统来供它实验，而只要有一个从实际系统日志中提取的数据集即可。这种实验方法的好处是不需要真实用户参与，可以直接快速地计算出来，从而方便、快速地测试大量不同的算法。 38 | 39 | ## 推荐算法上线步骤 40 | 一般来说，一个新的推荐算法最终上线，需要完成上面所说的3个实验。 41 | 1. 首先，需要通过离线实验证明它在很多离线指标上优于现有的算法。 42 | 2. 然后，需要通过用户调查确定它的用户满意度不低于现有的算法。 43 | 3. 最后，通过在线的AB测试确定它在我们关心的指标上优 44 | 45 | ## 推荐算法的条件 46 | 推荐算法从92年开始，发展到现在也有20年了，当然，也出了各种各样的推荐算法，但是不管怎么样，都绕不开几个条件，这是推荐的基本条件 47 | 48 | 1. 根据和你共同喜好的人来给你推荐； 49 | 2. 根据你喜欢的物品找出和它相似的来给你推荐； 50 | 3. 根据你给出的关键字来给你推荐，这实际上就退化成搜索算法了； 51 | 4. 根据上面的几种条件组合起来给你推荐； 52 | 53 | ## 推荐系统的组成 54 | 尽管不同的网站使用不同的推荐系统技术，但总地来说，几乎所有的推荐系统应用都是由前 55 | 台的展示页面、后台的日志系统以及推荐算法系统3部分构成的。 56 | 57 | 58 | -------------------------------------------------------------------------------- /practice/recommendation_collaborative_filtering.md: -------------------------------------------------------------------------------- 1 | # 协同过滤算法(Collaborative filtering algorithm) 2 | ## 什么是协同过滤算法 3 | 顾名思义，协同过滤就是指用户可以齐心协力，通过不断地和网站互动，使 自己的推荐列表能够不断过滤掉自己不感兴趣的物品，从而越来越满足自己的需求。 4 | 5 | 协同过滤是利用集体智慧的一个典型方法。要理解什么是协同过滤 (Collaborative Filtering, 简称 CF)，首先想一个简单的问题，如果你现在想看个电影，但你不知道具体看哪部，你会怎么做？大部分的人会问问周围的朋友，看看最近有什么好看的电影推荐，而我们一般更倾向于从口味比较类似的朋友那里得到推荐。这就是协同过滤的核心思想。 6 | 7 | 协同过滤一般是在海量的用户中发掘出一小部分和你品位比较类似的，在协同过滤中，这些用户成为邻居，然后根据他们喜欢的其他东西组织成一个排序的目录作为推荐给你。当然其中有一个核心的问题： 8 | 9 | 1. 如何确定一个用户是不是和你有相似的品位？ 10 | 2. 如何将邻居们的喜好组织成一个排序的目录？ 11 | 12 | 协同过滤相对于集体智慧而言，它从一定程度上保留了个体的特征，就是你的品位偏好，所以它更多可以作为个性化推荐的算法思想。可以想象，这种推荐策略在 Web 2.0 的长尾中是很重要的，将大众流行的东西推荐给长尾中的人怎么可能得到好的效果，这也回到推荐系统的一个核心问题：了解你的用户，然后才能给出更好的推荐。 13 | 14 | ## 基于邻域的算法 15 | 基于邻域的算法是推荐系统中最基本的算法。基于邻域的算法分为两大类，一类是基于用户的协同过滤算法，另一类是 基于物品的协同过滤算法。 16 | 17 | ## 基于用户的协同过滤算法 18 | 19 | ### 基于用户的协同过滤算法步骤 20 | 基于用户的协同过滤算法主要包括两个步骤: 21 | 1. 找到和目标用户兴趣相似的用户集合。 22 | 2. 找到这个集合中的用户喜欢的，且目标用户没有听说过的物品推荐给目标用户。 23 | 24 | #### 步骤1 25 | 步骤(1)的关键就是计算两个用户的兴趣相似度。这里，协同过滤算法主要利用行为计算兴趣的相似度。 26 | 27 | 计算相似度的方法主要有： 28 | 1. [余弦相似性，Cosine similarity](https://en.wikipedia.org/wiki/Cosine_similarity)； 29 | 2. [Jaccard similarity](https://en.wikipedia.org/wiki/Jaccard_index)； 30 | 3. 均方根相似度(Mean Squared Difference similarity，msd)其实就是欧式距离； 31 | 4. [Pearson correlation coefficient](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient)； 32 | 33 | 通过计算用户行为间的相似度，从而找到与用户兴趣最相近的K个用户，完成步骤1。 34 | 35 | #### 步骤2 36 | 计算用户u最感兴趣的N个物品（item）： 37 | 1. 找到步骤1获得的K个用户感兴趣的物品集S，V是步骤1找出的K个用户的集合。 38 | 2. 遍历S中的每个物品，计算用户u对该物品的兴趣度。 39 | 3. 兴趣度的计算方法是：sum((Wuv * rvi) for v, rvi in V) for i in S。Wuv表示用户u和用户v的相似度，rvi表示用户v的打分。 40 | ``` 41 | # init S 42 | S = set() 43 | for v in V: 44 | for i in v.items(): 45 | if i not in u.items(): 46 | S.add(i) 47 | # iter S 48 | pui = dict() 49 | for s in S: 50 | for v in V: 51 | rate = v[s.iid]['rate'] 52 | pui[s.iid] += W[u.iid][v.iid]* rate 53 | # 给pui排序，找到topN 54 | ``` 55 | 56 | ## 基于物品的协同过滤(item-based collaborative filtering) 57 | 58 | 随着网站的用户数目越来越大，计算用户兴趣相似度矩阵将越来越困难，其运算时间复杂度和空间复杂度的增长和用户数的增长近似于平方关系。其次，基于用户的协同过滤很难对推荐结果作出解释。 59 | 60 | 61 | 基于物品的协同过滤算法并不利用物品的内容属性计算物品之间的相似度，它主要通过分析用户的行为记录计算物品之间的相似度。该算法认为，物品A和物品B具有很大的相似度是因为喜欢物品A的用户大都也喜欢物品B。 62 | 63 | ### 可解释性 64 | 基于物品的协同过滤算法可以利用用户的历史行为给推荐结果提供推荐解释，比如给用户推荐《天龙八部》的解释可以是因为用户之前喜欢《射雕英雄传》。 65 | 66 | ### 基于物品的协同过滤算法步骤 67 | 基于物品的协同过滤算法主要分为两步。 68 | 1. 计算物品之间的相似度。 69 | 2. 根据物品的相似度和用户的历史行为给用户生成推荐列表。 70 | 71 | #### 步骤1 72 | 可以用下面的公式定义物品的相似度: 73 | 74 | ``` 75 | # Ni 表示喜欢物品i的用户集合 76 | Ni = set() 77 | 78 | # Nj 表示喜欢物品j的用户集合 79 | Nj = set() 80 | 81 | # Wij表示物品i和物品j的相似度 82 | Wij = len(Ni & Nj) / len(Ni) 83 | ``` 84 | 85 | 上述公式虽然看起来很有道理，但是却存在一个问题。如果物品j很热门，很多人都喜欢， 86 | 那么Wij就会很大，接近1。因此，该公式会造成任何物品都会和热门的物品有很大的相似度，这 对于致力于挖掘长尾信息的推荐系统来说显然不是一个好的特性。为了避免推荐出热门的物品， 可以用下面的公式: 87 | 88 | ``` 89 | # Ni 表示喜欢物品i的用户集合 90 | Ni = set() 91 | 92 | # Nj 表示喜欢物品j的用户集合 93 | Nj = set() 94 | 95 | # Wij表示物品i和物品j的相似度 96 | Wij = len(Ni & Nj) / math.sqrt(len(Ni) * len(Nj)) 97 | ``` 98 | 99 | 这个公式惩罚了物品j的权重，因此减轻了热门物品会和很多物品相似的可能性。 100 | 101 | #### 步骤2 102 | 103 | 下图是一个基于物品推荐的简单例子。该例子中，用户喜欢《C++ Primer中文版》和《编程之美》两本书。然后ItemCF会为这两本书分别找出和它们最相似的3本书，然后根据公式的定 义计算用户对每本书的感兴趣程度。比如，ItemCF给用户推荐《算法导论》，是因为这本书和《C++ Primer中文版》相似，相似度为0.4，而且这本书也和《编程之美》相似，相似度是0.5。考虑到用户对《C++ Primer中文版》的兴趣度是1.3，对《编程之美》的兴趣度是0.9，那么用户对《算法导论》的兴趣度就是1.3 × 0.4 + 0.9×0.5 = 0.97。 104 | 105 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/QQ20170823-195556.png) 106 | 107 | ## 基于用户的协同过滤和基于物品的协同过滤的综合比较 108 | 109 | 首先回顾一下UserCF算法和ItemCF算法的推荐原理。UserCF给用户推荐那些和他有共同兴 趣爱好的用户喜欢的物品，而ItemCF给用户推荐那些和他之前喜欢的物品类似的物品。从这个算 法的原理可以看到，UserCF的推荐结果着重于反映和用户兴趣相似的小群体的热点，而ItemCF 的推荐结果着重于维系用户的历史兴趣。换句话说，UserCF的推荐更社会化，反映了用户所在的 6 小型兴趣群体中物品的热门程度，而ItemCF的推荐更加个性化，反映了用户自己的兴趣传承。 110 | 111 | 112 | 113 | 114 | -------------------------------------------------------------------------------- /practice/recommendation_usr_behavior.md: -------------------------------------------------------------------------------- 1 | # 用户行为分析（User behavior analysis） 2 | 3 | ## 用户行为 4 | 用户行为在个性化推荐系统中一般分两种：显性反馈行为(explicit feedback)和隐性反馈行为(implicit feedback)。 5 | 6 | 1. **显性反馈行为**包括用户明确表示对物品喜好的行为。 7 | 2. **隐性反馈行为**指的是那些不能明确反应用户喜好的行为。最具代表性的隐性反馈行为就是页面浏览行为。用户浏览一个物品的页面并不代表用户一定喜欢这个页面展示的物品，比如可能因为这个页面链接显示在首页，用户更容易点击它而已。 8 | 9 | ### 长尾分布 10 | 用户活跃度图和物品流行度图： 11 | 12 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/578330-20170515202604807-603603790.png) 13 | 14 | **用户活跃度与物品流行度的关系:** 15 | **用户越活跃，越倾向于浏览冷门的物品。** 16 | 17 | 18 | -------------------------------------------------------------------------------- /practice/rmse_mae.md: -------------------------------------------------------------------------------- 1 | # RMSE and MAE 2 | 评分预测的预测准确度一般通过均方根误差(RMSE)和平均绝对误差(MAE)计算。 3 | 4 | records[i] = [u,i,rui,pui] 5 | 6 | * 对于测试集中的一个用户u和物品i； 7 | * rui表示用户u对物品i的实际评分； 8 | * pui表示推荐算法给出的预测评； 9 | 10 | 如下代码可以计算RMSE和MAE： 11 | 12 | ``` 13 | def RMSE(records): 14 | return math.sqrt(\ 15 | sum([(rui-pui)*(rui-pui) for u,i,rui,pui in records])\ 16 | / float(len(records))) 17 | def MAE(records): 18 | return sum([abs(rui-pui) for u,i,rui,pui in records])\ 19 | / float(len(records)) 20 | ``` 21 | -------------------------------------------------------------------------------- /practice/tensorflow/.ipynb_checkpoints/a_nn_by_tensorflow-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 2 6 | } 7 | -------------------------------------------------------------------------------- /practice/tensorflow/Softmax_with_tensorflow.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Softmax" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "解决分类问题里最普遍的baseline model就是逻辑回归，简单同时可解释性好，使得它大受欢迎，我们来用tensorflow完成这个模型的搭建。" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 1, 20 | "metadata": {}, 21 | "outputs": [ 22 | { 23 | "name": "stderr", 24 | "output_type": "stream", 25 | "text": [ 26 | "/Users/bobkentt/anaconda/lib/python3.6/site-packages/h5py/__init__.py:34: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n", 27 | " from ._conv import register_converters as _register_converters\n" 28 | ] 29 | } 30 | ], 31 | "source": [ 32 | "import os\n", 33 | "os.environ['TF_CPP_MIN_LOG_LEVEL']='2'\n", 34 | "\n", 35 | "import numpy as np\n", 36 | "import tensorflow as tf\n", 37 | "from tensorflow.examples.tutorials.mnist import input_data\n", 38 | "import time" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": {}, 44 | "source": [ 45 | "# 1.读取数据" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 3, 51 | "metadata": {}, 52 | "outputs": [ 53 | { 54 | "name": "stdout", 55 | "output_type": "stream", 56 | "text": [ 57 | "Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.\n", 58 | "Extracting ./data/mnist/train-images-idx3-ubyte.gz\n", 59 | "Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.\n", 60 | "Extracting ./data/mnist/train-labels-idx1-ubyte.gz\n", 61 | "Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.\n", 62 | "Extracting ./data/mnist/t10k-images-idx3-ubyte.gz\n", 63 | "Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.\n", 64 | "Extracting ./data/mnist/t10k-labels-idx1-ubyte.gz\n" 65 | ] 66 | } 67 | ], 68 | "source": [ 69 | "#使用tensorflow自带的工具加载MNIST手写数字集合\n", 70 | "mnist = input_data.read_data_sets('./data/mnist', one_hot=True) " 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": 4, 76 | "metadata": {}, 77 | "outputs": [ 78 | { 79 | "data": { 80 | "text/plain": [ 81 | "(55000, 784)" 82 | ] 83 | }, 84 | "execution_count": 4, 85 | "metadata": {}, 86 | "output_type": "execute_result" 87 | } 88 | ], 89 | "source": [ 90 | "#查看一下数据维度\n", 91 | "mnist.train.images.shape" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": 5, 97 | "metadata": {}, 98 | "outputs": [ 99 | { 100 | "data": { 101 | "text/plain": [ 102 | "(55000, 10)" 103 | ] 104 | }, 105 | "execution_count": 5, 106 | "metadata": {}, 107 | "output_type": "execute_result" 108 | } 109 | ], 110 | "source": [ 111 | "#查看target维度\n", 112 | "mnist.train.labels.shape" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "# 2.准备好placeholder" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 6, 125 | "metadata": { 126 | "collapsed": true 127 | }, 128 | "outputs": [], 129 | "source": [ 130 | "batch_size = 128\n", 131 | "X = tf.placeholder(tf.float32, [batch_size, 784], name='X_placeholder') \n", 132 | "Y = tf.placeholder(tf.int32, [batch_size, 10], name='Y_placeholder')" 133 | ] 134 | }, 135 | { 136 | "cell_type": "markdown", 137 | "metadata": {}, 138 | "source": [ 139 | "# 3.准备好参数/权重" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 7, 145 | "metadata": { 146 | "collapsed": true 147 | }, 148 | "outputs": [], 149 | "source": [ 150 | "w = tf.Variable(tf.random_normal(shape=[784, 10], stddev=0.01), name='weights')\n", 151 | "b = tf.Variable(tf.zeros([1, 10]), name=\"bias\")" 152 | ] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "metadata": {}, 157 | "source": [ 158 | "# 4.拿到每个类别的score" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 9, 164 | "metadata": { 165 | "collapsed": true 166 | }, 167 | "outputs": [], 168 | "source": [ 169 | "logits = tf.matmul(X, w) + b " 170 | ] 171 | }, 172 | { 173 | "cell_type": "markdown", 174 | "metadata": {}, 175 | "source": [ 176 | "# 5.计算多分类softmax的loss function" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": 10, 182 | "metadata": {}, 183 | "outputs": [ 184 | { 185 | "name": "stdout", 186 | "output_type": "stream", 187 | "text": [ 188 | "WARNING:tensorflow:From :2: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n", 189 | "Instructions for updating:\n", 190 | "\n", 191 | "Future major versions of TensorFlow will allow gradients to flow\n", 192 | "into the labels input on backprop by default.\n", 193 | "\n", 194 | "See tf.nn.softmax_cross_entropy_with_logits_v2.\n", 195 | "\n" 196 | ] 197 | } 198 | ], 199 | "source": [ 200 | "# 求交叉熵损失\n", 201 | "entropy = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=Y, name='loss')\n", 202 | "# 求平均\n", 203 | "loss = tf.reduce_mean(entropy)" 204 | ] 205 | }, 206 | { 207 | "cell_type": "markdown", 208 | "metadata": {}, 209 | "source": [ 210 | "# 6.准备好optimizer\n", 211 | "这里的最优化用的是随机梯度下降，我们可以选择AdamOptimizer这样的优化器\n", 212 | "\n" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": 13, 218 | "metadata": { 219 | "collapsed": true 220 | }, 221 | "outputs": [], 222 | "source": [ 223 | "learning_rate = 0.01\n", 224 | "optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss)" 225 | ] 226 | }, 227 | { 228 | "cell_type": "markdown", 229 | "metadata": {}, 230 | "source": [ 231 | "# 7.在session里执行graph里定义的运算" 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": 14, 237 | "metadata": {}, 238 | "outputs": [ 239 | { 240 | "name": "stdout", 241 | "output_type": "stream", 242 | "text": [ 243 | "Average loss epoch 0: 0.3679797322877915\n", 244 | "Average loss epoch 1: 0.2941511491170296\n", 245 | "Average loss epoch 2: 0.2857012886093769\n", 246 | "Average loss epoch 3: 0.2794165320885487\n", 247 | "Average loss epoch 4: 0.277245612775946\n", 248 | "Average loss epoch 5: 0.27178016275445344\n", 249 | "Average loss epoch 6: 0.2684775417744419\n", 250 | "Average loss epoch 7: 0.2708571720303911\n", 251 | "Average loss epoch 8: 0.26886305112244085\n", 252 | "Average loss epoch 9: 0.26571589656226285\n", 253 | "Average loss epoch 10: 0.26095397277172905\n", 254 | "Average loss epoch 11: 0.26094754422322297\n", 255 | "Average loss epoch 12: 0.26137401816589295\n", 256 | "Average loss epoch 13: 0.2608616345481717\n", 257 | "Average loss epoch 14: 0.26102534770131947\n", 258 | "Average loss epoch 15: 0.25903657868956076\n", 259 | "Average loss epoch 16: 0.2572681684142504\n", 260 | "Average loss epoch 17: 0.2610346191412919\n", 261 | "Average loss epoch 18: 0.25714351467805585\n", 262 | "Average loss epoch 19: 0.25624754731402255\n", 263 | "Average loss epoch 20: 0.25276912375416233\n", 264 | "Average loss epoch 21: 0.25517509730059507\n", 265 | "Average loss epoch 22: 0.25551578913118456\n", 266 | "Average loss epoch 23: 0.2571979035516997\n", 267 | "Average loss epoch 24: 0.2539537578195959\n", 268 | "Average loss epoch 25: 0.25475832040145957\n", 269 | "Average loss epoch 26: 0.2552412986790106\n", 270 | "Average loss epoch 27: 0.2529415577858478\n", 271 | "Average loss epoch 28: 0.25343086338647597\n", 272 | "Average loss epoch 29: 0.25248326906513224\n", 273 | "Total time: 21.735208988189697 seconds\n", 274 | "Optimization Finished!\n", 275 | "Accuracy 0.918\n" 276 | ] 277 | } 278 | ], 279 | "source": [ 280 | "#迭代总轮次\n", 281 | "n_epochs = 30\n", 282 | "\n", 283 | "with tf.Session() as sess:\n", 284 | "\t# 在Tensorboard里可以看到图的结构\n", 285 | "\twriter = tf.summary.FileWriter('./graphs/logistic_reg', sess.graph)\n", 286 | "\n", 287 | "\tstart_time = time.time()\n", 288 | "\tsess.run(tf.global_variables_initializer())\t\n", 289 | "\tn_batches = int(mnist.train.num_examples/batch_size)\n", 290 | "\tfor i in range(n_epochs): # 迭代这么多轮\n", 291 | "\t\ttotal_loss = 0\n", 292 | "\n", 293 | "\t\tfor _ in range(n_batches):\n", 294 | "\t\t\tX_batch, Y_batch = mnist.train.next_batch(batch_size)\n", 295 | "\t\t\t_, loss_batch = sess.run([optimizer, loss], feed_dict={X: X_batch, Y:Y_batch}) \n", 296 | "\t\t\ttotal_loss += loss_batch\n", 297 | "\t\tprint('Average loss epoch {0}: {1}'.format(i, total_loss/n_batches))\n", 298 | "\n", 299 | "\tprint('Total time: {0} seconds'.format(time.time() - start_time))\n", 300 | "\n", 301 | "\tprint('Optimization Finished!')\n", 302 | "\n", 303 | "\t# 测试模型\n", 304 | "\t\n", 305 | "\tpreds = tf.nn.softmax(logits)\n", 306 | "\tcorrect_preds = tf.equal(tf.argmax(preds, 1), tf.argmax(Y, 1))\n", 307 | "\taccuracy = tf.reduce_sum(tf.cast(correct_preds, tf.float32))\n", 308 | "\t\n", 309 | "\tn_batches = int(mnist.test.num_examples/batch_size)\n", 310 | "\ttotal_correct_preds = 0\n", 311 | "\t\n", 312 | "\tfor i in range(n_batches):\n", 313 | "\t\tX_batch, Y_batch = mnist.test.next_batch(batch_size)\n", 314 | "\t\taccuracy_batch = sess.run([accuracy], feed_dict={X: X_batch, Y:Y_batch}) \n", 315 | "\t\ttotal_correct_preds += accuracy_batch[0]\n", 316 | "\t\n", 317 | "\tprint('Accuracy {0}'.format(total_correct_preds/mnist.test.num_examples))\n", 318 | "\n", 319 | "\twriter.close()" 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": null, 325 | "metadata": { 326 | "collapsed": true 327 | }, 328 | "outputs": [], 329 | "source": [] 330 | } 331 | ], 332 | "metadata": { 333 | "kernelspec": { 334 | "display_name": "Python 3", 335 | "language": "python", 336 | "name": "python3" 337 | }, 338 | "language_info": { 339 | "codemirror_mode": { 340 | "name": "ipython", 341 | "version": 3 342 | }, 343 | "file_extension": ".py", 344 | "mimetype": "text/x-python", 345 | "name": "python", 346 | "nbconvert_exporter": "python", 347 | "pygments_lexer": "ipython3", 348 | "version": "3.6.1" 349 | } 350 | }, 351 | "nbformat": 4, 352 | "nbformat_minor": 2 353 | } 354 | -------------------------------------------------------------------------------- /practice/tensorflow/a_nn_by_tensorflow.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stderr", 10 | "output_type": "stream", 11 | "text": [ 12 | "/Users/bobkentt/anaconda/lib/python3.6/site-packages/h5py/__init__.py:34: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n", 13 | " from ._conv import register_converters as _register_converters\n" 14 | ] 15 | } 16 | ], 17 | "source": [ 18 | "import numpy as np\n", 19 | "import tensorflow as tf\n", 20 | "from tensorflow.examples.tutorials.mnist import input_data\n", 21 | "import time" 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 | "Extracting ./data/mnist/train-images-idx3-ubyte.gz\n", 34 | "Extracting ./data/mnist/train-labels-idx1-ubyte.gz\n", 35 | "Extracting ./data/mnist/t10k-images-idx3-ubyte.gz\n", 36 | "Extracting ./data/mnist/t10k-labels-idx1-ubyte.gz\n" 37 | ] 38 | } 39 | ], 40 | "source": [ 41 | "#使用tensorflow自带的工具加载MNIST手写数字集合\n", 42 | "mnist = input_data.read_data_sets('./data/mnist', one_hot=True) " 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": 3, 48 | "metadata": {}, 49 | "outputs": [ 50 | { 51 | "data": { 52 | "text/plain": [ 53 | "(55000, 784)" 54 | ] 55 | }, 56 | "execution_count": 3, 57 | "metadata": {}, 58 | "output_type": "execute_result" 59 | } 60 | ], 61 | "source": [ 62 | "#查看一下数据维度\n", 63 | "mnist.train.images.shape" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 4, 69 | "metadata": {}, 70 | "outputs": [ 71 | { 72 | "data": { 73 | "text/plain": [ 74 | "(55000, 10)" 75 | ] 76 | }, 77 | "execution_count": 4, 78 | "metadata": {}, 79 | "output_type": "execute_result" 80 | } 81 | ], 82 | "source": [ 83 | "#查看target维度\n", 84 | "mnist.train.labels.shape" 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": 6, 90 | "metadata": { 91 | "collapsed": true 92 | }, 93 | "outputs": [], 94 | "source": [ 95 | "X = tf.placeholder(tf.float32, [None, 784], name='X_placeholder') \n", 96 | "Y = tf.placeholder(tf.int32, [None, 10], name='Y_placeholder')" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": 7, 102 | "metadata": { 103 | "collapsed": true 104 | }, 105 | "outputs": [], 106 | "source": [ 107 | "# 网络参数\n", 108 | "n_hidden_1 = 256 # 第1个隐层\n", 109 | "n_hidden_2 = 256 # 第2个隐层\n", 110 | "n_input = 784 # MNIST 数据输入(28*28*1=784)\n", 111 | "n_classes = 10 # MNIST 总共10个手写数字类别\n", 112 | "\n", 113 | "weights = {\n", 114 | " 'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1]), name='W1'),\n", 115 | " 'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2]), name='W2'),\n", 116 | " 'out': tf.Variable(tf.random_normal([n_hidden_2, n_classes]), name='W')\n", 117 | "}\n", 118 | "biases = {\n", 119 | " 'b1': tf.Variable(tf.random_normal([n_hidden_1]), name='b1'),\n", 120 | " 'b2': tf.Variable(tf.random_normal([n_hidden_2]), name='b2'),\n", 121 | " 'out': tf.Variable(tf.random_normal([n_classes]), name='bias')\n", 122 | "}" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 8, 128 | "metadata": { 129 | "collapsed": true 130 | }, 131 | "outputs": [], 132 | "source": [ 133 | "def multilayer_perceptron(x, weights, biases):\n", 134 | " # 第1个隐层，使用relu激活函数\n", 135 | " layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'], name='fc_1')\n", 136 | " layer_1 = tf.nn.relu(layer_1, name='relu_1')\n", 137 | " # 第2个隐层，使用relu激活函数\n", 138 | " layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2'], name='fc_2')\n", 139 | " layer_2 = tf.nn.relu(layer_2, name='relu_2')\n", 140 | " # 输出层\n", 141 | " out_layer = tf.add(tf.matmul(layer_2, weights['out']), biases['out'], name='fc_3')\n", 142 | " return out_layer" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": 9, 148 | "metadata": { 149 | "collapsed": true 150 | }, 151 | "outputs": [], 152 | "source": [ 153 | "pred = multilayer_perceptron(X, weights, biases)" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": 10, 159 | "metadata": {}, 160 | "outputs": [ 161 | { 162 | "name": "stdout", 163 | "output_type": "stream", 164 | "text": [ 165 | "WARNING:tensorflow:From :2: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n", 166 | "Instructions for updating:\n", 167 | "\n", 168 | "Future major versions of TensorFlow will allow gradients to flow\n", 169 | "into the labels input on backprop by default.\n", 170 | "\n", 171 | "See tf.nn.softmax_cross_entropy_with_logits_v2.\n", 172 | "\n" 173 | ] 174 | } 175 | ], 176 | "source": [ 177 | "learning_rate = 0.001\n", 178 | "loss_all = tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=Y, name='cross_entropy_loss')\n", 179 | "loss = tf.reduce_mean(loss_all, name='avg_loss')\n", 180 | "optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss)" 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": 11, 186 | "metadata": { 187 | "collapsed": true 188 | }, 189 | "outputs": [], 190 | "source": [ 191 | "init = tf.global_variables_initializer()" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 12, 197 | "metadata": {}, 198 | "outputs": [ 199 | { 200 | "name": "stdout", 201 | "output_type": "stream", 202 | "text": [ 203 | "Epoch: 0001 cost= 172.808340357\n", 204 | "Epoch: 0002 cost= 43.471657182\n", 205 | "Epoch: 0003 cost= 27.427986258\n", 206 | "Epoch: 0004 cost= 19.661114889\n", 207 | "Epoch: 0005 cost= 14.475002144\n", 208 | "Epoch: 0006 cost= 11.059448785\n", 209 | "Epoch: 0007 cost= 8.493773243\n", 210 | "Epoch: 0008 cost= 6.370333782\n", 211 | "Epoch: 0009 cost= 4.822890971\n", 212 | "Epoch: 0010 cost= 3.663321695\n", 213 | "Epoch: 0011 cost= 2.818840031\n", 214 | "Epoch: 0012 cost= 2.061833691\n", 215 | "Epoch: 0013 cost= 1.632366778\n", 216 | "Epoch: 0014 cost= 1.238681466\n", 217 | "Epoch: 0015 cost= 0.994031222\n", 218 | "Optimization Finished!\n", 219 | "Accuracy: 0.9422\n" 220 | ] 221 | } 222 | ], 223 | "source": [ 224 | "#训练总轮数\n", 225 | "training_epochs = 15\n", 226 | "#一批数据大小\n", 227 | "batch_size = 128\n", 228 | "#信息展示的频度\n", 229 | "display_step = 1\n", 230 | "\n", 231 | "with tf.Session() as sess:\n", 232 | " sess.run(init)\n", 233 | " writer = tf.summary.FileWriter('./graphs/MLP_DNN', sess.graph)\n", 234 | "\n", 235 | " # 训练\n", 236 | " for epoch in range(training_epochs):\n", 237 | " avg_loss = 0.\n", 238 | " total_batch = int(mnist.train.num_examples/batch_size)\n", 239 | " # 遍历所有的batches\n", 240 | " for i in range(total_batch):\n", 241 | " batch_x, batch_y = mnist.train.next_batch(batch_size)\n", 242 | " # 使用optimizer进行优化\n", 243 | " _, l = sess.run([optimizer, loss], feed_dict={X: batch_x, Y: batch_y})\n", 244 | " # 求平均的损失\n", 245 | " avg_loss += l / total_batch\n", 246 | " # 每一步都展示信息\n", 247 | " if epoch % display_step == 0:\n", 248 | " print(\"Epoch:\", '%04d' % (epoch+1), \"cost=\", \\\n", 249 | " \"{:.9f}\".format(avg_loss))\n", 250 | " print(\"Optimization Finished!\")\n", 251 | "\n", 252 | " # 在测试集上评估\n", 253 | " correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(Y, 1))\n", 254 | " # 计算准确率\n", 255 | " accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n", 256 | " print(\"Accuracy:\", accuracy.eval({X: mnist.test.images, Y: mnist.test.labels}))\n", 257 | " writer.close()" 258 | ] 259 | }, 260 | { 261 | "cell_type": "code", 262 | "execution_count": null, 263 | "metadata": { 264 | "collapsed": true 265 | }, 266 | "outputs": [], 267 | "source": [] 268 | } 269 | ], 270 | "metadata": { 271 | "kernelspec": { 272 | "display_name": "Python 3", 273 | "language": "python", 274 | "name": "python3" 275 | }, 276 | "language_info": { 277 | "codemirror_mode": { 278 | "name": "ipython", 279 | "version": 3 280 | }, 281 | "file_extension": ".py", 282 | "mimetype": "text/x-python", 283 | "name": "python", 284 | "nbconvert_exporter": "python", 285 | "pygments_lexer": "ipython3", 286 | "version": "3.6.1" 287 | } 288 | }, 289 | "nbformat": 4, 290 | "nbformat_minor": 2 291 | } 292 | -------------------------------------------------------------------------------- /practice/tensorflow/data/mnist/t10k-images-idx3-ubyte.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/practice/tensorflow/data/mnist/t10k-images-idx3-ubyte.gz -------------------------------------------------------------------------------- /practice/tensorflow/data/mnist/t10k-labels-idx1-ubyte.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/practice/tensorflow/data/mnist/t10k-labels-idx1-ubyte.gz -------------------------------------------------------------------------------- /practice/tensorflow/data/mnist/train-images-idx3-ubyte.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/practice/tensorflow/data/mnist/train-images-idx3-ubyte.gz -------------------------------------------------------------------------------- /practice/tensorflow/data/mnist/train-labels-idx1-ubyte.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bobkentt/Learning-machine-from-scratch-/de70b8150d0bda6da24aaec358efac4c53b84555/practice/tensorflow/data/mnist/train-labels-idx1-ubyte.gz -------------------------------------------------------------------------------- /practice/todolist.md: -------------------------------------------------------------------------------- 1 | # Todolist 2 | ## Questions: 3 | 1. Project complexity 4 | 2. ML alg test 5 | 3. Data struct 6 | 4. Program base 7 | 8 | 9 | 10 | 11 | ## Todo: 12 | 0. GRU 13 | 1. **Attention is all you need** Completed deep Understanding by 24th Feb 14 | 2. **NLP gift by datafun** Completed 1th March 15 | 2. **BERT principle and pretrain** Completed 2th March 16 | 3. **dual encoder train** Completed 8th March 17 | 5. **More Deeplearning demo** Completed 8th March 18 | 6. 2ML alg test and 2 Data struct test every day 19 | 20 | ## Finished 21 | Keras turial: 22 | 1. classifier with keras: 23 | * Sequential model; 24 | * Layer:Dense,Activation,Convolution2D, MaxPooling2D, Flatten 25 | * Training op:SGD,Montentum,Adagrad,RMSprop,Adam 26 | * model.summary 27 | * functional API 28 | 29 | 30 | -------------------------------------------------------------------------------- /practice/tuning_e1.md: -------------------------------------------------------------------------------- 1 | # 一个CNN调参的例子 2 | 3 | ![](https://github.com/bobkentt/Learning-machine-from-scratch-pic/blob/master/practice/pic/20170717.png) 4 | 5 | > loss function 下降的更线性，应该把learning rate调高，损失函数下降快，反之下降慢； 6 | 7 | > loss function 震荡，因为使用SGD，顾应该把data set调大，减少震挡，（data set调大，容易memory out） 8 | 9 | > training and valication accuracy的差距小，所以表现为欠拟合，应该增大model capacity，例如增加neural nodes or hidden neural layer。 10 | -------------------------------------------------------------------------------- /practice/user_portrait.md: -------------------------------------------------------------------------------- 1 | # 用户画像(user portrait) 2 | --------------------------------------------------------------------------------