机器学习

定义

机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。
它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域。目前，世界上共有几百种不同的机器学习算法。

机器学习算法类别

分类与聚类

Classification (分类)
给定一堆样本数据以及这些数据所属的类别标签，通过算法来预测新数据的类别，有先验知识。

对于一个 classifier ，通常需要你告诉它“这个东西被分为某某类”这样一些例子，理想情况下，一个 classifier 会从它得到的训练集中进行“学习”，从而具备对未知数据进行分类的能力，这种提供训练数据的过程通常叫做 supervised learning (监督学习)

Clustering(聚类)
事先并不知道一堆数据可以被划分到哪些类，通过算法来发现数据之间的相似性，从而将相似的数据划入相应的类，简单地说就是把相似的东西分到一组，没有先验知识。

聚类的时候，我们并不关心某一类是什么，我们需要实现的目标只是把相似的东西聚到一起，因此，一个聚类算法通常只需要知道如何计算相似度就可以开始工作了，因此 clustering 通常并不需要使用训练数据进行学习，这在 Machine Learning 中被称作 unsupervised learning (无监督学习).

常见的分类与聚类算法

常用的分类算法：k-最近邻法(k-nearest neighbor，kNN)，决策树分类法，朴素贝叶斯分类算法(native Bayesian classifier)、支持向量机(SVM)的分类器，神经网络法，模糊分类法等等。

常见聚类算法： K均值(K-means clustering)聚类算法、K-MEDOIDS算法、CLARANS算法；BIRCH算法、CURE算法、CHAMELEON算法等；基于密度的方法：DBSCAN算法、OPTICS算法、DENCLUE算法等；基于网格的方法：STING算法、CLIQUE算法、WAVE-CLUSTER算法；

监督学习与无监督学习

机器学习按照训练数据是否有“先验知识”，一般划分为三类：
1) 监督学习(supervised learning)
2) 无监督学习(unsupervised learning)
3) 半监督学习(semi-supervised learning)

监督式学习技术需要关于结果的先验知识
例如，如果我们正在研究一个市场活动的历史数据，我们可以根据市场是否产生预期的反应来对数据进行分类，或决定下一步要花多少钱。监督式学习技术为预测和分类提供了强大的工具。

无监督学习技术不需要先验知识
例如，在某些欺诈的案例中，只有当事情发生很久以后，我们才可能知道某次交易是不是欺诈。在这种情况下，与其试图预测哪些交易是欺诈，我们不如使用机器学习来识别那些可疑的交易，并做出标记，以备后续观察。我们对某种特定的结果缺乏先验知识、但仍希望从数据中汲取有用的洞察时，就要用到无监督式学习。

Kmeans算法

是一个简单的聚类算法，目的是把n个对象根据他们的属性分为k个分类，k<n。

优点：算法速度很快
缺点：分组的数目k是一个输入参数，不合适的k可能返回较差的结果。

 spark kmeans算法demo

object KMeansDemo {

def main(args: Array[String]) {

val conf = new SparkConf()
conf.setAppName("ML")
conf.setMaster("local[*]")

val sc = new SparkContext(conf)
sc.setLogLevel("ERROR")

// Load and parse the data
val data = sc.textFile("D:/mllib/kmeans_data.txt")
// 数据转换成向量,每一行三个数据，因此是三维的
val parsedData = data.map(s => Vectors.dense(s.split(' ').map(_.toDouble))).cache()

// Cluster the data into two classes using KMeans
val numClusters = 2
// 最大迭代次数
val numIterations = 20
// 训练KMeansModel数据模型
val clusters = KMeans.train(parsedData, numClusters, numIterations)

// 打印聚类中心点
println(" cluster center ")
for (c <- clusters.clusterCenters) {
println(" " + c.toString)
}

// 打印每个点属于哪个分类
for (data <- parsedData) {
println(data + " " + clusters.predict(data))
}

// 预测数据属于哪个类别
println("Vectors 0.2 0.2 0.2 is belongs to clusters:" + clusters.predict(Vectors.dense("0.2 0.2 0.2".split(' ').map(_.toDouble))))
println("Vectors 8 8 8 is belongs to clusters:" + clusters.predict(Vectors.dense("8 8 8".split(' ').map(_.toDouble))))

// Evaluate clustering by computing Within Set Sum of Squared Errors
val WSSSE = clusters.computeCost(parsedData)
println("Within Set Sum of Squared Errors = " + WSSSE)

// Save and load model
// clusters.save(sc, "D:/mllib/save/kmeans/")
// val sameModel = KMeansModel.load(sc, "D:/mllib/save/kmeans/")

sc.stop()
}

}

D:/mllib/kmeans_data.txt数据

0.0 0.0 0.0
0.1 0.1 0.1
0.2 0.2 0.2
9.0 9.0 9.0
9.1 9.1 9.1
9.2 9.2 9.2

朴素贝叶斯算法(Naive Bayes)

朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法。算法的基础是概率问题，分类原理是通过某对象的先验概率，利用贝叶斯公式计算出其后验概率，即该对象属于某一类的概率，选择具有最大后验概率的类作为该对象所属的类。朴素贝叶斯假设是约束性很强的假设，假设特征条件独立，但朴素贝叶斯算法简单，快速，具有较小的出错率。 在朴素贝叶斯的应用中，主要研究了电子邮件过滤以及文本分类研究。

  spark Naive Bayes算法demo

def main(args: Array[String]) {

    val conf = new SparkConf()
    conf.setAppName("ML")
    conf.setMaster("local[*]")

    val sc = new SparkContext(conf)
    sc.setLogLevel("ERROR")

    // 加载数据
    val data = sc.textFile("D:/mllib/sample_naive_bayes_data.txt")
    // 0,1 0 0 数据格式，第一个0是label，后面的1 0 0是特征
    val parsedData = data.map { line =>
      val parts = line.split(',')
      // 转换数据为LabeledPoint
      LabeledPoint(parts(0).toDouble, Vectors.dense(parts(1).split(' ').map(_.toDouble)))
    }

    // 数据分为training(60%)和测试数据(40%).
    val splits = parsedData.randomSplit(Array(0.6, 0.4), seed = 11L)
    val training = splits(0)
    val test = splits(1)

    // 开始训练模型  modelType指定方法类型，multinomial或者bernoulli
    val model = NaiveBayes.train(training, lambda = 1.0, modelType = "multinomial")


    val testData = LabeledPoint(0, Vectors.dense("1 0 0".split(' ').map(_.toDouble)))

    // 根据特征预测label
    println("label:" + model.predict(testData.features))


    // model.predict(p.features) 预测值   p.label 实际值
    val predictionAndLabel = test.map(p => (model.predict(p.features), p.label))

    // 计算准确率
    val accuracy = 1.0 * predictionAndLabel.filter(x => x._1 == x._2).count() / test.count()

    sc.stop()
  }

数据

0,1 0 0
0,2 0 0
0,3 0 0
0,4 0 0
1,0 1 0
1,0 2 0
1,0 3 0
1,0 4 0
2,0 0 1
2,0 0 2
2,0 0 3
2,0 0 4

K最近邻分类算法（KNN）

分类算法，分类思想比较简单，从训练样本中找出K个与其最相近的样本，然后看这k个样本中哪个类别的样本多，则待判定的值（或说抽样）就属于这个类别。近朱者赤，近墨者黑。

 

SVM

分类算法，SVM可分为三类：线性可分（linear SVM in linearly separable case）的线性SVM、线性不可分的线性SVM、非线性（nonlinear）SVM

spark demo

def main(args: Array[String]) {

    val conf = new SparkConf()
    conf.setAppName("ML")
    conf.setMaster("local[*]")

    val sc = new SparkContext(conf)
    sc.setLogLevel("ERROR")

    // 加载数据,把数据转换成特征向量
    val data = MLUtils.loadLibSVMFile(sc, "D:/mllib/sample_libsvm_data.txt")

    // 数据分为training (60%)和test (40%).
    val splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)
    val training = splits(0).cache()
    val test = splits(1)

    // 迭代次数
    val numIterations = 200
    val model = SVMWithSGD.train(training, numIterations)

    // Clear the default threshold.
    model.clearThreshold()

    // 计算预测数据
    val scoreAndLabels = test.map { point =>
      val score = model.predict(point.features)
      // 打印预测值与实际值
      println(score + " : " + point.label)
      (score, point.label)
    }

    // 对数据进行评估
    val metrics = new BinaryClassificationMetrics(scoreAndLabels)
    val auROC = metrics.areaUnderROC()

    println("Area under ROC = " + auROC)

    // 计算正确率
    val trainErr = scoreAndLabels.filter(r => r._1 != r._2).count.toDouble / test.count

    println("train error = " + trainErr)

    sc.stop()
  }

数据在spark目录spark-2.1.0-bin-hadoop2.7\data\mllib\sample_libsvm_data.txt

 

Logistic regression

分类算法，主要在流行病学中应用较多，比较常用的情形是探索某疾病的危险因素，根据危险因素预测某疾病发生的概率

def main(args: Array[String]) {

    val conf = new SparkConf()
    conf.setAppName("ML")
    conf.setMaster("local[*]")

    val sc = new SparkContext(conf)
    sc.setLogLevel("ERROR")

    // 加载数据,把数据转换成特征向量
    val data = MLUtils.loadLibSVMFile(sc, "D:/mllib/sample_libsvm_data.txt")

    // 数据分为training (60%)和test (40%).
    val splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)
    val training = splits(0).cache()
    val test = splits(1)

    // 逻辑回归
    val model =  new LogisticRegressionWithLBFGS().setNumClasses(10)
      .run(training)

    // 计算预测数据
    val predictionAndLabels = test.map { point =>
      val score = model.predict(point.features)
      // 打印预测值与实际值
      println(score + " : " + point.label)
      (score, point.label)
    }

    // 对数据进行评估
    val metrics = new MulticlassMetrics(predictionAndLabels)
    val precision = metrics.precision
    println("Precision = " + precision)

    // 计算正确率
    val trainErr = predictionAndLabels.filter(r => r._1 != r._2).count.toDouble / test.count

    println("train error = " + trainErr)

    sc.stop()
  }

协同过滤

协同过滤常常被用于分辨某位特定顾客可能感兴趣的东西，这些结论来自于对其他相似顾客对哪些产品感兴趣的分析。协同过滤以其出色的速度和健壮性，在全球互联网领域炙手可热

def main(args: Array[String]) {

    val conf = new SparkConf()
    conf.setAppName("ML")
    conf.setMaster("local[*]")

    val sc = new SparkContext(conf)
    sc.setLogLevel("ERROR")

    // 加载数据,把数据转换成特征向量
    val data = sc.textFile("D:/mllib/als/test.data")
    val ratings = data.map(_.split(',') match { case Array(user, item, rate) =>
      // 用户  产品  评分
      Rating(user.toInt, item.toInt, rate.toDouble)
    })

    // 构建推荐模型
    val rank = 10
    // 迭代次数
    val numIterations = 10
    // rank使用的特征的数量
    val model = ALS.train(ratings, rank, numIterations, 0.01)

    // 数据转换成(user, product)
    val usersProducts = ratings.map { case Rating(user, product, rate) =>
      (user, product)
    }
    val predictions =
      model.predict(usersProducts).map { case Rating(user, product, rate) =>
        println(rate)
        ((user, product), rate)
      }

    // 基于用户推荐产品
    val recommends = model.recommendProducts(4, 1)
    for (r <- recommends) {
      println(r)
    }

    // 基于产品推荐用户
    // model.recommendUsers()

    // 实际值和预测值进行join
    val ratesAndPreds = ratings.map { case Rating(user, product, rate) =>
      println(rate)
      ((user, product), rate)
    }.join(predictions)

    val MSE = ratesAndPreds.map { case ((user, product), (r1, r2)) =>
      val err = (r1 - r2)
      // 平方
      err * err
    }.mean() // 均值

    // 均方误差
    println("Mean Squared Error = " + MSE)

    sc.stop()
  }

决策树

决策树（Decision Tree）是一种简单但是广泛使用的分类器。通过训练数据构建决策树，可以高效的对未知的数据进行分类。决策数有两大优点：1）决策树模型可以读性好，具有描述性，有助于人工分析；2）效率高，决策树只需要一次构建，反复使用，每一次预测的最大计算次数不超过决策树的深度。

def main(args: Array[String]) {

    val conf = new SparkConf()
    conf.setAppName("ML")
    conf.setMaster("local[*]")

    val sc = new SparkContext(conf)
    sc.setLogLevel("ERROR")

    // 加载数据,把数据转换成特征向量
    val data = MLUtils.loadLibSVMFile(sc, "D:/mllib/sample_libsvm_data.txt")
    // 数据70%training 30% test
    val splits = data.randomSplit(Array(0.7, 0.3))
    val (trainingData, testData) = (splits(0), splits(1))

    val numClasses = 2
    val categoricalFeaturesInfo = Map[Int, Int]()
    val impurity = "gini"
    val maxDepth = 5
    val maxBins = 32

    // 构建决策树模型 numClasses分几类
    // impurity "gini" (recommended) or "entropy"
    // maxDepth 树的最大深度
    // maxBins 建议 32
    val model = DecisionTree.trainClassifier(trainingData, numClasses, categoricalFeaturesInfo,
      impurity, maxDepth, maxBins)

    // 通过模型预测测试数据
    val labelAndPreds = testData.map { point =>
      val prediction = model.predict(point.features)
      (point.label, prediction)
    }

    // 计算错误率
    val testErr = labelAndPreds.filter(r => r._1 != r._2).count().toDouble / testData.count()
    println("Test Error = " + testErr)
    // println("Learned classification tree model:\n" + model.toDebugString)

    sc.stop()
  }