逼疯懒癌：“机器学习100天大作战”正式开始！

AI科技大本营

发布于 2018-08-17 15:04:56

8500

发布于 2018-08-17 15:04:56

文章被收录于专栏：AI科技大本营的专栏AI科技大本营的专栏

作者 | Avik-Hain

译者 | linstancy

编辑 | Jane

出品 | AI 科技大本营

机器学习已经成为人工智能中发展最快，应用最广、最重要的分支之一。但是这条学习之路似乎并不是那么容易，也不总是一帆风顺的。

相信每一个学习机器学习的小伙伴都码过不少的学习资源，无论是在线课程还是大佬们整理的学习PPT，但是看的速度远不及码的速度；有的同学数学基础比较差，就想先把数学补足再学习，但是往往数学也没补上来，机器学习还没开始就已经放弃了；还有很多同学看到现在深度学习声势最盛，直接学习深度学习，结果发现学习到的内容也像空中楼阁，不扎实。

无论是数学知识、经典与重要的算法还是编码实践，每天都会有人在路上败下阵来而放弃学习，仿佛我们永远都停留在入门阶段。

其实机器学习涵盖的知识面非常多，而且不仅要学习理论还有实践同样不能忽视。如果基础薄弱，学习起来肯定是会遇到很多困难的，但就一定不行吗？如何在基础薄弱的条件下进行有效的学习是很多人都非常关心的。至此 AI 科技大本营特此根据作者 Avik-Hain 的博客为大家精心准备了“机器学习百天大作战”的系列学习计划与教程，从理论与实践结合，在100天左右的时间里从理论＋实践结合的方式，有条理有逻辑的帮助大家完成入门，助攻进阶。相信大家一定可以受益颇多！

本期内容是此系列的第一期，主要内容有：

数据处理的实践流程
简单的线性回归与实现
多元线性回归与实践
Logistic 回归及实践
支持向量机 SVM 及其实现
KNN 算法与实现
决策树模型与实现

Day 1

数据处理

机器学习中的数据处理实践流程主要如下：

第一步：导入所需的库。Numpy 和 Pandas 是两个必需的，也是最基本的数据处理库。

import numpy as np
import pandas as pd

第二步：导入数据集。数据集通常是 .csv 的格式。一个 csv 文件能够储存表格数据，每行都代表一条数据，我们可以使用 Pandas 中的 read_csv 方法来读取 csv 文件并将其作为 dataframe 处理。随后，我们可以将 dataframe 中的矩阵、向量和标量分离开来单独处理。

dataset = pd.read_csv('Data.csv')
X = dataset.iloc[ : , :-1].values
Y = dataset.iloc[ : , 3].values

第三步：处理缺失数据。数据通常会因为一些原因而缺失，我们需要对其进行处理以便其不会对机器学习模型的性能造成影响。我们可以通过对整列数据进行平均化或中值化来填补缺失数据，这可以通过 sklearn.preprocessing 中的 Imputer 类方法来解决这个问题。

from sklearn.preprocessing import Imputer
imputer = Imputer(missing_values = "NaN", strategy = "mean", axis = 0)
imputer = imputer.fit(X[ : , 1:3])
X[ : , 1:3] = imputer.transform(X[ : , 1:3])

第四步：编码类数据。类数据是一个包含标签值的变量，通常它们被限制在一个固定的集合中。例如，‘Yes’ 或 ‘No’ 是无法用于模型中的数学表达式，因此我们需要对这些类数据进行编码，将其转化为数值。我们可以通过 sklearn.preprocessing 中的 LabelEncoder 类方法来解决这个问题。

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder_X = LabelEncoder()
X[ : , 0] = labelencoder_X.fit_transform(X[ : , 0])

第五步：将数据集分离为训练集和测试集。在机器学习中，我们通常需要对源数据集进行处理，以便分离出训练集和测试集，分别用于模型的训练和测试。通常所使用的分离比为8:2，我们可以通过导入 sklearn.crossvalidation 库的 train_test_split() 方法来解决这个问题。

from sklearn.cross_validation import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split( X , Y , test_size = 0.2, random_state = 0)

第六步：特征缩放。大多数机器学习算法会采用欧式距离，来衡量两个数据点特征变化情况。相比于低量级的特征，高量级的特征会在距离计算中占更大的权重。可以通过特征标准化或 Z 分数正则化来解决，我们可以导入 sklearn.preprocessing 库的 StandardScalar 方法。

from sklearn.preprocessing import StandardScaler
sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.fit_transform(X_test)

Day 2

简单的线性回归

▌简单的线性回归模型

使用单个特征来预测结果。在这种回归模型中，我们尝试最小化预测值和真实值之间的损失，来得到最佳的拟合性能。

▌线性回归的实现

第一步：数据预处理。回归模型中的数据预处理过程遵循上述的数据处理流程，主要包括导入所需的库，导入所需的数据集，检查缺失数据，分离数据集以及特征缩放。

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

dataset = pd.read_csv('studentscores.csv')
X = dataset.iloc[ : ,   : 1 ].values
Y = dataset.iloc[ : , 1 ].values

from sklearn.cross_validation import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split( X, Y, test_size = 1/4, random_state = 0)

第二步：用训练数据拟合简单的线性回归模型。首先，我们导入 sklearn.linear_model 中的 LinearRegression 类。然后，我们为目标 regressor 创建一个 LinearRegression 类。现在，我们可以使用 LinearRegression 类的 fit() 方法来用训练数据去拟合我们的目标 regressor。

from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor = regressor.fit(X_train, Y_train)

第三步：预测结果。使用我们训练好的模型，在测试集上预测我们的结果。首先，我们为预测结果创建一个向量 Y-pred。然后，我们对训练好的 regressor 使用 LinearRegression 类的预测方法来进行预测。

Y_pred = regressor.predict(X_test)

第四步：可视化。最后一步是可视化最后的结果，我们可以采用 matplotlib.pyplot 库来为模型的训练结果和测试结果做出散点图，可视化模型的预测结果。

plt.scatter(X_train , Y_train, color = 'red')
plt.plot(X_train , regressor.predict(X_train), color ='blue')

plt.scatter(X_test , Y_test, color = 'red')
plt.plot(X_test , regressor.predict(X_test), color ='blue')

Day 3

多元线性回归

▌多元线性回归模型

旨在通过拟合一个线性等式，探究两个或多个特征变量之间的关系。多元线性回归的处理步骤与简单线性回归的流程大致相似，不同就在于模型评估处理。由于多个变量对最终预测结果的影响是不同的，因此我们可以进一步评估对模型影响最大的变量以及各变量之间的相互关系。一个好的多元线性回归模型需要满足以下几个条件：

线性：不论是独立还是非独立的变量，它们之间的关系都应该是线性的。
方差齐性 (Homoscedasticity)：常量间误差要始终存在。
多元正态性 (Multivariate Normality)：多元回归假设变量之间的残差服从正态分布。
缺乏多重性 (Lack of Multicollinearity)：这里假设数据间不存在多重性。只有当特征或变量之间独立时才存在多重性。

此外，多元回归模型中使用的类数据是处理非数值数据类型非常有效的手段。类数据通常涉及一些表示类别数值的数据，如性别(男/女)。在回归模型中，这些数值通常可以被表示为哑变量，即用1或0代表类别数据出现或不出现。此外，对于两个类数据之间存在相关性的问题，我们通常降低一个类别数量，以便正常使用回归模型。

▌深入多元线性回归

第一步：数据预处理

导入库、导入数据集、编码分类数据、分离数据为训练集和测试集

import pandas as pd
import numpy as np

dataset = pd.read_csv('50_Startups.csv')
X = dataset.iloc[ : , :-1].values
Y = dataset.iloc[ : ,  4 ].values

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder = LabelEncoder()
X[: , 3] = labelencoder.fit_transform(X[ : , 3])
onehotencoder = OneHotEncoder(categorical_features = [3])
X = onehotencoder.fit_transform(X).toarray()

X = X[: , 1:]

from sklearn.cross_validation import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.2, random_state = 0)

第二步：将多个线性回归拟合到训练集

from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train, Y_train)

第三步：预测测试集结果

y_pred = regressor.predict(X_test)

Day 4、5、6

Logistic 回归与深入实践

这部分将深入研究 Logistic 回归模型，包括它背后的数学原理，如何计算成本函数，以及如何将梯度下降算法应用于成本函数以最小化预测误差等内容。

▌Logistic 回归

Logistic 回归通常用于不同类别的分类问题，旨在通过观察现有目标类预测所属的类别。通常所给的是离散的二值数据，介于0和1之间。Logistic 回归最常见的例子是在选举期间民众的投票情况。

Logistic 回归模型采用潜在的 logistic 函数得到估计概率值，来衡量独立变量 (通常使我们要预测的标签值) 与一个或多个非独立变量 (我们的特征值) 之间的关系。Logistic 函数，也被称为 sigmoid 函数，这是一个 S 型曲线函数，它能够将估计的概率值转换为二进制值0或1，以便模型预测得到结果。

与线性回归模型得到连续型输出不同，Logistic 回归最终的结果是离散的。

▌深入 Logistic 回归实战

下面我以一个实例来具体说明整个 Logistic 回归的流程。

社交网络数据集，这是一个包含社交网络用户信息的数据集，其中用户信息包括用户 ID，性别，年龄和估计工资等情况。一家汽车公司刚推出一款全新的豪华 SUV 骑车。我们的任务是试图预测社交网络中哪些用户将有能力购买这款全新的 SUV。最后一列的数据代表用户是否购买了这款 SUV (1代表购买，0代表不购买)。这里，我们打算构建一个 Logistic 回归模型，并把年龄和估计工资两列作为我们的特征矩阵。我们希望找到年龄和用户估计工资，与用户是否购买 SUV 决定之间的相关性。

第一步：数据预处理

导入所需的依赖库

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

导入所需的数据库

dataset = pd.read_csv('Social_Network_Ads.csv')
X = dataset.iloc[:, [2, 3]].values
y = dataset.iloc[:, 4].values

数据库地址： https://github.com/Avik-Jain/100-Days-Of-ML-Code/blob/master/datasets/Social_Network_Ads.csv

第二步：将数据库分离为训练库和测试库

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)

第三步：特征缩放

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

第四步：Logistic 回归模型

我们采用一个线性模型库，因为 Logistic 回归本身就是一个线性分类器，这意味着，我们将用一条直线在两个维度把两类用户分开，然后导入 logistic 回归类。接下来，我们将从这个类中创建一个新对象，并作为我们的训练数据集中的分类器。

在训练集中拟合 logistic 回归模型

from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression()
classifier.fit(X_train, y_train)

第五步：预测

用测试集数据预测结果

y_pred = classifier.predict(X_test)

第六步：评估预测结果

我们将通过可视化混淆矩阵评估 logistic 回归模型的预测结果。混淆矩阵能够显示我们模型所做出的正确预测以及不正确的预测。

创建混淆矩阵

from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)

第七步：可视化结果

Day 7、8、9

支持向量机 SVM及算法实现

这部分学习将带你直观了解 SVM 是什么，以及如何使用它来解决分类问题。

▌SVM 算法的实现

支持向量机 (SVM) 是一种监督式的机器学习算法，可以用于回归和分类任务 (大多数情况)。它通过找寻一个分类超平面来分离两个类别，换句话说，得到的最优超平面能够进一步用于新样本的分类。最优超平面是能够最大化类别数据之间间距的那个平面，换而言之，每个类别距离最优超平面的点之间的距离是最大的。SVM 算法示意图如下：

对于 SVM 算法而言，有四个至关重要的超参数：

核大小 (Kernel)：线性 SVM 中超平面是通过线性代数变换得到的，因此核大小扮演着关键的角色。多项式核和指数型核都能用于更高维度的线性分离计算。
正则化参数 (Regularization)：当正则化参数过大时，SVM 的优化过程将选择一个小边距的超平面，相反一个非常小的正则化参数将导致优化过程搜索一个大边距的分离面。
GAMMA 参数：小的 gamma 参数意味着远离可能超平面的点在计算分离线时会被考虑，相反大的 gamma 参数意味着靠近超平面的这些点在计算时会被考虑。
边距 (Margin)：边距是分离线与最近类别数据点的距离。一个好的边距能够将相应类别的数据点分离开，而中间不会出现其他类别的数据。

▌SVM 算法的实现

下面以一个实例来具体说明

第一步：数据预处理

导入所需的库

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

导入所需的数据数据集

dataset = pd.read_csv('Social_Network_Ads.csv')
X = dataset.iloc[:, [2, 3]].values
y = dataset.iloc[:, 4].values

第二步：将数据库分离为训练库和测试库

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)

第三步：特征缩放

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

第四步：在训练集中拟合 SVM 算法

from sklearn.svm import SVC
classifier = SVC(kernel = 'linear', random_state = 0)
classifier.fit(X_train, y_train)

第五步：用测试集数据预测结果

y_pred = classifier.predict(X_test)

第六步：创建混淆矩阵

from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)

第七步：可视化训练结果

from matplotlib.colors import ListedColormap
X_set, y_set = X_train, y_train
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
                     np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
             alpha = 0.75, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
    plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
                c = ListedColormap(('red', 'green'))(i), label = j)
plt.title('SVM (Training set)')
plt.xlabel('Age')
plt.ylabel('Estimated Salary')
plt.legend()
plt.show()

第八步：可视化测试结果

from matplotlib.colors import ListedColormap
X_set, y_set = X_test, y_test
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
                     np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
             alpha = 0.75, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
    plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
                c = ListedColormap(('red', 'green'))(i), label = j)
plt.title('SVM (Test set)')
plt.xlabel('Age')
plt.ylabel('Estimated Salary')
plt.legend()
plt.show()

Day 10、11、12

K 最近邻算法 (KNN)与算法实现

通过这部分学习，你将学会如何实现一个 KNN 算法。

▌KNN 算法

K 最近邻算法 (KNN) 是一种简单的回归分类模型，旨在通过非参数化的监督式学习来训练样本实例的算法。它不依赖于任何的数据分布假设，也不需要通过学习模型来预测结果。在分类任务中，KNN 算法有三个关键要素：标签目标集合，目标间的距离以及最近邻 k 的个数。

对于无标签的目标，KNN 算法会先计算它与标签目标之间的距离，并确定其 k 个最近邻数。然后，通过最近邻目标的类别标签来确定该目标的类别。对于实值的输入变量，最常用的距离度量是欧式距离。
欧式距离是通过计算两个目标各属性值之间的平方和得到的。还有其他的距离度量包括：Hamming 距离，Manhattan 距离，Minkowski 距离等。
K 值得选取：发现最佳的 K 值不是件容易的事。K 值越少，则对结果的影响越大；而 K 值越大，则计算成本将越高。K 值得选取通常取决于你发样本量，有时候你需要尝试一些可能的 K 值来得到最佳的选择。

▌KNN 算法的实现

下面以一个实例来具体说明

第一步：导入库

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

导入数据集

dataset = pd.read_csv('Social_Network_Ads.csv')
X = dataset.iloc[:, [2, 3]].values
y = dataset.iloc[:, 4].values

第二步：将数据集分离为训练集和测试集

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)

第三步：特征缩放

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

第四步：在训练集中拟合 KNN 算法

from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors = 5, metric = 'minkowski', p = 2)
classifier.fit(X_train, y_train)

第五步：预测测试集结果

y_pred = classifier.predict(X_test)

第六步：混淆矩阵

from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)

Day 13、14、15

决策树模型

▌决策树模型

决策树模型是一类用于类别和连续输入输出变量分类问题的监督式学习算法。一个决策树模型有许多分支，每个分支节点都代表一种选择，每个叶子 (leaf) 节点都代表一种决策。下面我们来看看决策树模型是如何工作的：

在下图的高维空间，我们有很多个散布的数据点，我们将采用决策树模型将这些数据分离开。

首先我们将每种类别的数据分离开，并构建一个决策树模型，方便后续使用。

通过诸如 CART，ID3等决策树算法，我们构建的决策树模型如下，这可以用于后续的输出预测。

ID3 表示的是迭代的 Dichotomizer 3 算法，旨在给定树节点的每个属性数据，通过自上而下的贪婪搜索来构建一个决策树模型。假定 A 是最佳属性，则分配一个决策树节点给 A。然后，对每个 A 值，为其创建一个子节点，直到遍历所有的训练数据。如果创建的决策树模型能够完美地分类数据，则终止上述过程，否则继续迭代每个叶节点。

▌决策树模型的实现

下面以一个实例来具体说明

第一步：导入库

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

导入数据集

dataset = pd.read_csv('Social_Network_Ads.csv')
X = dataset.iloc[:, [2, 3]].values
y = dataset.iloc[:, 4].values

第二步：将数据分离为训练集和测试集

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)

第三步：特征缩放

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

第四步：将决策树分类拟合到训练集

from sklearn.tree import DecisionTreeClassifier
classifier = DecisionTreeClassifier(criterion = 'entropy', random_state = 0)
classifier.fit(X_train, y_train)

第五步：预测测试集结果

y_pred = classifier.predict(X_test)

第六步：混淆矩阵

from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)

第七步：可视化训练集结果

from matplotlib.colors import ListedColormap
X_set, y_set = X_train, y_train
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
                     np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
             alpha = 0.75, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
    plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
                c = ListedColormap(('red', 'green'))(i), label = j)
plt.title('Decision Tree Classification (Training set)')
plt.xlabel('Age')
plt.ylabel('Estimated Salary')
plt.legend()
plt.show()

第八步：可视化测试集结果

from matplotlib.colors import ListedColormap
X_set, y_set = X_test, y_test
X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
                     np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
             alpha = 0.75, cmap = ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
    plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
                c = ListedColormap(('red', 'green'))(i), label = j)
plt.title('Decision Tree Classification (Test set)')
plt.xlabel('Age')
plt.ylabel('Estimated Salary')
plt.legend()
plt.show()

▌下节精彩预告：

朴素贝叶斯分类器及其实现

深度学习课程初学习及其python 实现

深度学习专业课程：超参数调整、正则化、优化等

统计学习理论导论：输入空间、动作空间、结果空间、预测函数、损失函数等内容

... ...