原文作者：Sunil Ray

译者：TalkingData 张永超

简介

从广义上讲，机器学习算法有三种类型：

监督学习

该算法是由一个目标/结果变量（也成为因变量）组成，该变量可以从一组给定的预测变量中预测出来。使用这些变量的组合，我们可以生成一个由输入映射到所需输出的的函数。该算法的训练过程会尝试将模型的预测准确度提高到训练数据所需的程度。具体的算法有：回归、决策树、随机森林、kNN、Logistic回归等等。

无监督学习

该算法中，没有任何的目标/结果变量以用来预测/估计。基本上用于不同的群体间的聚类，通常该算法用于对不同的群体进行分组。具体的算法有：Apriori算法，K-means等。

强化学习

该算法是比较新的一个机器学习算法分类，使用该算法，机器会被训练来做出一些特定的决策。此时机器会被暴露在一个特定的环境中，通过反复试验不断的训练自己，知道最终得到一个比较好的决策结果。该算法会从过去的经验中学习，并尝试捕捉最佳的结果知识以做出更加准确的决策。典型的算法有：马尔可夫决策过程等。

通用机器学习算法列表

下面是一些通用的机器学习算法，这些算法基本上能够解决大部分的数据相关问题：

1.    线性回归（Linear Regression）

2.    逻辑回归（Logistic Regression）

3.    决策树（Decision Tree）

4.    支持向量机（SVM）

5.    朴素贝叶斯（Naive Bayes）

6.    k近邻（kNN）

7.    k均值（K-Means）

8.    随机森林（Random Forest）

9.    降维算法（Dimensionality Reduction Algorithms）

10.  梯度增强算法（Gradient Boosting algorithms）

GBM

XGBoost

LightGBM

CatBoos

线性回归

线性回归主要用于根据连续的变量来估计实际值（例如：房屋成本，通话次数，总销售额等）。在该算法中，我们通过拟合最佳的分界线来建立独立变量和因变量之间的关系。该最佳的拟合线称为回归线，并可以由线性方程Y = a * X + b表示。例如：我们要求一个五年级的孩子根据班上同学的体重来排序，而不告诉他同学们的具体体重。他会怎么做呢？他可能会根据同学们的身高和体型来判断某个同学的体重，然后进行排序。我们并没有告诉他身高和体型与体重之间的关系，而他已经可以通过眼睛的观察来得到身高和体型与体重之间的关系了，而这个关系是符合上述线性回归的方程的。

在上述方程中：

Y --- 因变量

a --- 倾斜量

X --- 自变量

b --- 截距

系数a和b是基于最小化数据点与回归线之间的距离的平方差的总和而得出的。

假设我们有一些人员的身体和体重的数据，将其绘制在图表中。如下图所示：



这里我们已经找到了最佳的拟合线，其方程表示为y = 0.2811*x + 13.9，为图中黑色线。那么我们就可以使用这个方程来根据某人的身高，得到其体重了。

线性回归主要有两种类型：单一线性回归和多元线性回归。单一线性回归顾名思义，就是仅由一个独立的自变量表征，而多元线性回归由多于一个自变量来表征。在寻找最佳拟合线时，可以拟合多项式或曲线回归。

本文中的代码大部分为演示所用，在实际应用中需要替换甚至重写部分代码，请慎重复制粘贴！

Python code

1# Import Library

2# Import other necessary libraries like pandas, numpy...

3from sklearn import linear_model

4# Load Train and Test datasets

5# Identify feature and response variable(s) and values must be numeric and numpy arrays

6x_train=input_variables_values_training_datasets

7y_train=target_variables_values_training_datasets

8x_test=input_variables_values_test_datasets

9# Create linear regression object

10linear = linear_model.LinearRegression()

11# Train the model using the training sets and check score

12linear.fit(x_train, y_train)

13linear.score(x_train, y_train)

14# Equation coefficient and Intercept

15print('Coefficient: \n', linear.coef_)

16print('Intercept: \n', linear.intercept_)

17# Predict Output

18predicted= linear.predict(x_test)

2逻辑回归

不要被这个名字所糊弄了！ 其实逻辑回归并不是回归算法。它基于给定的一组自变量来估计离散值（二进制值，如0/1，是/否，真/假）。简单的说，它通过将数据拟合到logit函数来预测事件发生的可能性。因此，它通常也被称为logit回归。因为它预测了可能性，即概率，因此其输出值在0和1之间。例如：你的朋友给你出了一道难题，并且他并不知道你的知识范围，而你能给出的结果只有能解决或者不能解决。假如这道题是高级物理学科的题目，你可能只有大学本科的经历，你给出能解决的概率可能只有20%，而如何你恰好是一个物理学博士，你给出解决的概率可能就有80%了，这就是逻辑回归。

从数学的含义上讲，逻辑回归就是结果的对数几率被建模为预测变量的线性组合。如下：

1odds = p / (1- p) = probabilityofevent occurrence / probabilityofnotevent occurrence

2ln(odds) = ln(p / (1- p))

3logit(p) = ln(p / (1- p)) = b0+b1X1+b2X2+b3X3....+bkXk

上述公式中，p是存在感兴趣特征的概率。它选择最大化观察样本值的可能性的参数，而不是最小化平方误差的总和（如在普通回归中那样）。



Python code

1# Import Library

2fromsklearn.linear_modelimportLogisticRegression

3# Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset

4# Create logistic regression object

5model = LogisticRegression()

6# Train the model using the training sets and check score

7model.fit(X, y)

8model.score(X, y)

9# Equation coefficient and Intercept

10print('Coefficient: \n', model.coef_)

11print('Intercept: \n', model.intercept_)

12# Predict Output

13predicted= model.predict(x_test)

3决策树

决策树是一种主要用于分类问题的监督学习算法。该算法不仅仅支持分类问题，还支持连续因变量问题。在这个算法中，我们将人口分成两个或更多的齐次集合。这是基于最重要的属性/独立变量来完成的，以尽可能地形成不同的组。



如上图所示，可以看到该算法根据多个属性将一个群体分为了四个不同的群体，以识别“他们是否会参加比赛”。为了分组，它使用各种技术，如基尼，信息增益，卡方，熵等。

另一种理解决策树的绝佳方式是玩一个微软上经典的游戏 --- Jezzball。基本上，你有一个有活动墙壁的房间，你需要创造墙壁，这样最大的区域就会被清理掉。



因此，每一次你使用墙壁来划分房间，你都将试图将一个房间划分为两部分。决策树也非常类似这种方式。

Python code

1# Import Library

2# Import other necessary libraries like pandas, numpy...

3from sklearn import tree

4# Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset

5# Create tree object

6model = tree.DecisionTreeClassifier(criterion='gini')# for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini  

7# model = tree.DecisionTreeRegressor() for regression

8# Train the model using the training sets and check score

9model.fit(X, y)

10model.score(X, y)

11# Predict Output

12predicted= model.predict(x_test)

4SVM(支持向量机)

SVM是一个分类方法。在该算法中，我们将每个数据项绘制为n维空间中的一个点（其中n是您拥有的要素数），每个要素的值都是特定坐标的值。

例如，如果我们只有个人的身高和头发长度两个特征，我们首先在二维空间中绘制这两个变量，其中每个点有两个坐标（这些坐标被称为支持向量）。



现在，我们将找到一些分割两个不同分类数据组之间线。而这条线将使得两组数据中最近点的距离最远。



在上面所示的例子中，将数据分成两个不同分类组的线是黑线，因为两个最近点离线最远。这条线就是我们的分类器。然后，根据测试数据在线两侧的位置，就可以区分测试数据属于哪个类了。

Python code

1# Import Library

2from sklearn import svm

3# Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset

4# Create SVM classification object

5model = svm.svc()# there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail.

6# Train the model using the training sets and check score

7model.fit(X, y)

8model.score(X, y)

9# Predict Output

10predicted= model.predict(x_test)

5朴素贝叶斯

朴素贝叶斯是一种基于贝叶斯定理的分类技术，假设预测变量之间具有独立性。简而言之，朴素贝叶斯分类器假定类中特定特征的存在与任何其他特征的存在无关。例如，如果果实呈红色，圆形，直径约3英寸，则可认为其为苹果。即使这些特征依赖于彼此或者依赖于其他特征的存在，朴素贝叶斯分类器也会考虑所有这些特性来独立地贡献该水果是苹果的可能性。

朴素贝叶斯模型很容易构建，对于非常大的数据集特别有用。贝叶斯定理提供了一种从P（c），P（x）和P（x | c）计算后验概率P（c | x）的方法。看下面的公式：



这里：

P（c | x）是给定预测器（属性）的类（目标）的后验概率。

P（c）是类的先验概率。

P（x | c）是预测器给定类的概率的可能性。

P（x）是预测变量的先验概率。

例子：让我们用一个例子来理解它。下面我有一个天气和相应的目标变量“是否参加比赛”的训练数据集。现在，我们需要根据天气情况来分类球员是否参加比赛。让我们按照以下步骤来执行它。

将数据集转换为频率表

通过查找像Overcast probability = 0.29和播放概率为0.64的概率来创建Likelihood表。

现在，使用朴素贝叶斯方程来计算每个类别的后验概率。具有最高后验概率的类别是预测的结果。

Python code

1# Import Library

2fromsklearn.naive_bayesimportGaussianNB

3# Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset

4# Create SVM classification object model = GaussianNB() # there is other distribution for multinomial classes like Bernoulli Naive Bayes, Refer link

5# Train the model using the training sets and check score

6model.fit(X, y)

7# Predict Output

8predicted= model.predict(x_test)

6kNN (k-最近邻)

kNN可以用于分类和回归问题。然而，它在业内的分类问题中被更广泛地使用。 K最近邻算法是一个简单的算法，它存储所有可用的案例，并通过其k个邻居的多数投票来分类新案例。被分配给类的情况在距离函数测量的k近邻中最为常见。

这些距离函数可以是欧几里得，曼哈顿，闵可夫斯基和海明距离。前三个函数用于连续函数，第四个函数（Hamming）用于分类变量。如果K = 1，那么该情况被简单地分配给其最近邻居的类别。有时，在执行kNN建模时选择K是一项挑战。



kNN可以很容易地映射到我们的真实生活中。如果你想了解一个你没有信息的人，你可能想知道他的亲密朋友和他进入的圈子并获得他/她的信息！

选择kNN之前需要考虑的事项： * KNN在计算上很耗时 * 在使用kNN时，变量应该被标准化，否则更高的范围变量会偏向它 * 在进入kNN之前要更多地进行数据预处理，如异常值，噪音消除等。

Python code

1# Import Library

2fromsklearn.neighborsimportKNeighborsClassifier

3# Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset

4# Create KNeighbors classifier object model

5KNeighborsClassifier(n_neighbors=6)# default value for n_neighbors is 5

6# Train the model using the training sets and check score

7model.fit(X, y)

8# Predict Output

9predicted= model.predict(x_test)

7K-均值（K-Means）

K-均值是一种解决聚类问题的无监督算法。其过程遵循一个简单的方法，通过一定数量的聚类（假设k个聚类）对给定的数据集进行分类。群集内的数据点与同级群组是同质且异质的。

例如在白纸上随机撒上的墨水， K-均值有点类似这个活动，每一块墨水水渍可以理解为一个群组。



K-means如何形成群集：

K-means为每个簇选取k个点，称为质心。

每个数据点形成具有最接近质心的群集，即k个群集。

根据现有集群成员查找每个集群的质心。这里我们有新的质心。

由于我们有新的质心，请重复步骤2和3.从新质心找到每个数据点的最近距离，并与新的k-簇进行关联。重复这个过程直到收敛发生，即质心不变。

如何确定K的值：

在K-means中，我们有簇，每个簇都有自己的质心。质心与聚类内的数据点之间的差的平方和构成该聚类的平方值的和。另外，当所有群集的平方值总和相加时，群集解决方案的平方和总和为总和。

我们知道，随着群集数量的增加，这个值会持续下降，但是如果您绘制结果，您可能会看到平方距离的总和急剧下降到某个k值，然后再慢得多。在这里，我们可以找到聚类的最佳数量。



Python code

1# Import Library

2from sklearn.cluster import KMeans

3# Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset

4# Create KNeighbors classifier object model

5k_means = KMeans(n_clusters=3, random_state=0)

6# Train the model using the training sets and check score

7model.fit(X)

8# Predict Output

9predicted= model.predict(x_test)

8

随机森林

随机森林是一个决策树集合的术语。在随机森林中，集成了多个决策树（所谓的“森林”）。要根据属性对新对象进行分类，每棵树都会给出一个分类，并且该树会为该分类“投票”。森林选择票数最多的分类，即为最终的分类。

每株树种植和生长如下：

如果训练集中的病例数为N，则随机抽取N个病例的样本，但需要更换。这个样本将成为培育树的培训集。

如果有M个输入变量，则指定一个数m << M，以便在每个节点处从M中随机选择m个变量，并且使用这些m上的最佳分割来分割节点。在森林生长期间，m的值保持不变。

每棵树都尽可能地生长。没有修剪。

Python code

1# Import Library

2from sklearn.ensemble import RandomForestClassifier

3# Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset

4# Create Random Forest object

5model= RandomForestClassifier()

6# Train the model using the training sets and check score

7model.fit(X, y)

8# Predict Output

9predicted= model.predict(x_test)

9

维度降低算法

在过去的4-5年里，在每个可能的阶段数据采集呈指数级增长。企业/政府机构/研究机构不仅拥有新的资源，而且还在详细捕获数据。

例如：电子商务公司正在抓住更多有关客户的细节，例如他们的人口统计数据，网络爬行历史，他们喜欢或不喜欢的内容，购买历史记录，反馈信息等等，以便为他们提供比最近的杂货店老板更多的个性化关注。

作为一名数据科学家，我们提供的数据还包含许多功能，这对构建良好的健壮模型听起来不错，但是存在挑战。你如何确定1000或2000年以外的重要变量？在这种情况下，降维算法可以帮助我们连同各种其他算法，如决策树，随机森林，PCA，因子分析，基于相关矩阵的识别，缺失值比等。

Python code

1# Import Library

2from sklearn import decomposition

3# Assumed you have training and test data set as train and test

4# Create PCA obeject pca= decomposition.PCA(n_components=k) #default value of k =min(n_sample, n_features)

5# For Factor analysis

6# fa= decomposition.FactorAnalysis()

7# Reduced the dimension of training dataset using PCA

8train_reduced = pca.fit_transform(train)

9# Reduced the dimension of test dataset

10test_reduced = pca.transform(test)

10梯度下降算法

10.1. GBM

当我们处理大量数据以进行具有高预测能力的预测时，GBM是一种增强算法。 Boosting实际上是一种学习算法集合，它将几个基本估计量的预测结合起来，以提高单个估计量的鲁棒性。它将多个弱预测器或平均预测器组合成强大的预测器。这些提升算法在Kaggle，AV Hackathon，CrowdAnalytix等数据科学竞赛中始终运作良好。

Python code

1# Import Library

2from sklearn.ensemble import GradientBoostingClassifier

3# Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset

4# Create Gradient Boosting Classifier object

5model= GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)

6# Train the model using the training sets and check score

7model.fit(X, y)

8# Predict Output

9predicted= model.predict(x_test)

10.2. XGBoost

XGBoost是另一个经典的渐变增强算法，被称为在一些Kaggle比赛中获胜的关键性算法。

XGBoost具有非常高的预测能力，使其成为事件精确度的最佳选择，因为它具有线性模型和树学习算法，使得该算法比现有梯度增强技术快近10倍。

支持包括各种目标函数，包括回归，分类和排名。

XGBoost最有趣的事情之一就是它也被称为正规化提升技术。这有助于减少过度装配建模，并且对Scala，Java，R，Python，Julia和C ++等一系列语言提供大量支持。

在许多包含GCE，AWS，Azure和Yarn群集的机器上支持分布式和广泛的培训。 XGBoost还可以与Spark，Flink和其他云数据流系统集成在一起，每次迭代过程中都有内置的交叉验证。

Python code

1from xgboost import XGBClassifier

2from sklearn.model_selection import train_test_split

3from sklearn.metrics import accuracy_score

4X = dataset[:,0:10]

5Y = dataset[:,10:]

6seed = 1

7X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=seed)

8model = XGBClassifier()

9model.fit(X_train, y_train)

10#Make predictions for test data

11y_pred = model.predict(X_test)

10.3. LightGBM

LightGBM是一种梯度提升框架，使用基于树的学习算法。它的设计是分布式和高效的，具有以下优点：

更快的训练速度和更高的效率

降低内存使用量

更好的准确性

支持并行和GPU学习

能够处理大型数据

该框架是一种基于决策树算法的快速高性能梯度提升算法，用于排序、分类和许多其他机器学习任务。它是在Microsoft的分布式机器学习工具包项目下开发的。

由于LightGBM基于决策树算法，因此它将树叶以最佳拟合进行分割。因此，当在Light GBM中的同一片叶上生长时，叶式算法可以比平面式算法减少更多的损失，因此可以获得更好的精度，而现有的任何增强算法都很难达到这些精度。

Python code

1data = np.random.rand(500, 10)# 500 entities, each contains 10 features

2label = np.random.randint(2, size=500)# binary target

3train_data = lgb.Dataset(data, label=label)

4test_data = train_data.create_valid('test.svm')

5param = {'num_leaves':31, 'num_trees':100, 'objective':'binary'}

6param['metric'] = 'auc'

7num_round = 10

8bst = lgb.train(param, train_data, num_round, valid_sets=[test_data])

9bst.save_model('model.txt')

10# 7 entities, each contains 10 features

11data = np.random.rand(7, 10)

12ypred = bst.predict(data)

10.4. Catboost

CatBoost是Yandex最近开源的机器学习算法。它可以轻松地与Google的TensorFlow和Apple的Core ML等深度学习框架相整合。

CatBoost最棒的部分是它不需要像其他ML模型那样的大量数据训练，并且可以处理各种数据格式;不会破坏它的可靠性。

在使用和执行Catboost算法之前，请确保数据中的缺失值已经被处理。

Catboost可以自动处理分类变量而不显示类型转换错误，这有助于您更专注于更好地调整模型。

Python code

1importpandasaspd

2importnumpyasnp

3fromcatboostimportCatBoostRegressor

4#Read training and testing files

5train = pd.read_csv("train.csv")

6test = pd.read_csv("test.csv")

7#Imputing missing values for both train and test

8train.fillna(-999, inplace=True)

9test.fillna(-999,inplace=True)

10#Creating a training set for modeling and validation set to check model performance

11X = train.drop(['Item_Outlet_Sales'], axis=1)

12y = train.Item_Outlet_Sales

13fromsklearn.model_selectionimporttrain_test_split

14X_train, X_validation, y_train, y_validation = train_test_split(X, y, train_size=0.7, random_state=1234)

15categorical_features_indices = np.where(X.dtypes != np.float)[0]

16#importing library and building model

17fromcatboostimportCatBoostRegressormodel=CatBoostRegressor(iterations=50, depth=3, learning_rate=0.1, loss_function='RMSE')

18model.fit(X_train, y_train,cat_features=categorical_features_indices,eval_set=(X_validation, y_validation),plot=True)

19submission = pd.DataFrame()

20submission['Item_Identifier'] = test['Item_Identifier']

21submission['Outlet_Identifier'] = test['Outlet_Identifier']

22submission['Item_Outlet_Sales'] = model.predict(test)

总结

至此，相信你对机器学习的各个主要算法有了一个大概的了解，文中给出了各个算法的逻辑代码，你可以从这里开始，尝试解决一些问题，并在过程中加深理解。关于数据，你可以在网络上找到很多，而且在一些所使用到的Python库中也常内置了各种数据集，你可以查看相应的官方文档查找并直接使用。

                    
          

            
机器学习算法

广泛地说，有三种类型的机器学习算法。

1.监督学习
这个算法由一个目标/结果变量（或因变量）组成，这个变量可以从一组给定的预测变量（独立变量）中预测出来。 使用这些变量，我们生成一个将输入映射到所需输出的函数。 训练过程一直持续到模型达到训练数据所需的准确度。 监督学习的例子：回归，决策树，随机森林，KNN，逻辑回归等。
2.无监督学习
在这个算法中，我们没有任何目标或结果变量来预测/估计。 用于不同群体的群体聚类，广泛用于不同群体的消费者细分进行具体干预。 无监督学习的例子：Apriori算法，K-means。
3.强化学习：
使用这种算法，机器被训练做出特定的决定。 它是这样工作的：机器暴露在一个环境中，它使用反复试验不断地训练自己。 这台机器从过去的经验中学习，并试图捕捉最好的知识，做出准确的业务决策。 强化学习实例：马尔可夫决策过程
这里是常用的机器学习算法列表。 这些算法可以应用于几乎所有的数据问题：

线性回归

Logistic回归

决策树

SVM

朴素贝叶斯

KNN

K均值

随机森林

维度降低算法

梯度提升算法

GBM

XGBoost

LightGBM

CatBoost

1.线性回归
它用于根据连续变量估计实际值（房屋成本，通话次数，总销售额等）。在这里，我们通过拟合最佳线来建立独立和因变量之间的关系。该最佳拟合线被称为回归线，并由线性方程Y = a * X + b表示。
理解线性回归的最好方法是重温童年的这种体验。让我们说，你问一个五年级的孩子，通过增加体重的顺序来安排班上的人，而不要问他们的重量！你觉得孩子会做什么？他/她可能会查看（视觉分析）人的身高和身材，并使用这些可见参数的组合进行排列。这是现实生活中的线性回归！实际上，孩子已经找到了身高，身材与体重之间的关系，看起来像上面的方程式。
在这个等式中：
Y因变量

一个 - 坡度

X - 自变量

b - 拦截

这些系数a和b是基于最小化数据点与回归线之间的距离的平方和的总和而得出的。
看下面的例子。这里我们已经确定了具有线性方程y = 0.2811x + 13.9的最佳拟合线。现在使用这个等式，我们可以找到重量，知道一个人的身高。









R代码：
#Load Train and Test datasets
#Identify feature and response variable(s) and values must be numeric and numpy arrays
x_train <- input_variables_values_training_datasets
y_train <- target_variables_values_training_datasets
x_test <- input_variables_values_test_datasets
x <- cbind(x_train,y_train)
# Train the model using the training sets and check score
linear <- lm(y_train ~ ., data = x)
summary(linear)
#Predict Output
predicted= predict(linear,x_test) 

python:
#Import Library
#Import other necessary libraries like pandas, numpy...
from sklearn import linear_model
#Load Train and Test datasets
#Identify feature and response variable(s) and values must be numeric and numpy arrays
x_train=input_variables_values_training_datasets
y_train=target_variables_values_training_datasets
x_test=input_variables_values_test_datasets
# Create linear regression object
linear = linear_model.LinearRegression()
# Train the model using the training sets and check score
linear.fit(x_train, y_train)
linear.score(x_train, y_train)
#Equation coefficient and Intercept
print('Coefficient: \n', linear.coef_)
print('Intercept: \n', linear.intercept_)
#Predict Output
predicted= linear.predict(x_test)


          
        
        
        
                
    

序

声明：以下是博主精心整理的机器学习和AI系列文章，博主后续会不断更新该领域的知识：

人工智能AI实战系列代码全解析

手把手教你ML机器学习算法源码全解析

有需要的小伙伴赶紧订阅吧。

人工智能的浪潮正在席卷全球，诸多词汇时刻萦绕在我们耳边：人工智能（Artificial Intelligence）、机器学习（Machine Learning）、深度学习（Deep Learning）。不少人对这些高频词汇的含义及其背后的关系总是似懂非懂、一知半解。

 



人工智能的研究领域也在不断扩大，上图展示了人工智能研究的各个分支，包括专家系统、机器学习、进化计算、模糊逻辑、计算机视觉、自然语言处理、推荐系统等。

人工智能一定程度上来说是机器学习喝深度学习的深层次应用，要想学好人工智能，我们需要掌握的哪些经典算法呢？

一起来看看吧。

 

前言

深度学习是很多人面临的一个挑战，因为它在过去的十年中已经慢慢地改变了形式。为了在视觉上设置深度学习，下图展示了AI，机器学习和深度学习三者之间关系的概念。



人工智能领域广泛，已经有很长一段时间了，深度学习是机器学习领域的一个子集，AI的一个子领域。

一般将深度学习网络与“典型”前馈多层网络(FP)区分开来的方面如下：



	
比以前的网络更多的神经元
	
	

	
更复杂的连接层的方式
	
	

	
“寒武纪大爆炸”的计算训练能力
	
	

	
自动特征提取
	


当我说“更多的神经元”，意思是神经元数量已经上升了多年来表达更复杂的模型。

然后，深度学习可以被定义为具有四个基本网络体系结构之一中的：大量‘参数和层’的神经网络：



	
无监督的预训练网络
	
	

	
卷积神经网络
	
	

	
回归（复）神经网络
	
	

	
递归神经网络
	


在本文中，我们主要关注后三种架构。

 

一、卷积神经网络 


是基本上已经跨越使用共享权重的空间延伸的标准神经网络。CNN被设计为通过在内部卷积来识别图像，其看到图像上识别的对象的边缘。


二、回归神经网络


是基本上已经通过具有边缘，其递进给到下一个时间步长，而不是成在同一时间步骤中的下一层跨越时间延长标准神经网络。RNN被设计为识别序列，例如语音信号或文本。它里面的循环意味着网络中存在短暂的内存。


三、递归神经网络


更像是一个分层网络，其中输入序列确实没有时间方面，但输入必须以树状方式分层处理。以下10种方法可以应用于所有这些体系结构。


经典算法

1 - 反向传播（BP）

Back-propagation只是一种计算函数偏导数（或梯度）的方法，函数具有函数组成的形式（如神经网络）。当你使用基于梯度的方法（梯度下降只是其中之一）解决优化问题时，你需要在每次迭代中计算函数梯度。



对于神经网络而言，目标函数具有合成的形式

你如何计算梯度？

BP算法是Delta规则的推广，要求每个人工神经元（节点）所使用的激励函数必须是可微的。BP算法特别适合用来训练前向神经网络，有两种常见的方式来做到这一点：

（一）分析微分，你知道函数的形式，只需使用链式规则（基本演算）来计算函数梯度。

（二）使用有限差分进行近似微分。

其中（二）方法的计算量很大，因为评估函数的数量级是  O（N），其中 N 是参数的数量。与分析微分相比，就相形见绌了。然而，有限差分通常用于在调试时验证后端时很有效。

2 - 随机梯度下降（SGD）

想想渐变下降的一种直观的方式是想象一条源于山顶的河流的小路。

梯度下降的目标正是河流努力实现的目标 - 即到达从山上迈着扯着蛋的步子溜向山脚。

现在，如果山的地形是这样形成的，即在到达最终目的地（这是山麓的最低点）之前，河流不必完全停下来，那么这是我们所希望的理想情况。

在机器学习中，我们已经找到了从初始点（山顶）开始的解的全局最小值（或最优值）。

但是，这可能是因为地形的性质使得路径上的几个坑，这可能会迫使河流陷入困境，在机器学习方面，这种‘坑’被称为局部最优。



因此，梯度下降倾向于卡在局部最小值，这取决于地形的性质（或ML中的函数）。

但是，当你有一个特殊的山地形（形状像一个碗，在ML术语中称为凸函数），该算法始终保证找到最佳。

你可以想象这再次描绘了一条河流。这些特殊的地形（又称凸函数）总是在ML中优化的祝福。另外，取决于你最初从哪里开始（即函数的初始值），你可能会走上一条不同的路。同样，根据河流的爬升速度（即梯度下降算法的学习速率或步长），你可能会以不同的方式到达最终目的地。

3 - 学习率衰减

根据随机梯度下降优化程序调整学习率可以提高性能并减少训练时间。有时这被称为  学习速率退火 或 自适应学习速率。



最简单的学习速率：是随着时间的推移而降低学习速度。当使用较大的学习速率值时，它们具有在训练过程开始时进行大的改变的益处，并且降低了学习速率，使得稍后在训练过程中对较小的速率进行训练更新，从而对训练进行更新，这样可以达到早期快速学习好权重并稍后进行微调的效果。

两个流行和易于使用的学习率衰减如下：


在训练过程中逐步降低学习率。

在特定的epochs中降低学习速度比如Adam


4 - Dropout

具有大量参数的深度神经网络是非常强大的机器学习系统，过度拟合也是一个问题，大型网络的使用也很慢，通过在测试时间结合许多不同的大型神经网络的预测，很难处理过度拟合，Dropout是解决这个问题的一种技巧。



关键的思想是在训练期间从神经网络中随机丢掉某些单元（连同他们的连接），这可以防止单元适应太多
在训练期间，从不同的指数级的“稀疏”网络中剔除样本。
在测试时间，通过简单地使用具有较小权重的单个未解压的网络来容易地近似平均所有这些细化网络的预测的效果。这显着减少了过拟合，并且比其他正则化方法有了重大改进。

Dropout已被证明可以提高神经网络在视觉监控学习任务，语音识别，文档分类和计算生物学的性能，在许多基准数据集上获得最新的结果。

5 - 最大的池化

最大池化是一个基于样本的离散化过程。目标是对输入表示（图像，隐藏层输出矩阵等）进行下采样，降低其维度，并允许对包含在分区域中的特征进行假设。



这部分是通过提供表示的抽象形式来解决过度拟合，它通过减少要学习的参数数量来降低计算成本，并为内部表示提供基本的平移不变性，最大池化是通过将最大过滤波器应用于初始表示的通常不重叠的子区域来完成的。

6 - 批量标准化（有时也称归一化）

当然，包括深度网络的神经网络需要仔细调整权重，初始化和学习参数。
权重问题：

无论权重的初始化如何，无论是随机的还是经验性的选择，它们都远离学习权重。考虑一个小批量，在最初的时期，将会有许多异常值在所需的功能激活方面。

深层神经网络本身是不适宜的，即初始层中的小扰动导致后面层的大变化。

在反向传播过程中，这些现象会导致对梯度的分离，这意味着在学习权重以产生所需输出之前，梯度必须补偿异常值。这导致需要额外的epoch来收敛。



批量归一化使这些梯度从分散到正常值，并在小批量范围内流向共同目标（通过归一化）
学习率问题：一般来说，学习率保持较低，只有一小部分的梯度校正权重，原因是异常激活的梯度不应影响学习的激活。通过批量标准化，这些异常激活减少，因此可以使用更高的学习速度来加速学习过程。

7-LSTM网络：

LSTM网络具有以下三个方面，使其与常规神经网络中的常见神经元不同：



	
它决定何时让输入进入神经元。
	
	

	
它决定何时记住上一个时间中计算的内容
	
	

	
它决定何时让输出传递到下一个时间戳。
	


LSTM的优点在于它根据当前的输入本身来决定所有这些,所以如果你看下面的图表：



当前时间标记处的输入信号x（t）决定所有上述3个点。

输入门决定点1.遗忘门在点2的决策，输出门在点3输出决策，单独的输入是能够采取所有这三个决策，这受到我们的大脑如何工作的启发，并且可以基于输入来处理突然的上下文切换。

8-Skip-gram

词嵌入模型 的目标是为每个词汇项学习一个高维密集表示，其中嵌入向量之间的相似性显示了相应词语之间的语义或句法相似性。

Skip-gram是学习单词嵌入算法的模型，此模型（以及许多其他的词语嵌入模型）背后的主要思想如下：如果 两个词汇词汇共享相似的上下文，则它们是相似的。



换句话说，假设你有一个句子，就像“猫是哺乳动物”一样，如果你用“狗”而不是“猫”，这个句子还是一个有意义的句子，所以在这个例子中，“狗”和“猫”可以共享相同的语境（即“是哺乳动物”）。

9 - Continuous Bag Of Words（CBOW）

在自然语言处理问题中，我们希望学习将文档中的每个单词表示为一个数字的向量，使得出现在相似的上下文中的单词具有彼此接近的向量。

在连续的单词模型中，目标是能够使用围绕特定单词的上下文并预测特定单词，基于上述假设，你可以考虑一个上下文窗口（一个包含k个连续项的窗口）

然后你应该跳过其中一个单词，试着去学习一个能够得到除跳过项外的所有项的神经网络，并预测跳过的项，如果两个词在一个大语料库中反复共享相似的语境，则这些词的嵌入向量将具有相近的向量。



我们通过在一个大的语料库中采取大量的句子来做到这一点，每当我们看到一个单词时，我们就会听到这个单词。然后，我们将上下文单词输入到一个神经网络，并在这个上下文的中心预测单词。

当我们有成千上万个这样的上下文单词和中心词时，我们有一个神经网络数据集的实例。我们训练神经网络，最后编码的隐藏层输出表示特定单词的嵌入。恰巧当我们通过大量的句子进行训练时，类似语境中的单词得到相似的向量。

10 - 迁移学习（brilliant idea）

让我们考虑一下图像如何穿过卷积神经网络，假设你有一个图像，你应用卷积，并得到像素的组合作为输出。

假设他们是边缘。现在再次应用卷积，所以现在你的输出是边或线的组合。现在再次应用卷积，所以你的输出是线的组合等等。

你可以把它看作是每一层寻找一个特定的模式，神经网络的最后一层往往会变得非常细化。在ImageNet上，你的网络最后一层就是寻找baby，狗或飞机等等。你可能会看到网络寻找眼睛或耳朵或嘴巴或轮子。



深度CNN中的每一层都逐渐建立起越来越高层次的特征表征，最后几层往往是专门针对你输入模型的任何数据。另一方面，早期的图层更为通用，在一大类图片中有许多简单的图案。

转移学习就是当你在一个数据集上训练CNN时，切掉最后一层，在不同的数据集上重新训练最后一层的模型，直观地说，你正在重新训练模型以识别不同的高级功能。因此，训练时间会减少很多，所以当你没有足够的数据或者训练需要太多的资源时，迁移学习是一个有用的工具。

机器学习算法概揽



机器学习算法就是在没有人类干预的情况下，从数据中学习，并在经验中改善的一种方法，学习任务可能包括学习从输入映射到输出的函数，学习无标签数据的隐含结构;或者是「基于实例的学习」，通过与存储在记忆中的训练数据做比较，给一个新实例生成一个类别标签。基于实例的学习(instance-based learning)不会从具体实例中生成抽象结果。

机器学习算法的类型

有三类机器学习算法：

1. 监督学习:

可以这样来描述监督学习：使用有标签的训练数据去学习从输入变量(X)到输出变量(Y)的映射函数。

Y = f (X)

它分为两种类型：

a. 分类：通过一个给定的输入预测一个输出，这里的输出变量以类别的形式展示。例如男女性别、疾病和健康。

b. 回归：也是通过一个给定的输入预测一个输出，这里的输出变量以实数的形式展示。例如预测降雨量、人的身高等实数值。

本文介绍的前 5 个算法就属于监督学习：线性回归、Logistic 回归、CART、朴素贝叶斯和 KNN。

集成学习也是一种监督学习方法。它意味着结合多种不同的弱学习模型来预测一个新样本。本文介绍的第 9、10 两种算法--随机森林 Bagging 和 AdaBoost 提升算法就是集成学习技术。

2. 非监督学习:

非监督学习问提仅仅处理输入变量(X)，但不会处理对应的输出(也就是说，没有标签)。它使用无标签的训练数据建模数据的潜在结构。

非监督学习可以分为 2 种类型：

a. 关联：就是去发觉在同一个数据集合中不同条目同时发生的概率。广泛地用于市场篮子分析。例如：如果一位顾客买了面包，那么他有 80% 的可能性购买鸡蛋。

b. 聚类：把更加相似的对象归为一类，而不是其他类别对象。

c. 降维：顾名思义，降维就是减少数据集变量，同时要保证重要信息不丢失。降维可以通过使用特征提取和特征选择方法来完成。特征选择方法会选择原始变量的一个子集。特征提取完成了从高维空间到低维空间的数据变换。例如，主成分分析(PCA)就是一个特征提取方法。

本文介绍的算法 6-8 都是非监督学习的例子：包括 Apriori 算法、K-均值聚类、主成分分析(PCA)。

3. 强化学习:

强化学习是这样一种学习方法，它允许智能体通过学习最大化奖励的行为，并基于当前状态决定下一步要采取的最佳行动。

强化学习一般通过试错学习到最佳行动。强化学习应用于机器人，机器人在碰到障碍物质之后会收到消极反馈，它通过这些消极反馈来学会避免碰撞;也用在视频游戏中，通过试错发现能够极大增长玩家回报的一系列动作。智能体可以使用这些回报来理解游戏中的最佳状态，并选择下一步的行动。

监督学习

1. 线性回归

在机器学习中，我们用输入变量 x 来决定输出变量 y。输入变量和输出变量之间存在一个关系。机器学习的目标就是去定量地描述这种关系。



图 1：以一条直线的形式展示出来的线性回归：y = ax +b

在线性回归中，输入变量 x 和输出变量 y 的关系可以用一个方程的形式表达出来：y=ax+b。所以，线性回归的目标就是寻找参数 a 和 b 的值。这里，a 是直线的斜率，b 是直线的截距。

图 1 将一个数据集中的 x 和 y 用图像表示出来了。如图所示，这里的目标就是去寻找一条离大多数点最近的一条直线。这就是去减小一个数据点的 y 值和直线之间的距离。

2.Logistic 回归

线性回归预测是连续值(如厘米级的降雨量)，logistic 回归预测是使用了一种变换函数之后得到的离散值(如一位学生是否通过了考试)。

Logistic 回归最适合于二元分类问题(在一个数据集中，y=0 或者 1，1 代表默认类。例如：在预测某个事件是否会发生的时候，发生就是 1。在预测某个人是否患病时，患病就是 1)。这个算法是拿它所使用的变换函数命名的，这个函数称为 logistics 函数(logistics function，h(x)= 1/ (1 + e^x))，它的图像是一个 S 形曲线。

在 logistic 回归中，输出是默认类别的概率(不像线性回归一样，输出是直接生成的)。因为是概率，所以输出的值域是 [0,1]。输出值 y 是通过输入值 x 的对数变换 h(x)= 1/ (1 + e^ -x) 得到的。然后使用一个阈值强制地让输出结果变成一个二元分类问题。



图 2：确定一个肿瘤是恶性的还是良性的回归。如果概率 h(x)>0.5，则是恶性的

在图 2 中，为了判断一个肿瘤是不是恶性，默认变量被设置为 y=1(肿瘤是恶性的);变量 x 可能是对一个肿瘤的检测结果，例如肿瘤的尺寸。如图中所示，logistics 函数将变量 x 的值变换到了 0 到 1 之间。如果概率超过了 0.5(图中的水平线为界)，肿瘤就被归类为恶性。

logistic 回归的方程 P(x) = e ^ (b0 +b1*x) / (1 + e^(b0 + b1*x))可以被转换为对数形式： ln(p(x) / 1-p(x)) = b0 + b1*x。

logistic 回归的目标就是使用训练数据来寻找参数 b0 和 b1 的值，最小化预测结果和实际值的误差。这些参数的评估使用的是最大似然估计的方法。

3. 分类和回归树

分类和回归树(CART)是决策树的一种补充。

非终端节点(non-terminal node)包含根节点 (root node) 和中间节点 (internal node)。每一个非终端节点代表一个单独的输入变量 x 和这个变量的分支节点;叶节点代表的是输出变量 y。这个模型按照以下的规则来作出预测：



图 3：决策树的一些部分

4. 朴素贝叶斯法

在给定一个早已发生的事件的概率时，我们用贝叶斯定理去计算某个事件将会发生的概率。在给定一些变量的值时，我们也用贝叶斯定理去计算某个结果的概率，也就是说，基于我们的先验知识(d)去计算某个假设(h)为真的概率。计算方法如下：

P(h|d)= (P(d|h) * P(h)) / P(d)

其中，

P(h|d) = 后验概率。就是假设 h 为真概率，给定的数据相当于先验知识 d。其中 P(h|d)= P(d1| h)* P(d2| h)*....*P(dn| h)* P(d)。

P(d|h) = 似然度。假设 h 正确时，数据 d 的概率。

P(h) = 类先验概率。假设 h 正确的额概率。(无关数据)

P(d) = 预测器先验概率。数据的概率(无关假设)

这个算法被称为「朴素」的原因是：它假设所有的变量是相互独立的，这也是现实世界中做出的一个朴素的假设。



图 4：使用朴素贝叶斯法来预测变量「天气」变化状态

以图 4 为例，如果天气=晴天，那么输出是什么呢?

在给定变量天气=晴天时，为了判断结果是或者否，就要计算 P(yes|sunny) 和 P(no|sunny)，然后选择概率较大的结果。

计算过程如下：

->P(yes|sunny)= (P(sunny|yes) * P(yes)) / P(sunny)

= (3/9 * 9/14 ) / (5/14)

= 0.60

-> P(no|sunny)= (P(sunny|no) * P(no)) / P(sunny)

= (2/5 * 5/14 ) / (5/14)

= 0.40

所以，天气=晴天时，结果为是。

5.KNN

KNN 使用了整个数据集作为训练集，而不是将它分为训练集和测试集。

当给定的一个数据实例时，KNN 算法会在整个数据集中寻找 k 个与其新样本距离最近的，或者 k 个与新样本最相似的，然后，对于回归问题，输出结果的平均值，或者对于分类问题，输出频率最高的类。k 的值是用户自定义的。

样本之间的相似性是用欧氏距离或者汉明(Hamming)距离来计算的。

非监督学习算法

6.Apriori 算法

Apriori 算法被用来在交易数据库中进行挖掘频繁的子集，然后生成关联规则。常用于市场篮子分析，分析数据库中最常同时出现的交易。通常，如果一个顾客购买了商品 X 之后又购买了商品 Y，那么这个关联规则就可以写为：X -> Y。

例如：如果一位顾客购买了牛奶和甜糖，那他很有可能还会购买咖啡粉。这个可以写成这样的关联规则： {牛奶，甜糖} -> 咖啡粉。关联规则是交叉了支持度(support)和置信度(confidence)的阈值之后产生的。



图 5： 关联规则 X→Y 支持度、置信度和提升度的公式表示。

支持度的程度帮助修改在频繁的项目集中用来作为候选项目集的数量。这种支持度的衡量是由 Apriori 原则来指导的。Apriori 原则说明：如果一个项目集是频繁的，那么它的所有子集都是频繁的。

7.K-均值聚类算法

K-均值是一个对相似的数据进行聚类的迭代算法。它计算出 k 个聚类的中心点，并给某个类的聚类分配一个与其中心点距离最近的数据点。



图 6：K-均值算法的步骤

步骤 1：K-均值初始化

a) 选择一个 k 值。这里我们令 k=3。

b) 将数据点随机地分配给三个聚类。

c) 计算出每个聚类的中心点。图中的红色、蓝色和绿色的星分别代表三个聚类的中心点。

步骤 2：将每一个观测值与一个聚类关联起来

将每一个数据点重新分配给离它最近的一个聚类中心点。如图所示，上边的五个数据点被分配给了蓝星代表的聚类。按照相同的步骤将数据点分配给红色和绿色星代表的聚类中心点。

步骤 3：重新计算中心点

计算新聚类的中心点。如图所示，旧中心点是灰色的，新中心点是红色、蓝色和绿色的。

步骤 4：迭代，然后在数据点所属的聚类不变的时候退出整个过程

重复步骤 2-3，直至每一个聚类中的点不会被重新分配到另一个聚类中。如果在两个连续的步骤中不再发生变化，那么就退出 K-均值算法。

8. 主成分分析(PCA)

主成分分析(PCA)通过减少变量的数目来使数据变得更加易于探索和可视化。这通过将数据中拥有最大方差的数据抽取到一个被称为「主成分」的新坐标系中。每一个成分都是原始变量的一个新的线性组合，且是两两统计独立的。统计独立意味着这些成分的相关系数是 0。

第一主成分捕获的是数据中最大方差的数据。第二主成分捕获的是剩下的数据中方差最大但是与第一主成分相互独立的数据。相似地，后续的主成分(例如 PC3、PC4)都是剩下的数据中方差最大的但是与之前的主成分保持独立的数据。



图 7：使用主成分分析方法(PCA)，三种初始变量(基因)被降为两种新变量

集成学习技术

集成意味着通过投票或者取平均值的方式，将多个学习器(分类器)结合起来以改善结果。在分类的时候进行投票，在回归的时候求平均值。核心思想就是集成多个学习器以使性能优于单个学习器。有三种集成学习的方法：装袋(Bagging)、提升(Boosting)和堆叠(Stacking)。本文不涉及堆叠。

9. 随机森林 Bagging

随机森林(多个学习器)是在装袋决策树(单个学习器)上做的改进。

Bagging：Bagging 的第一步就是在使用 Bootstrap 采样方法得到的数据库中创建多个模型，每个生成的训练集都是原始数据集的子集。每个训练集都有相同的大小，但是有些样本重复出现了很多次，有些样本一次未出现。然后，整个原始数据集被用为测试集。那么，如果原始数据集的大小为 N，则每个生成的训练集的大小也是 N，唯一(没有重复)样本的大小大约是 2*N/3;测试集的大小也是 N。

Bagging 的第二步就是使用同一个算法在不同的数据集上生成多个模型。然后，我们讨论一下随机森林。在决策树中，每个节点都在最好的、能够最小化误差的最佳特征上进行分支，而随机森林与之不同，我们选择随机分支的特征来构建最佳的分支。进行随机处理的原因在于：即便使用了 Bagging，当决策树选择最佳特征来分支的时候，它们最终会有相似的模型和相关联的预测结果。但是用随机子集上的特征进行分支意味着子树做的预测是没有多少相关性的。

10. AdaBoost 提升算法

a)Bagging 是并行集成，因为每个模型都是独立建立的。然而，提升是一个顺序性集成，每个模型都要纠正前面模型的错误分类。

b)Bagging 主要涉及到「简单投票」，每个分类器都投票得到一个最终结果，这个分类结果是由并行模型中的大多数模型做出的;提升则使用「权重投票」。每个分类器都会投票得到一个由大多数模型做出的结果—但是建立这些顺序性模型的时候，给之前误分类样本的模型赋予了较大的权重。

Adaboost 指的是适应性提升。



图 9：一个决策树的 Adaboost

在图 9 中，步骤 1、2、3 指的是被称为决策桩(decision stump)的弱学习器(是一个仅依靠一个输入作出决策的 1 级决策树;是一种根节点直接连接到叶节点的决策树)。构造决策树的过程会一直持续，直到用户定义了一个弱学习器的数目，或者训练的时候再也没有任何提升的时候。步骤 4 结合了之前模型中的 3 个决策桩(所以在这个决策树中就有 3 种分支规则)。

步骤 1：开始用 1 个决策桩来根据 1 个输入变量做决策

数据点的大小说明我们应用了等权重来将它们分为圆形或者三角形。决策桩在图的上半部分用一条水平线来对这些点进行分类。我们可以看到，有两个圆被误分为三角形。所以，我们会赋予这两个圆更大的权重，然后使用另一个决策桩(decision stump)。

步骤 2：转向下一个决策桩，对另一个输入变量进行决策

我们可以看到，之前的步骤中误分类的两个圆要比其余数据点大。现在，第二个决策桩要尝试正确地预测这两个圆。

赋予更大权重的结果就是，这两个圆被左边的竖线正确地分类了。但是这又导致了对上面 3 个小圆的误分类。因此，我们要在另一个决策桩对这三个圆赋予更大的权重。

步骤 3：训练另一个决策桩对下一个输入变量进行决策。

上一步误分类的 3 个圆要比其他的数据点大。现在，在右边生成了一条竖线，对三角形和圆进行分类。

步骤 4：结合决策桩

我们结合了之前 3 步的决策桩，然后发现一个复杂的规则将数据点正确地分类了，性能要优于任何一个弱学习器。

结语

回顾一下，本文主要学到的内容：

1. 5 种监督学习技术：线性回归、Logistic 回归、CART(分类和决策树)、朴素贝叶斯法和 KNN。

2. 3 种非监督学习技术：Apriori 算法、K-均值聚类、主成分分析(PCA)。

3. 两种集成学习方法：Bagging 随机森林、AdaBoost 提升。

综上所述，机器学习的基本属性可以总结为以下：

机器学习是(使用样本获取近似函数的)统计学的一个分支。我们有一个确实存在的理论函数或分布用以生成数据，但我们目前不知道它是什么。我们可以对这个函数进行抽样，这些样本选自我们的训练集。

以图片描述任务为例：函数：f⋆(图片)→图片描述，样本：data∈(image，description)。注意：由于一个物体有许多有效的描述，所以描述是文本空间中的一个分布：图片描述〜文本。

机器的目标是找到模型：有足够的表现力来逼近真正的函数，找到一个高效的算法，它使用训练数据找到函数最优解。而且此最优解必须对未知输入有良好的泛化能力。