1.1 机器学习的实际例子
机器学习（Machine Learning）涉及到用不同的算法（algorithm）来使计算机学习如何执行不同的任务。

Robotics（机器人）

机器人在未来会成为帮助我们的伙伴。

机器人可以帮助我们阅读，安排时间表，提醒吃药等。也可以在合适的时间以适当的音量播放我们喜欢的歌曲~，而机器人能执行这一切的基础就是机器学习。

e.g. 为人形机器人创建行走和跳跃模式，以及调整假肢与独腿患者另一条腿的移动方式。
棋类游戏

棋类游戏是机器学习中最古老的应用之一。

有很多算法成功实现了各种棋类游戏，比如前几年的‘Alpha Go’。
语音识别

语音识别和机器学习在近代经历了一波又一波的重大创新。它得益于深度学习和大数据方面的进步，并被广泛应用于各种应用。

Siri就是这样的例子。Siri使用语音识别器、自然语言处理和文本转换语音技术。
数字识别/图像识别

数字识别是读取手写数字和字母的图像，并输出其机器编码的等价物的任务。机器学习方法(支持向量机和深度学习)已经达到了>99%的准确率。

其他的例子包括车牌检测、帐单上的数字打印、笔迹检测和验证码检测。
其他应用

各种各样的机器学习应用涉及到:

1.股票市场预测

2.业务分析

3.面部识别

4.etc.

目录

定义
	
机器学习算法类别
	
Kmeans算法
	
朴素贝叶斯算法(Naive Bayes)
	
K最近邻分类算法（KNN）
	
SVM
	
Logistic regression
	
协同过滤
	
决策树
回到顶部

定义

机器学习(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


			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9

			
10

			
11

			
12

			
13

			
14

			
15

			
16

			
17

			
18

			
19

			
20

			
21

			
22

			
23

			
24

			
25

			
26

			
27

			
28

			
29

			
30

			
31

			
32

			
33

			
34

			
35

			
36

			
37

			
38

			
39

			
40

			
41

			
42

			
43

			
44

			
45

			
46

			
47

			
48

			
49

			
50
			
			

			
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数据


			
1

			
2

			
3

			
4

			
5

			
6
			
			

			
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


			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9

			
10

			
11

			
12

			
13

			
14

			
15

			
16

			
17

			
18

			
19

			
20

			
21

			
22

			
23

			
24

			
25

			
26

			
27

			
28

			
29

			
30

			
31

			
32

			
33

			
34

			
35

			
36

			
37

			
38

			
39

			
40

			
41
			
			

			
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()

			
  }
			
		
数据


			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9

			
10

			
11

			
12
			
			

			
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


			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9

			
10

			
11

			
12

			
13

			
14

			
15

			
16

			
17

			
18

			
19

			
20

			
21

			
22

			
23

			
24

			
25

			
26

			
27

			
28

			
29

			
30

			
31

			
32

			
33

			
34

			
35

			
36

			
37

			
38

			
39

			
40

			
41

			
42

			
43

			
44

			
45
			
			

			
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

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


			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9

			
10

			
11

			
12

			
13

			
14

			
15

			
16

			
17

			
18

			
19

			
20

			
21

			
22

			
23

			
24

			
25

			
26

			
27

			
28

			
29

			
30

			
31

			
32

			
33

			
34

			
35

			
36

			
37

			
38

			
39

			
40

			
41
			
			

			
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()

			
  }
			
		
回到顶部

协同过滤

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


			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9

			
10

			
11

			
12

			
13

			
14

			
15

			
16

			
17

			
18

			
19

			
20

			
21

			
22

			
23

			
24

			
25

			
26

			
27

			
28

			
29

			
30

			
31

			
32

			
33

			
34

			
35

			
36

			
37

			
38

			
39

			
40

			
41

			
42

			
43

			
44

			
45

			
46

			
47

			
48

			
49

			
50

			
51

			
52

			
53

			
54

			
55

			
56

			
57

			
58

			
59
			
			

			
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）效率高，决策树只需要一次构建，反复使用，每一次预测的最大计算次数不超过决策树的深度。


			
1

			
2

			
3

			
4

			
5

			
6

			
7

			
8

			
9

			
10

			
11

			
12

			
13

			
14

			
15

			
16

			
17

			
18

			
19

			
20

			
21

			
22

			
23

			
24

			
25

			
26

			
27

			
28

			
29

			
30

			
31

			
32

			
33

			
34

			
35

			
36

			
37

			
38

			
39

			
40

			
41
			
			

			
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()

			
  }
			
		
 

转载地址：https://www.cnblogs.com/heml/p/6806907.html#_label5

参考文献：

莫烦强化学习之小例子
pandas官网
十分钟搞定pandas
10 Minutes to pandas
Pandas的 loc iloc ix 区别

（其实自己研究生摸索一年了，也很心塞，自己在搞自然语言处理，想把这些基础知识重新过一遍，和大家一起学习）



第一章的课时1主要涉及到一下内容

主要涉及的是机器学习在生活中的一些例子：

       在用google或者bing搜索的时候，能够得出自己想要的答案，就是用了学习算法，苹果手机相册和facebook能识别出朋友的图片，这也是机器学习；在收到邮件的时候，能够过滤点很多垃圾邮件，也是机器学习；

       这门课，我们会学习机器学习算法，但是只知道算法和数学含义不知道使用其去解决关心的问题是不够的，因此这门课涉及了很多联系，去实现每个算法，以至于我们利用他们；

      为什么机器学习如此流行？例如我们找A到B 的最短路径，很多时候我们不知道如何利用AI实现有意义的事情，例如网页搜索，图片标记，反垃圾邮件，只能是让机器自己学习；

例子： 

      数据挖掘database mining.网页点击数据，医疗记录； 

      人工无法写出的代码：自动直升机，手写体识别，nlp，计算机视觉； 

亚马逊，推荐； 

      下节课将给机器学习下个定义，并且讲解机器学习中的算法；