Python Spark MLlib之SVM支持向量机

数据准备

和决策树分类一样，依然使用StumbleUpon Evergreen数据进行实验。

Local模式启动ipython notebook

cd ~/pythonwork/ipynotebook
PYSPARK_DRIVER_PYTHON=ipython PYSPARK_DRIVER_PYTHON_OPTS="notebook" MASTER=local[*] pyspark

导入并转换数据

## 定义路径
global Path
if sc.master[:5]=="local":
    Path="file:/home/yyf/pythonwork/PythonProject/"
else:
    Path="hdfs://master:9000/user/yyf/"
## 读取train.tsv
print("开始导入数据...")
rawDataWithHeader = sc.textFile(Path+"data/train.tsv")
## 取第一项数据
header = rawDataWithHeader.first()
## 剔除字段名（特征名）行，取数据行
rawData = rawDataWithHeader.filter(lambda x:x!=header)
## 将双引号"替换为空字符（剔除双引号）
rData = rawData.map(lambda x:x.replace("\"",""))
## 以制表符分割每一行
lines = rData.map(lambda x: x.split("\t"))
print("共有："+str(lines.count())+"项数据")

---

数据预处理

1、处理特征

该数据集tran.tsv和test.tsv的第3个字段是alchemy_category网页分类，是一个离散值特征，要采用OneHotEncode的方式进行编码转换为数值特征，主要过程如下：

• (1) 创建categoriesMap字典，key为网页类别名，value为数字（网页类别名的索引值），每个类别名对应一个索引值
• (2) 根据categoriesMap字典查询每个alchemy_category特征值对应的索引值，例如business的索引值categoryIdx为2
• (3) 根据categoryIdx=2，以OneHotEncodeer的方式转换为一个列表categoryFeatures List，该列表长度为14（统计所有网页类别），categoryIdx=2对应的列表为[0,0,1,0,0,0,0,0,0,0,0,0,0,0]。

建立categoriesMap网页分类字典

categoriesMap = lines.map(lambda fields: fileds[3]).distinct().zipWithIndex().collectAsMap()

其中，lines.map()表示处理之前读取的数据的每一行，.map(lambda fields: fileds[3])表示读取第3个字段，.distinct()保留不重复数据，.zipWithIndex()将第3个字段中不重复的数据进行编号，.collectAsMap()转换为dict字典格式

将每个alchemy_category网页分类特征值转化为列表categoryFeatures List

## 给定一个alchemy_category网页分类特征转化为OneHot 列表
## 查询对应索引值
import numpy as np
categoryIdx = categoriesMap[lines.first()[3]]
OneHot = np.zeros(len(categoriesMap))
OneHot[categoryIdx] = 1
print(OneHot)

对于第4~25字段的数值特征，要转换为数值，用float函数将字符串转换为数值，同时简单处理缺失值”?”为0.

整个处理特征的过程可以封装成一个函数：

import numpy as np

def convert(v):
    """处理数值特征的转换函数"""
    return (0 if v=="?" else float(v))

def process_features(line, categoriesMap, featureEnd):
    """处理特征，line为字段行，categoriesMap为网页分类字典，featureEnd为特征结束位置，此例为25"""
    ## 处理alchemy_category网页分类特征
    categoryIdx = categoriesMap[line[3]]
    OneHot = np.zeros(len(categoriesMap))
    OneHot[categoryIdx] = 1
    ## 处理数值特征
    numericalFeatures = [convert(value) for value in line[4:featureEnd]]
    # 返回拼接的总特征列表
    return np.concatenate((OneHot, numericalFeatures))


## 处理特征生成featureRDD
featureRDD = lines.map(lambda r: process_features(r, categoriesMap, len(r)-1))

2、数据标准化

对数值特征进行标准化：

## 数据标准化
from pyspark.mllib.feature import StandardScaler   # 导入数据标准化模块

## 对featureRDD进行标准化
stdScaler = StandardScaler(withMean=True, withStd=True).fit(featureRDD)  # 创建一个标准化实例
ScalerFeatureRDD = stdScaler.transform(featureRDD)
ScalerFeatureRDD.first()

查看标准化之后的数值特征：

3、处理label构成labelpoint数据格式

处理标签数据（test.tsv最后一列），只需把字符串类型转化为float型：

## 处理标签
def process_label(line):
    return float(line[-1])  # 最后一个字段为类别标签

labelRDD = lines.map(lambda r: process_label(r))

构成labelpointRDD，Spark Mllib分类任务所支持的数据类型为LabeledPoint格式，LabeledPoint数据由标签label和特征feature组成。构建LabeledPoint数据：

## 构建LabeledPoint数据：
from pyspark.mllib.regression import LabeledPoint

## 拼接标签和特征
labelpoint = labelRDD.zip(ScalerFeatureRDD)
labelpointRDD = labelpoint.map(lambda r: LabeledPoint(r[0],r[1]))
labelpointRDD.first()

4、划分训练集、验证集及测试集

## 划分训练集、验证集和测试集
(trainData, validationData, testData) = labelpointRDD.randomSplit([7,1,2])

# 将数据暂存在内存中，加快后续运算效率
trainData.persist()
validationData.persist()
testData.persist()

---

训练模型

Spark Mllib封装了SVMWithSGD支持向量机分类器，其.train()方法训练模型，调用形式如下：

SVMWithSGD.train(data, iterations=100, step=1.0, regParam=0.01,
              miniBatchFraction=1.0, initialWeights=None, regType="l2",
              intercept=False, validateData=True, convergenceTol=0.001)

主要参数说明如下：

• data：输入的训练数据，数据格式为LabeledPoint格式
• iterations：使用SGD的迭代次数，默认为100
• step：每次执行SGD迭代步长大小，默认为1
• miniBatchFraction：小批量随机梯度下降法每次参与计算的样本比例，数值在0~1，默认为1
• initialWeights：初始化系数，默认为None
• regParam：正则项系数大小
• regType：正则化类型”l1”或”l2”或”None”，默认为”l2”,

## 使用SVM分类模型进行训练
from pyspark.mllib.classification import SVMWithSGD
## 使用默认参数训练模型
model = SVMWithSGD.train(trainData, iterations=100, step=1.0, miniBatchFraction=1.0, regParam=0.01, regType="l2")

---

模型评估

为简单起见使用预测准确率作为模型评估的指标，自定义函数计算准确率（好吧，其实是pyspark MLlib的evaluation中的类用的时候老报错。。不知道什么原因）

## 定义模型评估函数
def ModelAccuracy(model, validationData):
    ## 计算模型的准确率
    predict = model.predict(validationData.map(lambda p:p.features))
    predict = predict.map(lambda p: float(p))
    ## 拼接预测值和实际值
    predict_real = predict.zip(validationData.map(lambda p: p.label))
    matched = predict_real.filter(lambda p:p[0]==p[1])
    accuracy =  float(matched.count()) / float(predict_real.count())
    return accuracy

acc = ModelAccuracy(model, validationData)
## 打印accuracy
print("accuracy="+str(acc))

返回结果：accuracy=0.646563814867

---

模型参数调优

逻辑回归的参数：迭代次数iterations，SGD步长step，训练批次大小miniBatchFraction, 正则项系数regParam=0.01, 正则化方式regType=”l2”，会影响模型的准确率及训练的时间，下面对不同模型参数取值进行测试评估。

创建trainEvaluateModel函数包含训练与评估功能，并计算训练评估的时间。

## 创建trainEvaluateModel函数包含训练与评估功能，并计算训练评估的时间。
from time import time

def trainEvaluateModel(trainData, validationData, iterations, step, miniBatchFraction, regParam, regType):
    startTime = time()
    ## 创建并训练模型
    Model = SVMWithSGD.train(trainData, iterations=iterations, step=step, 
                                            miniBatchFraction=miniBatchFraction, regParam=regParam, regType=regType)
    ## 计算accuracy
    accuracy = ModelAccuracy(Model, validationData)

    duration = time() - startTime   # 持续时间
    print("训练评估：参数"+"iterations="+str(iterations) + 
         ",  step="+str(step)+",  miniBatchFraction="+str(miniBatchFraction)+
          ", regParam"+str(regParam)+", regType=" + str(regType) +"\n"+
         "===>消耗时间="+str(duration)+",  准确率accuracy="+str(accuracy))
    return accuracy, duration, iterations, step, miniBatchFraction, regParam, regType, model

1、评估iterations参数

分别测试iterations迭代次数为[10, 100, 1000, 10000] 的模型运行时间及在验证集上的分类准确率

## 评估iterations参数
iterationsList = [10, 100, 1000, 10000] 
stepList = [1]
miniBatchFractionList = [1]
regParamList = [0.01]
regTypeList = ["l2"]

## 返回结果存放至metries中
metrics = [trainEvaluateModel(trainData, validationData,iterations, step, miniBatchFraction, regParam, regType)
          for iterations in iterationsList
          for step in stepList
          for miniBatchFraction in miniBatchFractionList
          for regParam in regParamList
          for regType in regTypeList]

运行结果：

训练评估：参数iterations=10,  step=1,  miniBatchFraction=1, regParam0.01, regType=l2
===>消耗时间=0.995012998581,  准确率accuracy=0.652173913043
训练评估：参数iterations=100,  step=1,  miniBatchFraction=1, regParam0.01, regType=l2
===>消耗时间=2.74122095108,  准确率accuracy=0.646563814867
训练评估：参数iterations=1000,  step=1,  miniBatchFraction=1, regParam0.01, regType=l2
===>消耗时间=2.00927209854,  准确率accuracy=0.646563814867
训练评估：参数iterations=10000,  step=1,  miniBatchFraction=1, regParam0.01, regType=l2
===>消耗时间=1.96263098717,  准确率accuracy=0.646563814867

观察发现，iterations小的时候运行时间少，iterations大到一定程度，运行时间差不多。分类准确率也都很接近，由此看来，iterations可能不是关键。

---

2、评估参数step

分别测试step为[0.1, 1, 10, 100, 500, 1000] 的模型运行时间及在验证集上的分类准确率

## 评估istep参数
iterationsList = [100] 
stepList = [0.01, 1, 10, 100, 500]
miniBatchFractionList = [1]
regParamList = [0.01]
regTypeList = ["l2"]

## 返回结果存放至metries中
metrics = [trainEvaluateModel(trainData, validationData,iterations, step, miniBatchFraction, regParam, regType)
          for iterations in iterationsList
          for step in stepList
          for miniBatchFraction in miniBatchFractionList
          for regParam in regParamList
          for regType in regTypeList]

运行结果：

训练评估：参数iterations=100,  step=0.1,  miniBatchFraction=1, regParam0.01, regType=l2
===>消耗时间=2.24229192734,  准确率accuracy=0.656381486676
训练评估：参数iterations=100,  step=1,  miniBatchFraction=1, regParam0.01, regType=l2
===>消耗时间=2.11195993423,  准确率accuracy=0.646563814867
训练评估：参数iterations=100,  step=10,  miniBatchFraction=1, regParam0.01, regType=l2
===>消耗时间=1.82550406456,  准确率accuracy=0.642356241234
训练评估：参数iterations=100,  step=100,  miniBatchFraction=1, regParam0.01, regType=l2
===>消耗时间=1.71144795418,  准确率accuracy=0.583450210379
训练评估：参数iterations=100,  step=500,  miniBatchFraction=1, regParam0.01, regType=l2
===>消耗时间=1.78000092506,  准确率accuracy=0.50350631136
训练评估：参数iterations=100,  step=1000,  miniBatchFraction=1, regParam0.01, regType=l2
===>消耗时间=1.95169901848,  准确率accuracy=0.468443197756

观察发现，步长过小或过大，运行时间都会增加，而步长过大会导致准确率accuracy降低。

3、评估参数训练批次大小miniBatchFraction

分别测试miniBatchFraction为[[0.01, 0.1, 0.5, 1]] 的模型运行时间及在验证集上的分类准确率

## 评估miniBatchFractionList参数
iterationsList = [100] 
stepList = [100]
miniBatchFractionList = [0.01, 0.1, 0.5, 1]
regParamList = [0.01]
regTypeList = ["l2"]

## 返回结果存放至metries中
metrics = [trainEvaluateModel(trainData, validationData,iterations, step, miniBatchFraction, regParam, regType)
          for iterations in iterationsList
          for step in stepList
          for miniBatchFraction in miniBatchFractionList
          for regParam in regParamList
          for regType in regTypeList]

运行结果：

训练评估：参数iterations=100,  step=1,  miniBatchFraction=0.01, regParam0.01, regType=l2
===>消耗时间=1.71210098267,  准确率accuracy=0.647966339411
训练评估：参数iterations=100,  step=1,  miniBatchFraction=0.1, regParam0.01, regType=l2
===>消耗时间=1.34743785858,  准确率accuracy=0.646563814867
训练评估：参数iterations=100,  step=1,  miniBatchFraction=0.5, regParam0.01, regType=l2
===>消耗时间=1.30253577232,  准确率accuracy=0.643758765778
训练评估：参数iterations=100,  step=1,  miniBatchFraction=1, regParam0.01, regType=l2
===>消耗时间=1.37389492989,  准确率accuracy=0.646563814867

参数miniBatchFractionList影响不显著

---

4、评估参数正则项系数regParam及正则化方式regType

分别测试regParam为 [0.01, 0.1, 1,10, 100]的模型运行时间及在验证集上的分类准确率
测试结果：

训练评估：参数iterations=100,  step=1,  miniBatchFraction=1, regParam0.01, regType=l2
===>消耗时间=1.33343195915,  准确率accuracy=0.646563814867
训练评估：参数iterations=100,  step=1,  miniBatchFraction=1, regParam0.1, regType=l2
===>消耗时间=0.793405056,  准确率accuracy=0.649368863955
训练评估：参数iterations=100,  step=1,  miniBatchFraction=1, regParam1, regType=l2
===>消耗时间=0.505378007889,  准确率accuracy=0.650771388499
训练评估：参数iterations=100,  step=1,  miniBatchFraction=1, regParam10, regType=l2
===>消耗时间=0.927163124084,  准确率accuracy=0.639551192146
训练评估：参数iterations=100,  step=1,  miniBatchFraction=1, regParam100, regType=l2
===>消耗时间=1.36627006531,  准确率accuracy=0.360448807854

值得注意的是，如果正则化系数过大，会使得逻辑回归各个特征相对应的系数变得很小，失去预测效果。

分别测试正则化方式参数regType=[“l2”,”l1”,None]
运行结果：

训练评估：参数iterations=100,  step=1,  miniBatchFraction=1, regParam1, regType=l2
===>消耗时间=0.544511795044,  准确率accuracy=0.650771388499
训练评估：参数iterations=100,  step=1,  miniBatchFraction=1, regParam1, regType=l1
===>消耗时间=0.370025873184,  准确率accuracy=0.465638148668
训练评估：参数iterations=100,  step=1,  miniBatchFraction=1, regParam1, regType=None
===>消耗时间=1.3747150898,  准确率accuracy=0.643758765778

观察发现，此例可能不宜采用l1正则化。

---

选择最佳模型参数组合

以网格搜索的方式进行查找：

## 定义函数gridSearch网格搜索最佳参数组合

def gridSearch(trainData, validationData, iterationsList, stepList, miniBatchFractionList, regParamList, regTypeList):
    metrics = [trainEvaluateModel(trainData, validationData,iterations, step, miniBatchFraction, regParam, regType)
          for iterations in iterationsList
          for step in stepList
          for miniBatchFraction in miniBatchFractionList
          for regParam in regParamList
          for regType in regTypeList]
    # 按照accuracy从大到小排序，返回最大accuracy的参数组合
    sorted_metics = sorted(metrics, key=lambda k:k[0], reverse=True)
    best_parameters = sorted_metics[0]
    print("最佳参数组合："+"iterations="+str(best_parameters[2]) + 
         ",  step="+str( best_parameters[3])+",  miniBatchFraction="+str( best_parameters[4])+
          ", regParam"+str( best_parameters[5])+", regType=" + str( best_parameters[6]) +"\n"+ "准确率accuracy="+str( best_parameters[0]))
    return  best_parameters
## 参数组合
iterationsList = [10, 100,100] 
stepList = [1, 10]
miniBatchFractionList = [0.1, 1]
regParamList = [0.001, 0.01, 0.1]
regTypeList = ["l2","l1"]

## 调用函数返回最佳参数组合
best_parameters = gridSearch(trainData, validationData, iterationsList, stepList, miniBatchFractionList, regParamList, regTypeList)

得出最佳参数组合为：iterations=100, step=10, miniBatchFraction=0.1, regParam0.001, regType=l2
相应的在验证集上的准确率为：accuracy=0.661991584853

---

判断是否发生过拟合及模型预测

1、判断是否过拟合

前面已经得到最佳参数组合iterations=100, step=10, miniBatchFraction=0.1, regParam0.001, regType=l2及相应的accuracy。使用该最佳参数组合作用于测试数据，是否会过拟合

## 使用最佳参数组合iterations=100,  step=10,  miniBatchFraction=0.1, regParam0.001, regType=l2训练模型
best_model = SVMWithSGD.train(trainData, iterations=100, step=10, 
                                            miniBatchFraction=0.1, regParam=0.001, regType="l2")
trainACC = ModelAccuracy(best_model, trainData)
testACC =  ModelAccuracy(best_model, testData)
print("training: accurary="+str(trainACC))
print("testing: accurary="+str(testACC))

返回结果：

training: accurary=0.679861644889
testing: accurary=0.638700947226

二者接近，说明模型没有明显的过拟合产生。

2、使用模型进行预测

使用最佳参数组合对test.tsv中的数据进行预测

## 使用模型进行预测
## 使用模型进行预测
def predictData(sc,model,categoriesMap):
    print("开始导入数据...")
    rawDataWithHeader = sc.textFile(Path+"data/test.tsv")
    ## 取第一项数据
    header = rawDataWithHeader.first()
    ## 剔除字段名（特征名）行，取数据行
    rawData = rawDataWithHeader.filter(lambda x:x!=header)
    ## 将双引号"替换为空字符（剔除双引号）
    rData = rawData.map(lambda x:x.replace("\"",""))
    ## 以制表符分割每一行
    lines = rData.map(lambda x: x.split("\t"))
    ## 预处理测试数据集(都是特征字段)
    testDataRDD=lines.map(lambda r: process_features(r, categoriesMap, len(r)))
    ## 数据标准化

    stdScaler = StandardScaler(withMean=True, withStd=True).fit(testDataRDD)  # 创建一个标准化实例
    ScalertestRDD = stdScaler.transform(testDataRDD)
    DescDict={0:"暂时型(ephemeral)网页",
              1:"长久型(evergreen)网页"}
    ## 预测前5项数据
    for i in range(5):
        predictResult=model.predict(ScalertestRDD.take(5)[i])
        print("网址："+str(lines.collect()[i][0])+"\n"+" ===>预测结果为: "+str(predictResult) + "说明: "+DescDict[predictResult]+"\n")

predictData(sc,best_model,categoriesMap)

返回结果：

开始导入数据...
网址：http://www.lynnskitchenadventures.com/2009/04/homemade-enchilada-sauce.html
 ===>预测结果为: 1说明: 长久型(evergreen)网页

网址：http://lolpics.se/18552-stun-grenade-ar
 ===>预测结果为: 0说明: 暂时型(ephemeral)网页

网址：http://www.xcelerationfitness.com/treadmills.html
 ===>预测结果为: 0说明: 暂时型(ephemeral)网页

网址：http://www.bloomberg.com/news/2012-02-06/syria-s-assad-deploys-tactics-of-father-to-crush-revolt-threatening-reign.html
 ===>预测结果为: 0说明: 暂时型(ephemeral)网页

网址：http://www.wired.com/gadgetlab/2011/12/stem-turns-lemons-and-limes-into-juicy-atomizers/
 ===>预测结果为: 0说明: 暂时型(ephemeral)网页