mllib_mllib spark - CSDN
精华内容
参与话题
  • MLlib官方简介

    千次阅读 2018-05-12 13:14:14
    MLlib是Spark的机器学习(ML)库。 其目标是使实际的机器学习具有可扩展性和易用性。在较高的层面上,它提供了以下工具:(1)ML算法:通用学习算法,如分类,回归,聚类和协作过滤(2)特征提取:特征提取,转换,...

    MLlibSpark的机器学习(ML)库。 其目标是使实际的机器学习具有可扩展性和易用性。

    在较高的层面上,它提供了以下工具:

    (1)ML算法:通用学习算法,如分类回归聚类协作过滤

    (2)特征提取:特征提取,转换,降维和选择

    (3)管道:用于构建,评估和调整ML管道的工具

    (4)持久性:保存和加载算法,模型和管道

    (5)实用程序:线性代数,统计,数据处理等

    公告:基于DataFrameAPI是主要的API

    基于MLlib RDDAPI现在处于维护模式。

    Spark 2.0开始,spark.mllib包中的基于RDDAPI已进入维护模式。 Spark的主要机器学习API现在是spark.ml包中的基于DataFrameAPI

    什么影响?

    (1)MLlib仍然会支持spark.mllib中基于RDDAPI并提供错误修复。

    (2)MLlib不会将新功能添加到基于RDDAPI

    (3)Spark 2.x版本中,MLlib将向基于DataFramesAPI添加功能以达到与基于RDDAPI的功能一致性。

    (4)达到功能奇偶校验(大致估计为Spark 2.3)后,基于RDDAPI将被弃用。

    (5)预计在Spark 3.0中将删除基于RDDAPI

    为什么MLlib切换到基于DataFrameAPI

    (1)DataFrames提供比RDD更友好的APIDataFrame的许多优点包括Spark数据源,SQL / DataFrame查询,TungstenCatalyst优化以及跨语言的统一API

    (2)MLlib的基于DataFrameAPI提供跨ML算法和跨多种语言的统一API

    (3)DataFrames方便实用ML管道,特别是功能转换。 有关详细信息,请参阅管道指南。

    什么是“Spark ML”

    “Spark ML”不是一个正式名称,但偶尔用于指代基于MLlib DataFrameAPI。 这主要是由于基于DataFrameAPI所使用的org.apache.spark.ml Scala包名称以及我们最初用来强调管道概念的“Spark ML Pipelines”术语。

    MLlib是否被弃用?

    不会,MLlib包含基于RDDAPI和基于DataFrameAPI。 基于RDDAPI现在处于维护模式。 但是这两种API都没有被弃用,也没有和MLlib作为一个整体。

     依赖

    MLlib使用线性代数包Breeze,它依赖于netlib-java进行优化的数值处理。 如果本机库1在运行时不可用,您将看到一条警告消息,而将使用纯JVM实现。


    展开全文
  • SparkMLlib简介

    千次阅读 2018-08-21 18:33:15
    1、机器学习概念 1.1 机器学习的定义 在维基百科上对机器学习提出以下几种定义: l“机器学习是一门人工智能的科学,该领域的主要研究对象是人工智能,特别是如何在经验学习中改善具体算法的性能”。...

    1、机器学习概念

    1.1 机器学习的定义

    在维基百科上对机器学习提出以下几种定义:

    l“机器学习是一门人工智能的科学,该领域的主要研究对象是人工智能,特别是如何在经验学习中改善具体算法的性能”。

    l“机器学习是对能通过经验自动改进的计算机算法的研究”。

    l“机器学习是用数据或以往的经验,以此优化计算机程序的性能标准。” 一种经常引用的英文定义是:A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E。

    可以看出机器学习强调三个关键词:算法、经验、性能,其处理过程如下图所示。

    clip_image002

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

    1.2 机器学习的分类

    1.2.1 监督学习

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

    l  二元分类是机器学习要解决的基本问题,将测试数据分成两个类,如垃圾邮件的判别、房贷是否允许等问题的判断。

    l  多元分类是二元分类的逻辑延伸。例如,在因特网的流分类的情况下,根据问题的分类,网页可以被归类为体育、新闻、技术等,依此类推。

    监督学习常常用于分类,因为目标往往是让计算机去学习我们已经创建好的分类系统。数字识别再一次成为分类学习的常见样本。一般来说,对于那些有用的分类系统和容易判断的分类系统,分类学习都适用。

    监督学习是训练神经网络和决策树的最常见技术。神经网络和决策树技术高度依赖于事先确定的分类系统给出的信息。对于神经网络来说,分类系统用于判断网络的错误,然后调整网络去适应它;对于决策树,分类系统用来判断哪些属性提供了最多的信息,如此一来可以用它解决分类系统的问题。

    clip_image003

    1.2.2 无监督学习

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

    clip_image005

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

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

    1.2.3 半监督学习

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

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

    clip_image007

    1.2.4 强化学习

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

    clip_image009

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

    1.3 机器学习的常见算法

    常见的机器学习算法有:

    l  构造条件概率:回归分析和统计分类;

    l  人工神经网络;

    l  决策树;

    l  高斯过程回归;

    l  线性判别分析;

    l  最近邻居法;

    l  感知器;

    l  径向基函数核;

    l  支持向量机;

    l  通过再生模型构造概率密度函数;

    l  最大期望算法;

    l  graphical model:包括贝叶斯网和Markov随机场;

    l  Generative Topographic Mapping;

    l  近似推断技术;

    l  马尔可夫链蒙特卡罗方法;

    l  变分法;

    l  最优化:大多数以上方法,直接或者间接使用最优化算法。

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

    1.3.1 回归算法

    回归算法是试图采用对误差的衡量来探索变量之间的关系的一类算法。回归算法是统计机器学习的利器。在机器学习领域,人们说起回归,有时候是指一类问题,有时候是指一类算法,这一点常常会使初学者有所困惑。常见的回归算法包括:最小二乘法(Ordinary Least Square),逻辑回归(Logistic Regression),逐步式回归(Stepwise Regression),多元自适应回归样条(Multivariate Adaptive Regression Splines)以及本地散点平滑估计(Locally Estimated Scatterplot Smoothing)。

    clip_image011

    1.3.2 基于实例的算法

    基于实例的算法常常用来对决策问题建立模型,这样的模型常常先选取一批样本数据,然后根据某些近似性把新数据与样本数据进行比较。通过这种方式来寻找最佳的匹配。因此,基于实例的算法常常也被称为“赢家通吃”学习或者“基于记忆的学习”。常见的算法包括 k-Nearest Neighbor (KNN),、学习矢量量化(Learning Vector Quantization, LVQ)以及自组织映射算法(Self-Organizing Map,SOM)

    clip_image013

    1.3.3 正则化方法

    正则化方法是其他算法(通常是回归算法)的延伸,根据算法的复杂度对算法进行调整。正则化方法通常对简单模型予以奖励而对复杂算法予以惩罚。常见的算法包括:Ridge Regression、Least Absolute Shrinkage and Selection Operator(LASSO)以及弹性网络(Elastic Net)。

    clip_image015

    1.3.4 决策树学习

    决策树算法根据数据的属性采用树状结构建立决策模型,决策树模型常常用来解决分类和回归问题。常见的算法包括:分类及回归树(Classification And Regression Tree, CART)、 ID3 (Iterative Dichotomiser 3)、C4.5、Chi-squared Automatic Interaction Detection (CHAID)、Decision Stump、机森林(Random Forest)、多元自适应回归样条(MARS)以及梯度推进机(Gradient Boosting Machine,GBM)。

    clip_image017

    1.3.5 贝叶斯学习

    贝叶斯方法算法是基于贝叶斯定理的一类算法,主要用来解决分类和回归问题。常见算法包括:朴素贝叶斯算法、平均单依赖估计(Averaged One-Dependence Estimators, AODE)以及 Bayesian Belief Network(BBN)。

    clip_image019

    1.3.6 基于核的算法

    基于核的算法中最著名的莫过于支持向量机(SVM)了。基于核的算法把输入数据映射到一个高阶的向量空间, 在这些高阶向量空间里, 有些分类或者回归问题能够更容易解决。常见的基于核的算法包括:支持向量机(Support Vector Machine,SVM)、径向基函数(Radial Basis Function,RBF)以及线性判别分析(Linear Discriminate Analysis,LDA)等。

    clip_image021

    1.3.7 聚类算法

    聚类就像回归一样,有时候人们描述的是一类问题,有时候描述的是一类算法。聚类算法通常按照中心点或者分层的方式对输入数据进行归并。所有的聚类算法都试图找到数据的内在结构,以便按照最大的共同点将数据进行归类。常见的聚类算法包括 k-Means 算法以及期望最大化算法(Expectation Maximization,EM)。

    clip_image023

    1.3.8 关联规则学习

    关联规则学习通过寻找最能够解释数据变量之间关系的规则,来找出大量多元数据集中有用的关联规则。常见算法包括 Apriori 算法和 Eclat 算法等。

    clip_image025

    1.3.9 人工神经网络算法

    人工神经网络算法模拟生物神经网络,是一类模式匹配算法。通常用于解决分类和回归问题。人工神经网络是机器学习的一个庞大的分支,有几百种不同的算法(其中深度学习就是其中的一类算法,我们会单独讨论)。重要的人工神经网络算法包括:感知器神经网络(Perceptron Neural Network)、反向传递(Back Propagation)、Hopfield 网络、自组织映射(Self-Organizing Map, SOM)、学习矢量量化(Learning Vector Quantization,LVQ)。

    clip_image027

    1.3.10 深度学习算法

    深度学习算法是对人工神经网络的发展,在近期赢得了很多关注,特别是百度也开始发力深度学习后,更是在国内引起了很多关注。在计算能力变得日益廉价的今天,深度学习试图建立大得多也复杂得多的神经网络。很多深度学习的算法是半监督式学习算法,用来处理存在少量未标识数据的大数据集。常见的深度学习算法包括:受限波尔兹曼机(Restricted Boltzmann Machine, RBN)、 Deep Belief Networks(DBN)、卷积网络(Convolutional Network)、堆栈式自动编码器(Stacked Auto-encoders)。

    clip_image029

    1.3.11 降低维度算法

    像聚类算法一样,降低维度算法试图分析数据的内在结构,不过降低维度算法是以非监督学习的方式,试图利用较少的信息来归纳或者解释数据。这类算法可以用于高维数据的可视化或者用来简化数据以便监督式学习使用。常见的算法包括:主成份分析(Principle Component Analysis, PCA)、偏最小二乘回归(Partial Least Square Regression,PLS)、 Sammon 映射、多维尺度(Multi-Dimensional Scaling, MDS)、投影追踪(Projection Pursuit)等。

    clip_image031

    1.3.12 集成算法

    集成算法用一些相对较弱的学习模型独立地对同样的样本进行训练,然后把结果整合起来进行整体预测。集成算法的主要难点在于究竟集成哪些独立的较弱的学习模型以及如何把学习结果整合起来。这是一类非常强大的算法,同时也非常流行。常见的算法包括:Boosting、Bootstrapped Aggregation(Bagging)、AdaBoost、堆叠泛化(Stacked Generalization, Blending)、梯度推进机(Gradient Boosting Machine, GBM)、随机森林(Random Forest)。

    clip_image033

    2、Spark MLlib介绍

    Spark之所以在机器学习方面具有得天独厚的优势,有以下几点原因:

    (1)机器学习算法一般都有很多个步骤迭代计算的过程,机器学习的计算需要在多次迭代后获得足够小的误差或者足够收敛才会停止,迭代时如果使用Hadoop的MapReduce计算框架,每次计算都要读/写磁盘以及任务的启动等工作,这回导致非常大的I/O和CPU消耗。而Spark基于内存的计算模型天生就擅长迭代计算,多个步骤计算直接在内存中完成,只有在必要时才会操作磁盘和网络,所以说Spark正是机器学习的理想的平台。

    (2)从通信的角度讲,如果使用Hadoop的MapReduce计算框架,JobTracker和TaskTracker之间由于是通过heartbeat的方式来进行的通信和传递数据,会导致非常慢的执行速度,而Spark具有出色而高效的Akka和Netty通信系统,通信效率极高。

    MLlib(Machine Learnig lib) 是Spark对常用的机器学习算法的实现库,同时包括相关的测试和数据生成器。Spark的设计初衷就是为了支持一些迭代的Job, 这正好符合很多机器学习算法的特点。在Spark官方首页中展示了Logistic Regression算法在Spark和Hadoop中运行的性能比较,如图下图所示。

    clip_image035

    可以看出在Logistic Regression的运算场景下,Spark比Hadoop快了100倍以上!

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

    clip_image037

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

    MLlib是MLBase一部分,其中MLBase分为四部分:MLlib、MLI、ML Optimizer和MLRuntime。

    l  ML Optimizer会选择它认为最适合的已经在内部实现好了的机器学习算法和相关参数,来处理用户输入的数据,并返回模型或别的帮助分析的结果;

    l  MLI 是一个进行特征抽取和高级ML编程抽象的算法实现的API或平台;

    l  MLlib是Spark实现一些常见的机器学习算法和实用程序,包括分类、回归、聚类、协同过滤、降维以及底层优化,该算法可以进行可扩充; MLRuntime 基于Spark计算框架,将Spark的分布式计算应用到机器学习领域。

    clip_image039

    3、Spark MLlib架构解析

    从架构图可以看出MLlib主要包含三个部分:

    l  底层基础:包括Spark的运行库、矩阵库和向量库;

    l  算法库:包含广义线性模型、推荐系统、聚类、决策树和评估的算法;

    l  实用程序:包括测试数据的生成、外部数据的读入等功能。

    clip_image041

    3.1 MLlib的底层基础解析

    底层基础部分主要包括向量接口和矩阵接口,这两种接口都会使用Scala语言基于Netlib和BLAS/LAPACK开发的线性代数库Breeze。

    MLlib支持本地的密集向量和稀疏向量,并且支持标量向量。

    MLlib同时支持本地矩阵和分布式矩阵,支持的分布式矩阵分为RowMatrix、IndexedRowMatrix、CoordinateMatrix等。

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

    clip_image043

          clip_image045

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

    clip_image047

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

    clip_image049

    可以把表示为1.0的判断为正常邮件,而表示为0.0则作为垃圾邮件来看待。

    对于矩阵Matrix而言,本地模式的矩阵如下所示。

    clip_image051clip_image053

    分布式矩阵如下所示。

    clip_image051[1] clip_image055

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

    clip_image057

    clip_image059

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

    clip_image061

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

    clip_image063

    3.2 MLlib的算法库分析

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

    clip_image065

    在这里我们分析一些Spark中常用的算法:

    3.2.1 分类算法

    分类算法属于监督式学习,使用类标签已知的样本建立一个分类函数或分类模型,应用分类模型,能把数据库中的类标签未知的数据进行归类。分类在数据挖掘中是一项重要的任务,目前在商业上应用最多,常见的典型应用场景有流失预测、精确营销、客户获取、个性偏好等。MLlib 目前支持分类算法有:逻辑回归、支持向量机、朴素贝叶斯和决策树。

    案例:导入训练数据集,然后在训练集上执行训练算法,最后在所得模型上进行预测并计算训练误差。

    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)

    3.2.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.2.3 聚类算法

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

    案例:导入训练数据集,使用 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)

    3.2.4 协同过滤

    协同过滤常被应用于推荐系统,这些技术旨在补充用户-商品关联矩阵中所缺失的部分。MLlib当前支持基于模型的协同过滤,其中用户和商品通过一小组隐语义因子进行表达,并且这些因子也用于预测缺失的元素。

    案例:导入训练数据集,数据每一行由一个用户、一个商品和相应的评分组成。假设评分是显性的,使用默认的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)

    3.3 MLlib的实用程序分析

    实用程序部分包括数据的验证器、Label的二元和多元的分析器、多种数据生成器、数据加载器。

    clip_image067

     

    4、参考资料

    (1)Spark官网 mlllib说明  http://spark.apache.org/docs/1.1.0/mllib-guide.html

    (2)《机器学习常见算法分类汇总》 http://www.ctocio.com/hotnews/15919.html

    展开全文
  • SPARK MLLIB机器学习 Spark入门实战系列附带资源 好不容易搜了好多地方找到的
  • Spark机器学习库(MLlib)官方指南手册中文版

    万次阅读 多人点赞 2016-12-12 15:30:10
    Spark机器学习库(MLlib)指南  MLlib是Spark里的机器学习库。它的目标是使实用的机器学习算法可扩展并容易使用。它提供如下工具:  1.机器学习算法:常规机器学习算法包括分类、回归、聚类和协同过滤。  2.特征...

    Spark机器学习库(MLlib)指南

           MLlib是Spark里的机器学习库。它的目标是使实用的机器学习算法可扩展并容易使用。它提供如下工具:

           1.机器学习算法:常规机器学习算法包括分类、回归、聚类和协同过滤。

           2.特征工程:特征提取、特征转换、特征选择以及降维。

           3.管道:构造、评估和调整的管道的工具。

           4.存储:保存和加载算法、模型及管道

           5.实用工具:线性代数,统计,数据处理等。

           *注意:主要接口为基于数据框的接口,基于RDD的接口目前处于维护模式。

           在Spark2.0中,spark.mllib包中的RDD接口已进入维护模式。现在主要的机器学习接口为spark.ml包中的基于数据框接口。

           这一转变包含哪些信息?

           1.MLlib将继续在spark.mllib中支持基于RDD的接口。

           2.MLlib不会向基于RDD的接口中继续添加新的特征。

           3.在Spark2.0以后的版本中,将继续向基于数据框的接口添加新特征以缩小与基于RDD接口的差异。

           4.当两种接口之间达到特征相同时(初步估计为Spark2.2),基于RDD的接口将被废弃。

           5.基于RDD的接口将在Spark3.0中被移除。

           为什么MLlib转向数据框接口?

           1.数据框可以提供比RDD更容易掌握使用的接口。数据框的主要优点包括Spark数据源来源、结构化查询语言的数据框查询、各编程语言之间统一的接口。

           2.基于数据框的MLlib接口为多种机器学习算法与编程语言提供统一的接口。

           3.数据框有助于实现机器学习管道,特别是特征转换。管道指南中可查看详细信息。

           调用信息

           MLlib使用线性代数包Breeze,Breeze使用Netlib-java来优化数值问题。如果运行时本地包不可用,你将看到一个警告提示信息,然后使用纯虚拟机进行处理。

           考虑到运行二进制问题时的证书许可问题,我们默认不使用netlib-java的本地代理。安装netlib-java/Breeze来使用系统二进优化,请阅读netlib-java官方文档来获得安装说明。

           基于Python语言使用MLlib,需要安装1.4以上版本Nnmpy。

    中文指南目录

    1 管道          

    2特征提取、特征变换、特征选择

    2.1 特征提取

    2.1.1 词频-逆向文件频率(TF-IDF)

    2.1.2 Word2Vec

    2.1.3 计数向量器

    2.2 特征变换

    2.2.1 分词器

    2.2.2 停用词移除

    2.2.3 n-gram

    2.2.4 二值化

    2.2.5 主成分分析(PCA)

    2.2.6 多项式展开

    2.2.7 离散余弦变换(DCT)

    2.2.8 字符串-索引变换

    2.2.9 索引-字符串变换

    2.2.10 独热编码

    2.2.11 向量-索引变换

    2.2.12 正则化

    2.2.13 标准缩放

    2.2.14 最大值-最小值缩放

    2.2.15 最大值-平均值缩放

    2.2.16 离散化重组

    2.2.17 元素乘积

    2.2.18 SQL转换器

    2.2.19 向量汇编

    2.2.20 分位数求解器

    2.3 特征选择

    2.3.1 向量机

    2.3.2 R公式

    2.3.3 选择

    3 分类和回归

    3.1 分类

    3.1.1 逻辑回归

    3.1.2决策树分类

    3.1.3 随机森林分裂

    3.1.4 梯度迭代树分类

    3.1.5 多层感知机

    3.1.6 一对多分类器

    3.1.7 朴素贝叶斯

    3.2 回归

    3.2.1 广义线性模型

    3.2.2 决策树回归

    3.2.3 随机森林回归

    3.2.4 梯度迭代树回归

    3.2.5 生存回归

    3.2.6 保序回归

    4 聚类

    4.1 K均值聚类

    4.2 文档主题生成模型(LDA)

    4.3 二分K均值

    4.4 高斯混合模型(GMM)

    5 协同过滤

    6 模型选择和调试

    6.1 交叉检验

    6.2 训练检验分裂

    7 高级主题

    展开全文
  • pyspark MLlib基本使用

    千次阅读 2018-03-26 23:09:19
    MLlib中包含能够在集群上运行良好的并行算法,如kmeans、分布式RF、交替最小二乘等,这能够让MLib中的每个算法都能够适用于大规模数据集 也可以将同一算法的不同参数列表通过parallelize(),在不同节点上运行,最终...

    MLib

    基本概念

    • MLib其实就是将数据以RDD的形式进行表示,在分布式数据集上调用各种算法。

    使用方法

    • MLlib中包含能够在集群上运行良好的并行算法,如kmeans、分布式RF、交替最小二乘等,这能够让MLib中的每个算法都能够适用于大规模数据集
    • 也可以将同一算法的不同参数列表通过parallelize(),在不同节点上运行,最终找到性能最好的一组参数,这可以节省小规模数据集上参数选择的时间。

    对垃圾邮件进行分类

    • 使用基于SGD的LR完成分类任务
    from pyspark.mllib.regression import LabeledPoint
    from pyspark.mllib.feature import HashingTF
    from pyspark.mllib.classification import LogisticRegressionWithSGD
    
    spamFp = "file:///home/hadoop/code/spark/files/spam.txt"
    normalFp = "file:///home/hadoop/code/spark/files/normal.txt"
    spam= sc.textFile(spamFp)
    normal= sc.textFile(normalFp)
    
    # 将每个单词作为一个单独的特征
    tf = HashingTF(numFeatures=10000)
    spamFeatures = spam.map( lambda email : tf.transform(email.split(" ")) )
    normalFeatures = normal.map( lambda email : tf.transform(email.split(" ")) )
    
    # 构建LabelPoint,即每个向量都有它的label,之后联合构成整个训练集
    positiveExamples = spamFeatures.map( lambda features : LabeledPoint(1, features) )
    negativeExamples = normalFeatures.map( lambda features : LabeledPoint(0, features) )
    trainingData = positiveExamples.union(negativeExamples  )
    # SGD是迭代算法,因此在这里缓存数据集,加快运行速度
    trainingData.cache()
    
    # 训练
    model = LogisticRegressionWithSGD.train( trainingData )
    
    # 预测
    posTest = tf.transform( "O M G Get cheap stuff by sending money to ...".split(" ") )
    negTest = tf.transform( "I just want to play tennis now".split(" ") )
    
    print( "Prediction for positive test example : %g" % model.predict(posTest) )
    print( "Prediction for negative test example : %g" % model.predict(negTest) )
    Prediction for positive test example : 1
    Prediction for negative test example : 0
    

    MLlib中的数据类型

    • Vector:在mllib.linalg.vectors中,既支持稠密向量,也支持稀疏向量
    • LabeledPoint:在mllib.regression中,用于监督学习算法中,表示带有标签的数据点
    • Rating:在mllib.recommendation中,用于产品推荐,表示用户对一个产品的打分
    • 各种Label类:每个Model都是训练算法的结果,可以用train进行训练,用predict进行预测

    Vectors

    • 对于denseVector,MLlib可以通过Vectors.dense直接创建,也可以直接将numpy.array传递给Vectors,生成dense Vector
    • 对于sparseVector,首先设置其大小,然后传入一个包含index和value的dict或者是2个列表,分别表示indexes与value
    • sparseVector与denseVector都可以转化为array,array可以转化为denseVector,sparseVector不能直接转化为denseVector。
    • 需要注意:array与denseVector都不能直接转化为sparseVector
    • 参考链接:http://www.cnblogs.com/zhangbojiangfeng/p/6115263.html
    import numpy as np
    from pyspark.mllib.linalg import Vectors
    
    denseVec1 = np.array( [1, 2, 3] )
    denseVec2 = Vectors.dense( [4,5,6] )
    print( denseVec2 )
    denseVec2 = denseVec1
    print( denseVec2 )
    # print( Vectors.sparse(denseVec2) ) # 会出错,因为无法直接转换
    sparseVec1 = Vectors.sparse(4, {0:1.0, 2:2.0})
    sparseVec2 = Vectors.sparse( 4, [0,2], [1.0, 3.0] )
    print( sparseVec1.toArray() ) # 可以转化为array,也支持下标访问
    [4.0,5.0,6.0]
    [1 2 3]
    [1. 0. 2. 0.]
    

    算法

    • 特征提取主要是在mllib.feature中

    TF-IDF(词频-逆文档频率)

    • TFIDF是一种从文本文档生成特征向量的简单方法,文档中的词有2个统计值:TF与IDF,TF指的是每个词咋文档中出现的次数,IDF用于衡量一个词在整个文档语料库中出现的(逆)频繁程度
    • HashingTF用于计算TF,IDF用于IDF,hashingTF用的是哈希的方法,生成稀疏向量
    • hashingTF可以一次只运行在一个文档中,也可以运行于整个RDD中
    from pyspark.mllib.feature import HashingTF
    
    sentence = "hello world hello test"
    words = sentence.split(" ")
    tf = HashingTF(10000) # 构建一个向量,S=10000
    vec1 = tf.transform( words )
    print( vec1 )
    
    rdd = sc.wholeTextFiles("file:///home/hadoop/code/spark/files").map(lambda content: content[1].split(" "))
    vec2 = tf.transform( rdd ) # 对整个RDD对象进行转换,生成TF
    print( vec2.collect() )
    (10000,[745,830,2014],[2.0,1.0,1.0])
    [SparseVector(10000, {4704: 1.0}), SparseVector(10000, {0: 5.0, 82: 1.0, 103: 1.0, 365: 5.0, 455: 1.0, 503: 1.0, 509: 1.0, 940: 1.0, 1091: 1.0, 1320: 1.0, 1363: 2.0, 1395: 1.0, 1451: 2.0, 1458: 1.0, 1583: 1.0, 1683: 1.0, 1819: 2.0, 2220: 2.0, 2321: 3.0, 2403: 1.0, 2410: 1.0, 2634: 1.0, 2701: 1.0, 2824: 1.0, 3122: 1.0, 3289: 2.0, 3317: 1.0, 3342: 1.0, 4323: 1.0, 4373: 1.0, 4460: 1.0, 4671: 2.0, 4673: 1.0, 4837: 1.0, 4995: 1.0, 5146: 1.0, 5172: 1.0, 5336: 3.0, 5430: 1.0, 5469: 1.0, 5639: 1.0, 5706: 1.0, 5763: 1.0, 5831: 1.0, 5849: 1.0, 5878: 1.0, 5880: 1.0, 6043: 1.0, 6052: 2.0, 6147: 1.0, 6300: 2.0, 6384: 1.0, 6408: 1.0, 6582: 1.0, 6744: 1.0, 6910: 1.0, 7094: 1.0, 7119: 2.0, 7296: 2.0, 7566: 1.0, 7656: 1.0, 7785: 1.0, 7803: 1.0, 8070: 1.0, 8242: 1.0, 8479: 1.0, 8971: 1.0, 8977: 1.0, 9101: 3.0, 9163: 1.0, 9232: 1.0, 9241: 1.0, 9390: 1.0, 9399: 1.0, 9646: 1.0, 9878: 1.0}), SparseVector(10000, {4024: 1.0}), SparseVector(10000, {9057: 1.0}), SparseVector(10000, {365: 2.0, 455: 1.0, 601: 1.0, 945: 1.0, 1363: 1.0, 2321: 1.0, 2364: 1.0, 3870: 1.0, 3934: 1.0, 4755: 1.0, 6147: 1.0, 6300: 2.0, 6637: 1.0, 7119: 2.0, 7870: 1.0, 8242: 1.0, 8699: 1.0, 9106: 1.0, 9202: 1.0, 9435: 1.0})]
    
    • 注意:在上面的转换中,由于wholeTextFiles中的每个元素val是一个tuple,val[0]是文件名,val[1]是文件内容,因此在map的时候,需要注意lambda表达式的写法
    from pyspark.mllib.feature import HashingTF, IDF
    rdd = sc.wholeTextFiles("file:///home/hadoop/code/spark/files").map(lambda content: content[1].split(" "))
    tf = HashingTF()
    # 因为这里的tfVec使用了2次,因此可以cache一下
    tfVec = tf.transform(rdd).cache()# collect()
    
    idf = IDF()
    idfModel = idf.fit( tfVec )
    tfIdfVec = idfModel.transform( tfVec )
    print( tfIdfVec.take(2) )
    [SparseVector(1048576, {124416: 1.0986}), SparseVector(1048576, {0: 5.4931, 757: 1.0986, 1475: 1.3863, 6822: 1.0986, 22598: 1.0986, 36881: 1.0986, 46995: 1.0986, 87778: 1.0986, 97347: 1.0986, 110604: 1.0986, 139511: 1.0986, 146549: 1.0986, 151357: 3.2958, 154253: 3.4657, 183123: 1.0986, 204835: 1.0986, 206664: 1.0986, 235395: 0.6931, 238153: 2.1972, 243833: 1.0986, 250929: 2.0794, 264736: 1.0986, 270412: 2.1972, 287130: 1.0986, 302147: 1.0986, 321791: 2.1972, 348943: 1.3863, 369400: 1.0986, 376018: 1.0986, 380427: 2.1972, 399177: 1.0986, 450045: 1.0986, 463522: 0.6931, 464296: 1.0986, 465696: 2.1972, 479575: 1.0986, 503160: 1.0986, 524510: 1.0986, 526582: 1.0986, 573803: 1.0986, 585056: 1.0986, 588582: 1.0986, 589703: 1.0986, 594200: 3.2958, 606655: 1.0986, 631572: 1.0986, 640647: 1.0986, 648331: 1.0986, 657435: 1.0986, 685591: 0.6931, 698511: 1.0986, 706364: 1.3863, 717190: 1.0986, 745211: 1.0986, 759962: 1.0986, 764510: 1.0986, 770682: 1.0986, 817934: 1.0986, 824059: 1.0986, 828157: 1.0986, 858685: 1.0986, 863649: 1.0986, 871246: 1.0986, 874586: 1.0986, 879707: 1.0986, 886019: 1.0986, 895212: 1.0986, 902136: 1.0986, 910968: 1.0986, 935701: 1.0986, 938679: 1.0986, 961982: 1.0986, 971522: 1.0986, 972729: 1.0986, 974758: 1.0986, 979651: 1.0986, 997716: 2.1972})]
    

    对数据进行缩放

    • 可以使用StandScaler对数据进行缩放,下面的example是将数据的所有特征的平均值转化为0,方差转化为1。
    • mllib中将每一行视作一个特征,即每次操作时,都是对矩阵中的每一行的数据进行缩放
    from pyspark.mllib.feature import StandardScaler
    
    vec = Vectors.dense([[-1, 5, 1], [2, 0, 1]])
    print( vec )
    dataset = sc.parallelize( vec )
    scaler = StandardScaler( withMean=True, withStd=True )
    model = scaler.fit( dataset )
    result = model.transform( dataset ).collect()
    print( result )
    [[-1.  5.  1.],[2. 0. 1.]]
    [DenseVector([-0.7071, 0.7071, 0.0]), DenseVector([0.7071, -0.7071, 0.0])]
    
    • 使用Normalizer可以使得数据的L-p范数转化为1,这个在归一化以及预测概率等时常用,默认是L2范数,也可以自己指定
    from pyspark.mllib.feature import Normalizer
    vec = Vectors.dense( [[3,4], [5, 5], [6,8]] )
    data = sc.parallelize( vec )
    normalizer = Normalizer()
    result = normalizer.transform( data )
    print( result.collect() )
    [DenseVector([0.6, 0.8]), DenseVector([0.7071, 0.7071]), DenseVector([0.6, 0.8])]
    

    统计

    • mllib提供了很多广泛的统计函数
    • 统计函数是对每一列进行处理
    from pyspark.mllib.stat import Statistics 
    vec = Vectors.dense( [[3,4], [5, 5], [6,8]] )
    data = sc.parallelize( vec )
    stat = Statistics.colStats( data )
    corr = Statistics.corr( data ) # 计算相关系数
    print( stat.mean(), stat.variance() )
    print( corr )
    [4.66666667 5.66666667] [2.33333333 4.33333333]
    [[1.         0.89104211]
     [0.89104211 1.        ]]
    

    线性回归

    • 在mllib.regression
    • 对于这种问题,最好需要将其归一化,否则SGD求解很容易发散。对于下面的例子,如果将X,即特征的范围取得非常大(比如下面range里面设置最大值为20之类的),则求得的解很有可能就会发散。
    • 除此之外,也有Lasso等加入正则化方法的线性回归
    import matplotlib.pyplot as plt
    import random as rnd
    %matplotlib inline
    import numpy as np
    from pyspark.mllib.regression import LabeledPoint, LinearRegressionWithSGD, LassoWithSGD
    
    x = np.linspace(0,4,20)
    y = 2*x  + 2 + 4*np.random.random(x.shape)-2
    
    data = sc.parallelize(np.column_stack( (x, y) ))
    
    labeledData = data.map( lambda d : LabeledPoint(d[1] , d[0:1]) )
    model = LinearRegressionWithSGD.train( labeledData, iterations=100, intercept=True )
    y_pred = model.predict( np.array(x).reshape(1,-1) )
    print( "weights : %s, intercept : %s" % (model.weights, model.intercept) )
    
    plt.plot( x,y, 'k*', label="real" )
    plt.plot( x,y_pred, 'g--', label="pred with intercept" )
    plt.show()
    
    weights : [1.960302173749138], intercept : 1.7728141318262047
    

    这里写图片描述

    Logistic Regression

    • LR用于监督式分类问题,可以使用SGD等方法对LR进行训练,
    • clearThreshold之后,LR会输出原始概率,也可以设置概率阈值,直接输出分类结果
    from pyspark.mllib.classification import LogisticRegressionWithSGD
    
    data = [LabeledPoint(0.0, [0.0, 1.0]), LabeledPoint(1.0, [1.0, 0.0])]
    lrm = LogisticRegressionWithSGD.train( sc.parallelize(data), iterations=20 )
    print( lrm.predict([1,0]) )
    lrm.clearThreshold()
    print( lrm.predict([1,0]) )
    lrm.setThreshold(0.5)
    print( lrm.predict([1,0]) )
    1
    0.7763929145707635
    1
    

    其他

    • mllib同时也支持SVM、朴素贝叶斯、决策树、随机森林等机器学习方法

    决策树的超参数

    • data:由LabeledPoint组成的rdd
    • numClasses:分类任务时,有该参数,表示类别数量
    • impurity:节点的不纯度测量,对于分类可以使用gini系数或者信息熵,对回归只能是varainace
    • maxDepth:数的最大深度,默认为5。
    • maxBins:在构建各节点时,将数据分到多少个箱子中
    • cateoricalFeaturesInfo:指定哪些特征是用于分类的,以及有多少个分类。

    随机森林

    除了上面的超参数之外,还有
    * numTrees,即决策树的个数。
    * featureSubsetStrategy:在每个节点上做决定时所考虑的特征的数量,可以是auto、all、sqrt、log2、onethird等,数目越大,计算的代价越大。
    * seed:采用的随机数种子

    聚类任务

    • MLlib中包含kmeans以及kmeans||两种算法,后者可以为并行化环境提供更好的初始化策略。除了聚类的目标数量K之外,还包括以下几个超参数
    • initializationMode:初始化聚类中心的方法,可以是kmeans||或者randomkmeans||的效果一般更好,但是更加耗时
    • maxIterations:最大迭代次数,默认为100
    • runs:算法并发运行的数目,mllib的kmeans支持从多个起点并发执行,然后选择最佳的结果。

    下面的代码中,首先训练一个kmeans模型,然后对其分类结果进行可视化

    from pyspark.mllib.clustering import KMeans
    
    data = 2*np.random.random((30, 2))
    data[10:20,:] = data[10:20,:]+4
    data[20:,:] = data[20:,:]+8
    
    plt.plot( data[:,0], data[:,1], 'r+' )
    plt.show()
    
    rddData = sc.parallelize( data )
    model = KMeans.train( rddData, 3, maxIterations=100, initializationMode="kmeans||",
                        seed=50, initializationSteps=5, epsilon=1e-4)

    这里写图片描述

    result = np.zeros((data.shape[0], ))
    for ii in range( data.shape[0] ):
        result[ii] = model.predict( data[ii,:] )
    colors = ["r+", "b+", "g+"]
    for ii in range(3):
        plt.plot( data[result == ii, 0], data[result == ii, 1], colors[ii] )
    
    plt.show()

    这里写图片描述

    展开全文
  • pyspark:ML和MLlib

    千次阅读 2020-03-25 13:45:15
    Spark有两个用于机器学习的库,分别是ML和MLlib,可以把实际的机器学习以简单、可伸缩并且无缝的方式与Spark整合起来。Spark中ML和MLlib的主要区别和联系如下: (1)目前常用的机器学习功能2个库都能满足需求; ...
  • MLlib算法简介

    万次阅读 2015-04-10 12:01:33
    主要的机器学习的算法目前在MLlib中都已经提供了,分类回归、聚类、关联规则、推荐、降维、优化、特征抽取筛选、用于特征预处理的数理统计方法、以及算法的评测
  • Spark中ml和mllib的区别

    千次阅读 2018-01-24 20:56:55
    Spark中ml和mllib的主要区别和联系如下: ml和mllib都是Spark中的机器学习库,目前常用的机器学习功能2个库都能满足需求。spark官方推荐使用ml, 因为ml功能更全面更灵活,未来会主要支持ml,mllib很有可能会被...
  • 请别再问我Spark的MLlib和ML库的区别

    万次阅读 2017-12-10 09:56:31
    机器学习库(MLlib)指南 MLlib是Spark的机器学习(ML)库。其目标是使实际的机器学习可扩展和容易。在高层次上,它提供了如下工具: ML算法:通用学习算法,如分类,回归,聚类和协同过滤 特征提取,特征...
  • spark:ML和MLlib的区别

    千次阅读 2018-05-21 11:02:15
    ML和MLlib的区别如下ML是升级版的MLlib,最新的Spark版本优先支持ML。ML支持DataFrame数据结构和Pipelines,而MLlib仅支持RDD数据结构。ML明确区分了分类模型和回归模型,而MLlib并未在顶层做此类区分。ML通过...
  • spark mllib的优缺点分析

    千次阅读 2016-06-25 19:56:00
    spark机器学习的有点和缺点
  • 搭建sparkmllib开发环境的一些坑-----

    千次阅读 2018-04-02 18:44:50
    实现了在分布式的大数据集群上做机器学习的功能,是目前对分布式支持较好的机器学习框架,除此之外支持分布式的机器学习框架还有tensorflow和deeplearning4j,但sparkmllib天生和hadoop无缝结合,不过sparkmllib的短...
  • 《Spark MLlib 机器学习算法与源码解析》spark是一个开源集群运算框架,最初是由加州大学柏克利分校AMPLab所开发。Spark使用了内存内运算技术,在内存上的运算速度比Hadoop MapReduce的运算速度快上100倍,即便是在...
  • Spark MLlib 机器学习算法与源码解析  01、Spark MLlib基础入门  02、 Spark MLlib矩阵向量  03、Spark MLlib线性回归算法  04、Spark MLlib逻辑回归算法  05、Spark MLlib贝叶斯分类算法  06、Spark ...
  • 既生Mahout,何生Spark MLlib

    千次阅读 2017-12-29 19:09:22
    Apache Mahout与Spark MLlib均是Apache下的项目,都是机器学习算法库,并且现在mahout已经不再接受MapReduce的作业了,也向Spark转移。那两者有什么关系呢?我们在应用过程中该作何取舍?既然已经有了Mahout,为什么...
  • Spark MLlib之逻辑回归

    千次阅读 2019-06-09 23:10:41
    package mllib import org.apache.log4j.{Level, Logger} import org.apache.spark.mllib.classification.{LogisticRegressionModel, LogisticRegressionWithLBFGS} import org.apache.spark.mllib.evaluation.Mul....
  • 1 Spark机器学习 spark MLlib 入门

    万次阅读 2018-09-17 10:59:14
    spark中也提供了机器学习的包,就是MLlibMLlib中也包含了大部分常用的算法,分类、回归、聚类等等,借助于spark的分布式特性,机器学习在spark将能提高很多的速度。MLlib底层采用数值计算库Breeze和基础线性代数...
  • Spark MLlib机器学习—封面

    千次阅读 2016-03-18 12:02:43
    Spark MLlib机器学习,目前已经正在印刷中,预计4月初可以正式上市,请大家多多关注! 封面如下:
  • MLlib支持单机local vectors 和 matrices以及分布式矩阵。其中local vectors 和 matrices是一种用于公共接口的简单数据结
  • spark mllib算法思想总结

    千次阅读 2019-02-15 09:29:18
    Spark MLlib全部算法总结(2.1.0版) 说明:总结算法为Spark2.1.0中Mllib中源码算法,参照网络链接及书籍整理而成。 算法按计算过程分两大类:监督学习(Supervised Learning)和无监督学习(Unsupervised ...
1 2 3 4 5 ... 20
收藏数 13,936
精华内容 5,574
关键字:

mllib