19_多易教育之《yiee数据运营系统》用户画像-算法导论篇

一、机器学习概念

二、机器学习算法的分类

1、监督学习

2、无监督学习

3、半监督学习

4、向量入门

三、机器学习的常见算法

四、基本数学知识

1、向量入门

2、向量的距离（相似度）

3、矩阵入门

4、概率入门

5、线性方程入门

五、Spark MLlib介绍

1、MLlib的底层基础

2、向量编程接口

3、矩阵编程接口

4、特征处理：向量规范化

六、MLlib的算法库

1、分类算法

2、回归算法

3、聚类算法

4、协同过滤

多易教育，专注大数据培训；课程引领市场，就业乘风破浪
多易教育官网地址
https://www.51doit.cn
多易教育在线学习平台
https://v.51doit.cn

一、机器学习概念

涛哥的定义：
机器学习算法，就是基于大量经验数据对某个问题进行预测；
机器学习强调三个关键词：算法、经验、性能（效果），其处理过程如下图所示。

上图表明机器学习是数据通过算法构建出模型并对模型进行评估，评估的性能如果达到要求就拿这个模型来测试其他的数据，如果达不到要求就要调整算法来重新建立模型，再次进行评估，如此循环往复，最终获得满意的模型来预测其他的数据。

二、机器学习算法的分类

1、监督学习

监督是从给定的训练数据集中学习一个函数（模型），当新的数据到来时，可以根据这个函数（模型）预测结果。监督学习的训练集要求包括输入和输出，也可以说是特征和目标。训练集中的目标是由人标注（标量）的。在监督式学习下，输入数据被称为“训练数据”，每组训练数据有一个明确的标识或结果，如对防垃圾邮件系统中“垃圾邮件”、“非垃圾邮件”，对手写数字识别中的“1”、“2”、“3”等。在建立预测模型时，监督式学习建立一个学习过程，将预测结果与“训练数据”的实际结果进行比较，不断调整预测模型，直到模型的预测结果达到一个预期的准确率。

常见的监督学习算法包括回归分析和统计分类：
二元分类是机器学习要解决的基本问题，将测试数据分成两个类，如垃圾邮件的判别、房贷是否允许等问题的判断。
多元分类是二元分类的逻辑延伸。例如，在因特网的流分类的情况下，根据问题的分类，网页可以被归类为体育、新闻、技术等，依此类推。
监督学习常常用于分类，因为目标往往是让计算机去学习我们已经创建好的分类系统。数字识别再一次成为分类学习的常见样本。一般来说，对于那些有用的分类系统和容易判断的分类系统，分类学习都适用。
监督学习是训练神经网络和决策树的最常见技术。神经网络和决策树技术高度依赖于事先确定的分类系统给出的信息。对于神经网络来说，分类系统用于判断网络的错误，然后调整网络去适应它；对于决策树，分类系统用来判断哪些属性提供了最多的信息，如此一来可以用它解决分类系统的问题。

2、无监督学习

与监督学习相比，无监督学习的训练集没有人为标注的结果。在非监督式学习中，数据并不被特别标识，学习模型是为了推断出数据的一些内在结构。常见的应用场景包括关联规则的学习以及聚类等。常见算法包括Apriori算法和k-Means算法。这类学习类型的目标不是让效用函数最大化，而是找到训练数据中的近似点。聚类常常能发现那些与假设匹配的相当好的直观分类，例如基于人口统计的聚合个体可能会在一个群体中形成一个富有的聚合，以及其他的贫穷的聚合。

非监督学习看起来非常困难：目标是我们不告诉计算机怎么做，而是让它（计算机）自己去学习怎样做一些事情。非监督学习一般有两种思路：第一种思路是在指导Agent时不为其指定明确的分类，而是在成功时采用某种形式的激励制度。需要注意的是，这类训练通常会置于决策问题的框架里，因为它的目标不是产生一个分类系统，而是做出最大回报的决定。这种思路很好地概括了现实世界，Agent可以对那些正确的行为做出激励，并对其他的行为进行处罚。

因为无监督学习假定没有事先分类的样本，这在一些情况下会非常强大，例如，我们的分类方法可能并非最佳选择。在这方面一个突出的例子是Backgammon（西洋双陆棋）游戏，有一系列计算机程序（例如neuro-gammon和TD-gammon）通过非监督学习自己一遍又一遍地玩这个游戏，变得比最强的人类棋手还要出色。这些程序发现的一些原则甚至令双陆棋专家都感到惊讶，并且它们比那些使用预分类样本训练的双陆棋程序工作得更出色。

3、半监督学习

半监督学习（Semi-supervised Learning）是介于监督学习与无监督学习之间一种机器学习方式，是模式识别和机器学习领域研究的重点问题。它主要考虑如何利用少量的标注样本和大量的未标注样本进行训练和分类的问题。半监督学习对于减少标注代价，提高学习机器性能具有非常重大的实际意义。主要算法有五类：基于概率的算法；在现有监督算法基础上进行修改的方法；直接依赖于聚类假设的方法等，在此学习方式下，输入数据部分被标识，部分没有被标识，这种学习模型可以用来进行预测，但是模型首先需要学习数据的内在结构以便合理地组织数据来进行预测。应用场景包括分类和回归，算法包括一些对常用监督式学习算法的延伸，这些算法首先试图对未标识数据进行建模，在此基础上再对标识的数据进行预测，如图论推理算法（Graph Inference）或者拉普拉斯支持向量机（Laplacian SVM）等。

半监督学习分类算法提出的时间比较短，还有许多方面没有更深入的研究。半监督学习从诞生以来，主要用于处理人工合成数据，无噪声干扰的样本数据是当前大部分半监督学习方法使用的数据，而在实际生活中用到的数据却大部分不是无干扰的，通常都比较难以得到纯样本数据。

4、强化学习

强化学习通过观察来学习动作的完成，每个动作都会对环境有所影响，学习对象根据观察到的周围环境的反馈来做出判断。在这种学习模式下，输入数据作为对模型的反馈，不像监督模型那样，输入数据仅仅是作为一个检查模型对错的方式，在强化学习下，输入数据直接反馈到模型，模型必须对此立刻做出调整。常见的应用场景包括动态系统以及机器人控制等。常见算法包括Q-Learning 以及时间差学习（Temporal difference learning）。

在企业数据应用的场景下，人们最常用的可能就是监督式学习和非监督式学习的模型。在图像识别等领域，由于存在大量的非标识的数据和少量的可标识数据，目前半监督式学习是一个很热的话题。而强化学习更多地应用在机器人控制及其他需要进行系统控制的领域。

三、机器学习的常见算法

机器学习算法解决的问题最主要的有：分类，聚类，回归(得到一个因变量和众多影响因素之间的函数模型，用以预测在新的因素组合下的因变量），推荐算法
常见的机器学习算法有：
构造条件概率：回归分析（线性回归）和统计分类；
逻辑回归（分类算法，利用回归的思想做分类）
人工神经网络/深度学习（TensorFlow，Pythorch）；
决策树（分类算法）；
朴素贝叶斯算法（分类算法）；
高斯过程回归；
线性判别分析；
K近邻算法：KNN（分类算法）
感知器；
径向基核函数；
支持向量机；SVM核函数（升维）（分类算法）
通过再生模型构造概率密度函数；
最大期望算法；
graphical model：包括贝叶斯网和Markov随机场；
Generative Topographic Mapping；
近似推断技术；
马尔可夫链蒙特卡罗方法；
变分法；
最优化：大多数以上方法，直接或者间接使用最优化算法。
ALS最小二乘协同过滤算法（推荐算法）
FP-GROWTH算法(关联规则分析算法)

根据算法的功能和形式的类似性，我们可以把算法分类，比如说基于树的算法，基于神经网络的算法等等。当然，机器学习的范围非常庞大，有些算法很难明确归类到某一类。而对于有些分类来说，同一分类的算法可以针对不同类型的问题，下面用一些相对比较容易理解的方式来解析一些主要的机器学习算法：

四、基本数学知识

1、向量入门

在编程上，你可以把向量理解为一个“double数组”

2、向量的距离（相似度）

既然向量是一个点，那么向量和向量之间就存在距离的概念！
而距离的衡量有很多的度量方法；
最经典的一种距离，就是我们日常生活中所理解的距离（点和点之间的线段长度：欧几里德距离）
但是，在不同领域，还有不同的距离度量方法：曼哈顿距离、余弦距离

距离又对应一个概念：相似度
相似度是距离的反面！距离越大，相似度越小！

在机器学习算法中，相似度的计算是非常核心的一个要素！比如KNN分类、KMEANS聚类、协同过滤推荐算法等本质上都是在计算事物和事物之间（特征向量和特征向量之间）的相似度

相似度的衡量指标跟距离一样有很多：
欧几里德距离的倒数！
余弦相似度！

推导两个公式：
1)用欧几里得距离来衡量相似度
欧几里得距离计算公式：

相似度计算公式： = 1/(1+d)

2)用余弦相似度衡量
余弦相似度计算公式：

它俩的区别：思考一个魔童哪吒卡通形象的小图片和一个等比例放大大图片之间的距离

3、矩阵入门

在编程上，你可以把矩阵理解为一个“2维甚至多维数组”

4、概率入门

伯努利方程
概率密度
概率分布：正态分布 t分布 …
假设检验

5、线性方程入门

初中：
x+2y=3
2x-y = 4
大学：
a11X+a12Y =4
a21X+a22Y = 5

（给你一些x、y的值，反推各变量的系数a11,a12,a21,a22等）

五、Spark MLlib介绍

MLlib目前支持4种常见的机器学习问题: 分类、回归、聚类和协同过滤，MLlib在Spark整个生态系统中的位置如图下图所示。

MLlib基于RDD，天生就可以与Spark SQL、GraphX、Spark Streaming无缝集成，以RDD为基石，4个子框架可联手构建大数据计算中心！

Spark MLlib架构解析

从架构图可以看出MLlib主要包含三个部分：
底层基础：包括Spark的运行库、矩阵库和向量库；
算法库：包含广义线性模型、推荐系统、聚类、决策树和评估的算法；
实用程序：包括测试数据的生成、外部数据的读入等功能。

1、MLlib的底层基础

底层基础部分主要包括向量接口Vector和矩阵接口Matrix，这两种接口都会使用Scala语言基于Netlib和BLAS/LAPACK开发的线性代数库Breeze。
MLlib支持本地的密集向量和稀疏向量，并且支持标量向量。
MLlib同时支持本地矩阵和分布式矩阵，支持的分布式矩阵分为RowMatrix、IndexedRowMatrix、CoordinateMatrix等。

2、向量编程接口

向量在数学上就是一组数字！
（在机器学习算法中，一组数字往往就是对一个事物的N个特征的表达）
因此，在编程中，最方便的模型表达就是一个Array
考虑到对向量的一些操作功能，比如求均值，求最大值，求分位数，求方差等通用功能，所以算法库就专门设计了一种类型Vector

考虑到不同向量的一个空值占比的问题，模型表达还可以细分一下：
比如，向量1: [1,8,9,18,10,11,89,] （有1000个特征，但有值的特征很少）
比如，向量2: [1,8,9,76,1,23,65,87,8,276,28,8,88,98]

上述两种向量，如果都有一个Array来表达的话，你觉得有什么问题？
向量1就变成一个如下的数组：
Array(1,8,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,0,0,0,0,10,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,89,0,0,0,0,0);
真正有意义的值很少，但数组还是得那么长！空间效率很低！有时候带来计算效率也低！

对于向量1来说，有一个名词来专门描述：稀疏型向量！
而向量2，则叫做：密集型向量

密集型向量用Array来表达，很好！

稀疏性向量用Array来表达，浪费空间，那么如何表达呢？
(向量的总维数，有特征值的位置数组，具体的非零特征值数组)
( 1000, Array[0,1,2,54,63,86,90], Array[1,8,9,18,10,11,89] )

在sparkmllib中，
密集型向量的表达类为： DenseVector （内部的数据存储形式就是一个数组）
稀疏型向量的表达类为：SparseVector（内部的数据存储形式就是前文所述tuple）

关于密集型和稀疏型的向量Vector的示例如下所示。

疏矩阵在含有大量非零元素的向量Vector计算中会节省大量的空间并大幅度提高计算速度，如下图所示。

标量LabledPoint在实际中也被大量使用，例如判断邮件是否为垃圾邮件时就可以使用类似于以下的代码：

可以把表示为1.0的判断为正常邮件，而表示为0.0则作为垃圾邮件来看待。
对于矩阵Matrix而言，本地模式的矩阵如下所示。

3、矩阵编程接口

分布式矩阵如下所示。

RowMatrix直接通过RDD[Vector]来定义并可以用来统计平均数、方差、协同方差等：

而IndexedRowMatrix是带有索引的Matrix，但其可以通过toRowMatrix方法来转换为RowMatrix，从而利用其统计功能，代码示例如下所示。

CoordinateMatrix常用于稀疏性比较高的矩阵，是由RDD[MatrixEntry]来构建的，MatrixEntry是一个Tuple类型的元素，其中包含行、列和元素值，代码示例如下所示：

4、特征处理：向量规范化

如果把原始数据中的值直接转入向量，各特征的值量纲可能差距很大，对算法的效果产生巨大负面效应（某些特征可能会掩盖掉其他特征的作用）
所以需要对向量进行缩放（规范化、归一化）
MLlib中提供的规范化工具类有4种：
P范数规范器：Normalizer .setP(2) 针对一行来操作！

示例代码：import org.apache.spark.ml.feature.Normalizer// 正则化每个向量到1阶范数
val normalizer = new Normalizer().setInputCol("features").setOutputCol("normFeatures").setP(1.0)val l1NormData = normalizer.transform(dataFrame)
println("Normalized using L^1 norm")
l1NormData.show()// 将每一行的规整为1阶范数为1的向量，1阶范数即所有值绝对值之和。
+---+--------------+------------------+
| id|      features|      normFeatures|
+---+--------------+------------------+
|  0|[1.0,0.5,-1.0]|    [0.4,0.2,-0.4]|
|  1| [2.0,1.0,1.0]|   [0.5,0.25,0.25]|
|  2|[4.0,10.0,2.0]|[0.25,0.625,0.125]|
+---+--------------+------------------+// 正则化每个向量到无穷阶范数
val lInfNormData = normalizer.transform(dataFrame, normalizer.p -> Double.PositiveInfinity)
println("Normalized using L^inf norm")
lInfNormData.show()// 向量的无穷阶范数即向量中所有值中的最大值
+---+--------------+--------------+
| id|      features|  normFeatures|
+---+--------------+--------------+
|  0|[1.0,0.5,-1.0]|[1.0,0.5,-1.0]|
|  1| [2.0,1.0,1.0]| [1.0,0.5,0.5]|
|  2|[4.0,10.0,2.0]| [0.4,1.0,0.2]|
+---+--------------+--------------+

标准差规范器：StandardNormalizer
思想：将特征标准化为单位标准差或是0均值，或是0均值单位标准差。
将每一列的标准差限制在0-1之间，从而倒推各特征值的缩放
标准差公式：

示例代码：
import org.apache.spark.ml.feature.StandardScalerval scaler = new StandardScaler().setInputCol("features").setOutputCol("scaledFeatures").setWithStd(true).setWithMean(false)// Compute summary statistics by fitting the StandardScaler.
val scalerModel = scaler.fit(dataFrame)// Normalize each feature to have unit standard deviation.
val scaledData = scalerModel.transform(dataFrame)
scaledData.show// 将每一列的标准差缩放到1。
+---+--------------+------------------------------------------------------------+
|id |features      |scaledFeatures                                              |
+---+--------------+------------------------------------------------------------+
|0  |[1.0,0.5,-1.0]|[0.6546536707079772,0.09352195295828244,-0.6546536707079771]|
|1  |[2.0,1.0,1.0] |[1.3093073414159544,0.1870439059165649,0.6546536707079771]  |
|2  |[4.0,10.0,2.0]|[2.618614682831909,1.870439059165649,1.3093073414159542]    |
+---+--------------+------------------------------------------------------------+

值域范围缩放器：MinMaxScaler
思想，将一列特征的（| 最大值-最小值 |）作为分母，（特征x-最小值）作为分子

示例代码：
import org.apache.spark.ml.feature.MinMaxScalerval scaler = new MinMaxScaler().setInputCol("features").setOutputCol("scaledFeatures")// Compute summary statistics and generate MinMaxScalerModel
val scalerModel = scaler.fit(dataFrame)// rescale each feature to range [min, max].
val scaledData = scalerModel.transform(dataFrame)
println(s"Features scaled to range: [${scaler.getMin}, ${scaler.getMax}]")
scaledData.select("features", "scaledFeatures").show// 每维特征线性地映射，最小值映射到0，最大值映射到1。
+--------------+-----------------------------------------------------------+
|features      |scaledFeatures                                             |
+--------------+-----------------------------------------------------------+
|[1.0,0.5,-1.0]|[0.0,0.0,0.0]                                              |
|[2.0,1.0,1.0] |[0.3333333333333333,0.05263157894736842,0.6666666666666666]|
|[4.0,10.0,2.0]|[1.0,1.0,1.0]                                              |
+--------------+-----------------------------------------------------------+

最大绝对值缩放器：MaxAbsScaler
思想，将一列特征的最大绝对值作为分母，（特征x）作为分子

import org.apache.spark.ml.feature.MaxAbsScalerval scaler = new MaxAbsScaler().setInputCol("features").setOutputCol("scaledFeatures")// Compute summary statistics and generate MaxAbsScalerModel
val scalerModel = scaler.fit(dataFrame)// rescale each feature to range [-1, 1]
val scaledData = scalerModel.transform(dataFrame)
scaledData.select("features", "scaledFeatures").show()// 每一维的绝对值的最大值为[4, 10, 2]
+--------------+----------------+
|      features|  scaledFeatures|
+--------------+----------------+
|[1.0,0.5,-1.0]|[0.25,0.05,-0.5]|
| [2.0,1.0,1.0]|   [0.5,0.1,0.5]|
|[4.0,10.0,2.0]|   [1.0,1.0,1.0]|
+--------------+----------------+

六、MLlib的算法库

下图是MLlib算法库的核心内容。

下文我们介绍一些Spark中常用的算法

1、分类算法

分类算法属于监督式学习，使用类标签已知的样本建立一个分类函数或分类模型，应用分类模型，能把数据库中的类标签未知的数据进行归类。分类在数据挖掘中是一项重要的任务，目前在商业上应用最多，常见的典型应用场景有流失预测、精确营销、客户获取、个性偏好等。

MLlib 目前支持分类算法有：逻辑回归、支持向量机、朴素贝叶斯和决策树。
案例：导入训练数据集，然后在训练集上执行训练算法，最后在所得模型上进行预测并计算训练误差。
SVM调用示例：

import org.apache.spark.SparkContext
import org.apache.spark.mllib.classification.SVMWithSGD
import org.apache.spark.mllib.regression.LabeledPoint// 加载和解析数据文件
val data = sc.textFile("mllib/data/sample_svm_data.txt")
val parsedData = data.map { line =>val parts = line.split(' ')LabeledPoint(parts(0).toDouble, parts.tail.map(x => x.toDouble).toArray)
}// 设置迭代次数并进行进行训练
val numIterations = 20
val model = SVMWithSGD.train(parsedData, numIterations)// 统计分类错误的样本比例
val labelAndPreds = parsedData.map { point =>
val prediction = model.predict(point.features)
(point.label, prediction)
}
val trainErr = labelAndPreds.filter(r => r._1 != r._2).count.toDouble / parsedData.count
println("Training Error = " + trainErr)

2、回归算法

回归算法属于监督式学习，每个个体都有一个与之相关联的实数标签，并且我们希望在给出用于表示这些实体的数值特征后，所预测出的标签值可以尽可能接近实际值。
MLlib 目前支持回归算法有：线性回归、岭回归、Lasso和决策树。
线性回归调用示例：导入训练数据集，将其解析为带标签点的RDD，使用 LinearRegressionWithSGD 算法建立一个简单的线性模型来预测标签的值，最后计算均方差来评估预测值与实际值的吻合度。

import org.apache.spark.mllib.regression.LinearRegressionWithSGD
import org.apache.spark.mllib.regression.LabeledPoint// 加载和解析数据文件
val data = sc.textFile("mllib/data/ridge-data/lpsa.data")
val parsedData = data.map { line =>val parts = line.split(',')LabeledPoint(parts(0).toDouble, parts(1).split(' ').map(x => x.toDouble).toArray)
}//设置迭代次数并进行训练
val numIterations = 20
val model = LinearRegressionWithSGD.train(parsedData, numIterations)// 统计回归错误的样本比例
val valuesAndPreds = parsedData.map { point =>
val prediction = model.predict(point.features)
(point.label, prediction)
}
val MSE = valuesAndPreds.map{ case(v, p) => math.pow((v - p), 2)}.reduce(_ + _)/valuesAndPreds.count
println("training Mean Squared Error = " + MSE)

3、聚类算法

聚类算法属于非监督式学习，通常被用于探索性的分析，是根据“物以类聚”的原理，将本身没有类别的样本聚集成不同的组，这样的一组数据对象的集合叫做簇，并且对每一个这样的簇进行描述的过程。它的目的是使得属于同一簇的样本之间应该彼此相似，而不同簇的样本应该足够不相似，常见的典型应用场景有客户细分、客户研究、市场细分、价值评估。
MLlib 目前支持广泛使用的KMmeans聚类算法。

KMeans调用示例：导入训练数据集，使用 KMeans 对象来将数据聚类到两个类簇当中，所需的类簇个数会被传递到算法中，然后计算集内均方差总和 (WSSSE)，可以通过增加类簇的个数 k 来减小误差。实际上，最优的类簇数通常是 1，因为这一点通常是WSSSE图中的 “低谷点”。

import org.apache.spark.mllib.clustering.KMeans// 加载和解析数据文件
val data = sc.textFile("kmeans_data.txt")
val parsedData = data.map( _.split(' ').map(_.toDouble))
// 设置迭代次数、类簇的个数
val numIterations = 20
val numClusters = 2// 进行训练
val clusters = KMeans.train(parsedData, numClusters, numIterations)// 统计聚类错误的样本比例
val WSSSE = clusters.computeCost(parsedData)
println("Within Set Sum of Squared Errors = " + WSSSE)

4、协同过滤

协同过滤常被应用于推荐系统，这些技术旨在补充用户-商品关联矩阵中所缺失的部分。MLlib当前支持基于模型的协同过滤，其中用户和商品通过一小组隐语义因子进行表达，并且这些因子也用于预测缺失的元素。
ALS调用示例：导入训练数据集，数据每一行由一个用户、一个商品和相应的评分组成。假设评分是显性的，使用默认的ALS.train()方法，通过计算预测出的评分的均方差来评估这个推荐模型。

import org.apache.spark.mllib.recommendation.ALS
import org.apache.spark.mllib.recommendation.Rating// 加载和解析数据文件
val data = sc.textFile("mllib/data/als/test.data")
val ratings = data.map(_.split(',') match {case Array(user, item, rate) => Rating(user.toInt, item.toInt, rate.toDouble)
})// 设置迭代次数
val numIterations = 20
val model = ALS.train(ratings, 1, 20, 0.01)// 对推荐模型进行评分
val usersProducts = ratings.map{ case Rating(user, product, rate) => (user, product)}
val predictions = model.predict(usersProducts).map{case Rating(user, product, rate) => ((user, product), rate)
}
val ratesAndPreds = ratings.map{
case Rating(user, product, rate) => ((user, product), rate)
}.join(predictions)
val MSE = ratesAndPreds.map{
case ((user, product), (r1, r2)) => math.pow((r1- r2), 2)
}.reduce(_ + _)/ratesAndPreds.count
println("Mean Squared Error = " + MSE)

多易教育，专注大数据培训；课程引领市场，就业乘风破浪
多易教育官网地址
https://www.51doit.cn
多易教育在线学习平台
https://v.51doit.cn