利用Spark-mllab进行聚类，分类，回归分析的代码实现(python)

      Spark作为一种开源集群计算环境，具有分布式的快速数据处理能力。而Spark中的Mllib定义了各种各样用于机器学习的数据结构以及算法。Python具有Spark的API。需要注意的是，Spark中，所有数据的处理都是基于RDD的。

首先举一个聚类方面的详细应用例子Kmeans：

　　　下面代码是一些基本步骤，包括外部数据，RDD预处理，训练模型，预测。

#coding:utf-8
from numpy import array
from math import sqrt
from pyspark import SparkContext
from pyspark.mllib.clustering import KMeans, KMeansModel


if __name__ == "__main__":
    sc = SparkContext(appName="KMeansExample",master='local')  # SparkContext


    # 读取并处理数据
    data = sc.textFile("./kmeans_data.txt")
    print data.collect()
    parsedData = data.map(lambda line: array([float(x) for x in line.split(' ')]))

    # 训练数据
    print parsedData.collect()
    clusters = KMeans.train(parsedData, k=2, maxIterations=10,
                            runs=10, initializationMode="random")

    #求方差之和
    def error(point):
        center = clusters.centers[clusters.predict(point)]
        return sqrt(sum([x**2 for x in (point - center)]))
    WSSSE = parsedData.map(lambda point: error(point)).reduce(lambda x, y: x + y)

    print("Within Set Sum of Squared Error = " + str(WSSSE))

    #聚类结果
    def sort(point):
        return clusters.predict(point)
    clusters_result = parsedData.map(sort)
    # Save and load model
    # $example off$
    print '聚类结果：'
    print clusters_result.collect()
    sc.stop()

可以看到在利用Spark进行机器学习时，我调用了一个外部的开源包numpy，并利用了数组作为数据结构。而在Mllib中其实已经定义了各种用于机器学习的数据结构，下面简单介绍两种在分类和回归分析中可以用到的DS。

稀疏向量（SparseVector）：稀疏向量是指向量元素中有许多值是0的向量。

其初始化与简单操作如下：　　

# coding:utf-8
from pyspark.mllib.linalg import *
v0 = SparseVector(4, [1, 2], [2, 3.0])  # 稀疏向量，第一个参数为维度，第二个参数是非0维度的下标的集合，第三个参数是非0维度的值的集合
v1 = SparseVector(4,{1: 3, 2: 4}) # 第一个参数是维度，第二个参数是下标和维度组成的字典
print v0.dot(v1)  # 计算点积
print v0.size  # 向量维度
print v0.norm(0)  # 返回维度0的值
print v0.toArray()  # 转化为array
print v0.squared_distance(v1)  # 欧式距离

　　spark中的稀疏向量可以利用list或者dict进行初始化。

向量标签（Labeled  point）：向量标签就是在向量和标签的组合，分类和回归中，标签可以作为分类中的类别，也可以作为回归中的实际值。

from pyspark.mllib.regression import LabeledPoint
data = [
  LabeledPoint(1.0, [1.0, 1.0]),
  LabeledPoint(4.0, [1.0, 3.0]),
  LabeledPoint(8.0, [2.0, 3.0]),
  LabeledPoint(10.0, [3.0, 4.0])]
print data[0].features
print data[0].label

下面是mllib中用于回归分析的一些基本实现（线性回归，岭回归）：

# coding:UTF-8
from pyspark.mllib.regression import LabeledPoint
from pyspark.mllib.regression import LinearRegressionWithSGD
from pyspark.context import SparkContext

# ----------------线性回归--------------

import numpy as np
sc = SparkContext(master='local',appName='Regression')
data = [
  LabeledPoint(1.0, [1.0, 1.0]),
  LabeledPoint(2.0, [1.0, 1.4]),
  LabeledPoint(4.0, [2.0, 1.9]),
  LabeledPoint(6.0, [3.0, 4.0])]  # 训练集
lrm = LinearRegressionWithSGD.train(sc.parallelize(data), iterations=100, initialWeights=np.array([1.0,1.0]))
print lrm.predict(np.array([2.0,1.0]))  # 利用训练出的回归模型进行预测

import os, tempfile
from pyspark.mllib.regression import LinearRegressionModel
from pyspark.mllib.linalg import SparseVector

path = tempfile.mkdtemp()
lrm.save(sc, path)  # 将模型保存至外存
sameModel = LinearRegressionModel.load(sc, path)  # 读取模型
print sameModel.predict(SparseVector(2, {0: 100.0, 1: 150}))  # 利用稀疏向量作为数据结构,返回单个预测值
test_set = []
for i in range(100):
  for j in range(100):
    test_set.append(SparseVector(2, {0: i,1: j}))
print sameModel.predict(sc.parallelize(test_set)).collect()  # 预测多值，返回一个RDD数据集
print sameModel.weights  # 返回参数


# -----------------岭回归------------------

from pyspark.mllib.regression import RidgeRegressionWithSGD
data = [
  LabeledPoint(1.0, [1.0, 1.0]),
  LabeledPoint(4.0, [1.0, 3.0]),
  LabeledPoint(8.0, [2.0, 3.0]),
  LabeledPoint(10.0, [3.0, 4.0])]
train_set = sc.parallelize(data)
rrm = RidgeRegressionWithSGD.train(train_set, iterations=100, initialWeights=np.array([1.0,1.0]))
test_set = []
for i in range(100):
  for j in range(100):
    test_set.append(np.array([i, j]))
print rrm.predict(sc.parallelize(test_set)).collect()
print rrm.weights

 上述代码只是让大家弄懂一下简单的操作，对于数据的预处理没有在RDD的基础上做。

下面是一些分类算法的基本实现：

# coding:utf-8
from pyspark import SparkContext
from pyspark.mllib.regression import LabeledPoint

print '-------逻辑回归-------'
from pyspark.mllib.classification import LogisticRegressionWithSGD
sc = SparkContext(appName="LRWSGD", master='local')
dataset = []
for i in range(100):
    for j in range(100):
        dataset.append([i,j])
dataset = sc.parallelize(dataset)  # 并行化数据，转化为RDD

data =[LabeledPoint(0.0, [0.0, 100.0]),LabeledPoint(1.0, [100.0, 0.0]),]

lrm = LogisticRegressionWithSGD.train(sc.parallelize(data), iterations=10)  # 第二个参数是迭代次数
print lrm.predict(dataset).collect()

lrm.clearThreshold()
print lrm.predict([0.0, 1.0])
# ----------------------------------------------------------
from pyspark.mllib.linalg import SparseVector
from numpy import array
sparse_data = [
    LabeledPoint(0.0, SparseVector(2, {0: 0.0, 1: 0.0})),
    LabeledPoint(1.0, SparseVector(2, {1: 1.0})),
    LabeledPoint(0.0, SparseVector(2, {0: 1.0})),
    LabeledPoint(1.0, SparseVector(2, {1: 2.0}))
]
train = sc.parallelize(sparse_data)
lrm = LogisticRegressionWithSGD.train(train, iterations=10)
print lrm.predict(array([0.0, 1.0]))  # 对单个数组进行预测
print lrm.predict(SparseVector(2, {1: 1.0}))  # 对单个稀疏向量进行预测

print '------svm-------'

from pyspark.mllib.classification import SVMWithSGD
svm = SVMWithSGD.train(train,iterations=10)
print svm.predict(SparseVector(2, {1: 1.0}))

print '------bayes------'
from pyspark.mllib.classification import NaiveBayes
nb = NaiveBayes.train(train)
print nb.predict(SparseVector(2, {1: 1.0}))

版权都是我所有的，(*^__^*) 哈哈哈～