1 基础

基础知识(Basic Concepts)

训练集，测试集，特征值，监督学习，非监督学习，分类，回归

1.1 机器学习概念

• 多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度等多门学科。
• 专门研究计算机怎样模拟和实现人类的学习行为，以获取新的知识和技能，重新组织新的知识结构使之不断改善自身的性能

1.2 学科定位

• 人工智能（Artificial Intelligence，AI）的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，主要方法是归纳、综合而不是演绎。

1.3 机器学习定义

• 探究和开发一系列算法来如何使计算机不需要通过外部明显的指示，而可以自己通过数据来学习和建模，并且利用建好的模型和新的输入来进行预测的学科。
• 一门不需要外部程序指示，而让计算机有能力自我学习的学科。
• 机器学习是一门人工智能的科学，该领域的主要研究对象是人工智能，特别是如何在经验学习中改善算法的性能。
• 机器学习是对能通过经验自动改进的计算机算法的研究。

1.4 什么是学习

• 针对经验E(Experience)和一些列的任务T(Task)和一定表现的衡量P(performe)，如果随着经验的积累，针对定义好的任务T可以提高表现P，说明计算机具有学习能力。
• 下棋、语音识别、自动驾驶、语言翻译、计算机视觉、推荐系统、无人机、识别垃圾邮件、人脸识别、推荐系统

1.5 深度学习

• 深度学习是机器学习延伸出来的一个新领域，由以人脑结构为启发的神经网络算法为起源，加之模型结构的增加发展，并伴随大数据和计算能力的提高而产生的一系列新的算法。
  
• 深度学习作为机器学习中延伸出来的一个领域，被应用在图像处理和计算机视觉，自然语言处理以及语音识别等领域。自2006年至今，学术界和工业界合作在深度学习方面的研究与应用取得了突破性的进展。以ImageNet为数据库的经典图像中的物体识别竞赛为例，击败了所有传统算法，取得了前所未有的精确度。

1.5 监督学习-分类

监督学习(Supervised Learning):分类(Classification)

• 决策树(Decision Tree) ，银行信用自动评估系统
• 邻近取样(Nearest Neighbor) ，人脸识别
• 支持向量机(Support Vector Machine) ，图片中的红眼检测，结肠癌晚期分类
• 神经网络算法(Neural Network)，手写数字识别，图片分类

1.6 监督学习-回归

监督学习(Supervised Learning):回归(Regression)

• 线性回归(Linear Regression)，销量预测，价格预测
• 非线性回归(Non-linear Regression)，销售预测，价格预测

1.7 非监督学习

非监督学习(Unsupervised Learning)

• K-mean算法聚类(Clustering)，人脸分类
• hierarchical dustering算法聚类，人脸噪音移除

1.8 机器学习步骤框架

1. 把数据拆分为训练集和测试集
2. 用训练集和训练集的特征向量来训练算法
3. 用学习来的算法运用在测试集上来评估算法，可能要调整参数（parameter tuning），

2 基本概念

• 基本概念：训练集、测试集、特征值、监督学习、非监督学习、半监督学习、分类、回归
• 概念学习是指从有关某个布尔函数的输入输出样例中推断出该布尔函数。
• 概念定义在实例（Instance）集合之上，这个集合表示为X。
• 待学习的概念或目标函数成为目标概念（Target Concept），记作做C。
• 训练集（training set / data）/ 训练样例（training examples）：用来进行训练，也就是生产模型，或者算法的数据集
• 测试集（testing set / data）/ 测试样例（testing example）：用来专门进行测试已学习好的模型或者算法的数据集
• 特征向量(features/feature vector):属性的集合，通常用一个向量来表示，附属于一个实例
• 标记（label）：C(x)，实例类别的标记
• 正例：positive example
• 反例：negative example
• 分类（Classification）：目标标记为类别型数据（category）
• 回归（regression）：目标标记为连续性数值（Continuous Numeric Value）
• 有监督学习（supervised learning）：训练集有类别标记（Calss Label）
• 无监督学习（unsupervised learning）：无类别标记（Class Label）
• 半监督学习（semi-supervised learning）：有类别标记训练集+无类别标记训练集

3 监督学习-分类

监督学习（Superviesd Learning）：分类（Classification）

3.1 决策树

决策树（Decision Tree）

3.1.1 机器学习中分类和预测算法的评估

• 准确率
• 速度
• 强壮性
• 可规模性
• 可解释性

3.1.2 什么是决策树/判定树？

• 判定树是一个类似于流程图的数结构，其中每个内部节点表示在一个属性上的测试，每个分支代表一个属性输出，而每个树叶节点代表类和类分布。树的最顶层是根节点。
  

3.1.2 熵（entropy）概念

• 信息和抽象如何度量？
• 1948年香农提出信息熵的概念
• 一条信息的信息量大小和他的不确定性有直接的关系
• 要搞清楚一件非常不确定的事情，或者是我们一无所知的事情，需要了解大量的信息
• 信息量的度量等于不确定性的多少
• 变量的不确定性越大，熵也越大

3.1.3 决策树归纳算法（ID3）

信息获取量（Information Gain）：Gain(A)=Info(D)-Info_A(D).
通过A来作为节点分类获取了多少信息

• 树以代表训练样本的单个节点开始（步骤1）
• 如果样本都在同一个类，则该节点成为树叶，并用该类标号（步骤2和3）
• 否则，算法使用称为信息增益的基于熵的度量作为启发信息，选择能够最好的将样本分类的属性（步骤6）.该属性成为该节点的“测试”或“判定”属性（步骤7）
• 在算法的该版本中，所有的属性都是分类的，即离散值。连续属性必须离散化。
• 对测试属性的每个已知的值，创建一个分支，并据从划分样本（步骤8-10）
• 算法使用同样的过程，递归的形成每个划分上的样本的判定树。一旦一个属性出现在一个结点时，就不必该节点的任何后代上考虑它（步骤13）
• 递归划分步骤划分条件仅当下列条件之一停止。
• （a）给定结点的所有样本属于同一类（步骤2和3）
• （b）没有剩余属性可以用来进一步划分样本（步骤4），在此情况下，使用多数表决（步骤5）
• 这涉及将给定结点转换成树叶，并用样本中的多数所在的类标记它

3.1.4 树叶剪枝(避免overfitting)

• 先剪枝
• 后剪枝

3.1.5 决策树的优点

• 直观
• 便于理解
• 小规模数据集有效

3.1.6 决策树的缺点

• 处理连续变量不好
• 类别较多时，错误增加的较快
• 可规模性一般

3.1.7 代码实现

Python 机器学习库：scikit-learn
简单高效的数据挖掘和机器学习库
对所有用户开放，根据不同需求，高度可重用性
基于Numpy、SciPy、matplotlib,开源

• 数据

RID,age,income,student,credit_rating,Class_buys_computer
1,youth,high,no,fair,no
2,youth,high,no,excellent,no
3,middle_aged,high,no,fair,yes
4,senior,medium,no,fair,yes
5,senior,low,yes,fair,yes
6,senior,low,yes,excellent,no
7,middle_aged,low,yes,excellent,yes
8,youth,medium,no,fair,no
9,youth,low,yes,fair,yes
10,senior,medium,yes,fair,yes
11,youth,medium,yes,excellent,yes
12,middle_aged,medium,no,excellent,yes
13,middle_aged,high,yes,fair,yes
14,senior,medium,no,excellent,no

• 代码

from sklearn.feature_extraction import DictVectorizer
import csv
from sklearn import preprocessing
from sklearn import tree
from sklearn.externals.six import StringIOallElectronicsData = open(r'D:\IDEA\ML\MachineLearningBasics\DataSets\AllElectronics.csv', 'rb')
reader = csv.reader(allElectronicsData)
headers = reader.next()print 'headers'
print(headers)featureList = []
labelList = []for row in reader:labelList.append(row[len(row) - 1])rowDict = {}for i in range(1, len(row) - 1):rowDict[headers[i]] = row[i]featureList.append(rowDict)print 'featureList'
print(featureList)vec = DictVectorizer()
dummyX = vec.fit_transform(featureList).toarray()print("dummyX:" + str(dummyX))
print(vec.get_feature_names())
print("labelList:" + str(labelList))lb = preprocessing.LabelBinarizer()
dummyY = lb.fit_transform(labelList)
print("dummyY:" + str(dummyY))clf = tree.DecisionTreeClassifier(criterion='entropy')
clf = clf.fit(dummyX, dummyY)
print('clf:' + str(clf))with open("allElectronicInformationGainOri.dot", 'w') as f:f = tree.export_graphviz(clf, feature_names=vec.get_feature_names(), out_file=f)
oneRowX = dummyX[0, :]
print('oneRowX:' + str(oneRowX))newRowX = oneRowX
newRowX[0] = 1
newRowX[2] = 0
print('newRowX:' + str(newRowX))# predictedY = clf.predict(newRowX)
# print('predictedY:' + str(predictedY))

• 结果
  

3.2 邻近取样

邻近取样（Nearest Neighbor）

3.2.1 最邻近规则分类(K-Nearest Neighbor) KNN算法

Cover和Hart在1968年提出最初的邻近算法
分类（Classification）算法
输入基于实例的学习(instance-based learning)，懒惰学习(Lazy Learning)

3.2.2 算法详述

1. 为了判断未知实例的类别，以所有已知类别的实例作为参照
2. 选择参数K
3. 计算未知实例与所有已知实例的距离
4. 选择最近K个已知实例
5. 根据少数服从多数的投票法则（majority-voting），让未知实例归类为K个最邻近样本中最多数的类别

3.2.3 关于距离衡量方法

• Euclidean Distance 定义
  
• 其他距离衡量：余弦值(COS)，相关度(correlation)，曼哈顿距离(Manhattan Distance)

3.2.4 算法评价

• 优点：简单，易于理解，容易实现，通过对K的选择可具备丢噪音数据的健壮性
• 缺点：需要大量空间存储所有已知实例，算法复杂度高（需要比较所有已知实例与要分类的实例）
• 当其样本分布不平衡时，比如其中一类样本过大（实例数量过多）占主导时，新的未知实例容易被归类为这个主导样本，因为这类样本实例的数量过大，但这个新的未知实例并不接近目标样本
  

3.2.5 KNN算法应用

最邻近规则分类KNN(K-Nearest Neighbor)算法应用

• SKLearnExample.py

# Example of KNN implemented
from sklearn import neighbors
from sklearn import datasetsknn = neighbors.KNeighborsClassifier()
iris = datasets.load_iris()
print iris
knn.fit(iris.data, iris.target)
predictedLabel = knn.predict([[0.1, 0.2, 0.3, 0.4]])
print predictedLabel

3.2.6 Iris(虹膜)数据集介绍

• 150个实例
• sepal length：萼片长度，sepal width：萼片宽度，petal length：花瓣长度，petal width：花瓣宽度
• 类别：setosa,versicolor,virginica
  

3.2.7 代码实现

# coding=utf-8
import csv
import random
import math
import operator# filename 文件名称
# split 分割
# trainingSet 训练集
# testSet 测试集
def loadDataset(filename, split, trainingSet=[], testSet=[]):with open(filename, 'rb') as csvFile:lines = csv.reader(csvFile)dataset = list(lines)for x in range(len(dataset) - 1):for y in range(4):dataset[x][y] = float(dataset[x][y])if random.random() < split:trainingSet.append(dataset[x])else:testSet.append(dataset[x])# instance1 第一个坐标
# instance2 第二个坐标
# length 维数
def euclideanDistance(instance1, instance2, length):distance = 0for x in range(length):distance += pow((instance1[x] - instance2[x]), 2)return math.sqrt(distance)# 获取K个最近的实例
def getNeighbors(trainingSet, testInstance, k):distances = []length = len(testInstance) - 1for x in range(len(trainingSet)):dist = euclideanDistance(testInstance, trainingSet[x], length)distances.append((trainingSet[x], dist))distances.sort(key=operator.itemgetter(1))neighbors = []for x in range(k):neighbors.append(distances[x][0])return neighborsdef getResponse(neighbors):class_votes = {}for x in range(len(neighbors)):response = neighbors[x][-1]if response in class_votes:class_votes[response] += 1else:class_votes[response] = 1sorted_votes = sorted(class_votes.iteritems(), key=operator.itemgetter(1), reverse=True)return sorted_votes[0][0]# 获取准确率
def getAccuracy(testSet, predictions):correct = 0for x in range(len(testSet)):if testSet[x][-1] == predictions[x]:correct += 1return (correct / float(len(testSet))) * 100.0def main():training_set = []test_set = []split = 0.67loadDataset(r'D:\IDEA\ML\MachineLearningBasics\DataSets\iris.data.txt', split, training_set, test_set)print 'Train Set:' + repr(len(training_set))print 'Test Set:' + repr(len(test_set))predictions = []k = 3for x in range(len(test_set)):neighbors = getNeighbors(training_set, test_set[x], k)result = getResponse(neighbors)predictions.append(result)print '>> predicted=' + repr(result) + ',actual=' + repr(test_set[x][-1])accuracy = getAccuracy(test_set, predictions)print 'Accuracy:' + repr(accuracy) + '%'main()

3.3 支持向量机

支持向量机（Support Vector Machine，SVM）

3.3.1 原理简介

• 最早于1963年被提出，深度学习出现之前（2012），SVM被认为机器学习中近十年来，最成功、表现最好的算法。
• 机器学习的一般框架：训练集，提取特征向量， 结合一定的算法（分类器：比如决策树，KNN），得到结果
  
• SVM寻找区分两类的超平面（hyper plane），使边际（margin）最大
  
• 总共可以有多少个超平面？无数个
• 如何选取边际最大的超平面（Max Margin Hyper plane）？
• 超平面到一侧最近点的距离等于到另一侧最近点的距离，两侧的两个超平面平行
• 线性可区分（linear separable）和线性不可区分（linear inseparable）
  
  

3.3.2 定义与公式建立

• 一般情况

超平面可定义为：W * X + b = 0
W：Weight Vector，权重
W={w1,w2,w3,w4...wn}
n：特征值的个数
X：训练实例
b：bias，偏好

• 二维平面

假设二维特征向量：x=(x1,x2)
把b想象成额外的weight
超平面的方程变为：w0 + w1*x1 + w2*x2 = 0
超平面右上方的点满足：w0 + w1*x1 + w2*x2 > 0
超平面左下方的点满足：w0 + w1*x1 + w2*x2 < 0

• 所有坐落在边际的两边的超平面上的向量被成为支持向量（support vectors）
  
  

from sklearn import svmx = [[2, 0], [1, 1], [2, 3]]
y = [0, 0, 1]
clf = svm.SVC(kernel='linear')
clf.fit(x, y)
print clf
# get support vectors
print clf.support_vectors_
# get indices of support vectors
print clf.support_
# get number of support vectors for each class
print clf.n_support_

3.3.3 SVM算法特性

• 训练好的模型的算法复杂度是由支持向量的个数决定的，而不是由数据的维度决定的。所以SVM不容易产生Overfitting。
• SVM训练出来的模型完全依赖于支持向量（Support Vector），即使训练集里面所有非支持向量被去除，重复训练过程，结果依然会得到完全一样的模型。
• 一个SVM如果训练得出的支持向量个数比较少，SVM训练出来的模型容易被泛化

3.3.4 线性不可分情况

• 数据集在空间中对应的向量不可被一个超平面区分
  

两个步骤来解决

• 利用一个非线性的映射，把源数据集中的向量转化到一个更高维度的空间
• 在这个高维度的空间中，找一个线性的超平面来根据线性可分的情况处理
  
  
• 如何选择合理的非线性转化把数据转化到高维度？
• 如何解决计算内积时算法复杂度非常高的问题？

3.3.5 具体实现

print __doc__
import numpy as np
import pylab as pl
from sklearn import svm# create 40 separable points
np.random.seed(0)
x = np.r_[np.random.randn(20, 2) - [2, 2], np.random.randn(20, 2) + [2, 2]]
y = [0] * 20 + [1] * 20# fit the model
clf = svm.SVC(kernel='linear')
clf.fit(x, y)# get the separating hyper plane
w = clf.coef_[0]
a = -w[0] / w[1]
xx = np.linspace(-5, 5)
yy = a * xx - (clf.intecept_[0]) / w[1]# plot the parallels to the separating hyper plane the pass through the support vectors
b = clf.support_vectors_[0]
yy_down = a * xx + (b[1] - a * b[0])
b = clf.support_vectors[-1]
yy_up = a * xx + (b[1] - a * b[0])print "w:", w
print "a:", a
print "support_vectors:", clf.support_vectors_
print "clf.coef_", clf.coef_# plot the line,the points,and the nearest vectors the plane
pl.plot(xx, yy, 'k-')
pl.plot(xx, yy_down, 'k--')
pl.plot(xx, yy_up, 'k--')pl.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1], s=80, facecolor='none')
pl.scatter(x[:, 0], x[:, 1], c=y, cmap=pl.cm.Paired)
pl.axis('tight')
pl.show()

3.4 神经网络算法

神经网络算法（Neural Network）

3.4.1 算法详述

• 背景：以人脑中的神经网络为启发，历史上出现多个不同的版本，最著名的算法是1980年的Back Propagation，被使用在多层向前神经网络上

• 多层向前神经网络Multilayer Feed-Forward Neural Network

• 多层向前神经网络由以下部分组成：输入层（Input Layer），隐藏层（hidden layer），输入层（）
  

• 每层由单元（units）组成

• 输入层（Input Layer）是由训练集的实例特征向量传入

• 经过连接点的权重（weight）传入下一层，一层的输出是另一层的输入

• 隐藏层的个数可以是任意的，输入层有一层，输出层有一层

• 每个单元也可以被称作神经结点，根据生物学来定义

• 以上称为两层的神经网络（输入层不算）

• 一层中加权的求和，根据非线性方程转化输出

• 作为多层向前神经网络，理论上，如果有足够多的隐藏层和足够大的训练集，理论上可模拟出任何方程。

3.4.2 设计神经网络结构

• 使用神经网络设计数据之前，必须确定神经网络的层数，以及每层单元的个数
• 特征向量在传入输入层时，通常先被标准化（normalize）0到1之间，为了加速学习的过程
• 离散型变量可以被编码成每一个输入单元对应一个特征值可能赋的值，比如：特征值A可能取三个值（a0,a1,a2），可以使用三个输入单元来代表A；如果A=a0,那么代表a0的单元值就取1，其他取0；如果A=a1,那么代表a1的单元值就取1，其他取0，以此类推
• 神经网络可以用来做分类问题（Classification）问题，也可以解决回归问题（regression）问题
• 对于分类问题，如果是两类，可以用一个输入单元表示，0和1分别代表两类
• 如果多于两类，每一个类别用一个输入单元表示,输入层的单元数量通常等于类别数量
• 没有明确的规则来设计最好有多少个隐藏层，根据实验测试及误差以及准确度来改进
• 交叉验证方法（Cross Validation）
  

3.4.3 Backpropagation算法

• 通过迭代性来处理训练集中的实例
• 对比经过神经网络后，输入值预测值（predicted value）与真实值（target Value）之间
• 反方向（输出层-隐藏层-输入层）来以最小化误差来更新每个连接的权重
• 算法详细介绍
  

输入：D：数据集，学习率（Learning rate），一个层向前神经网路
输出：一个训练好的神经网路（a trained neural network）
初始化权重（weights）和偏向（bias） ：随机初始化到-1到1之间，或者-0.5到0.5之间，每个单元由一个偏向

3.4.4 非线性转化方程（Non-linear transformation function ）

• sigmoid 函数（S曲线）用来做Activation Function
  
• 双曲线函数（tanh）
  
• 逻辑函数（logic function）
  

3.4.5 神经网络算法应用

# coding=utf-8
import numpy as np# 双曲线函数
def tanh(x):return np.tanh(x)# 双曲线函数-导数
def tanh_deriv(x):return 1.0 - np.tanh(x) * np.tanh(x)# 逻辑函数
def logistic(x):return 1 / (1 + np.exp(-x))# 逻辑函数-导数
def logistic_derivative(x):return logistic(x) * (1 - logistic(x))class NeuralNetwork:def __init__(self, layers, activation='tanh'):''':param layers: A list containing the number of units in each layerShould be at least two layers:param activation: The activation function to be used.Can be "Logistic" or "tanh"'''if activation == 'logistic':self.activation = logisticself.activation_deriv = logistic_derivativeelif activation == 'tanh':self.activation = tanhself.activation_deriv = tanh_derivself.weights = []for i in range(1, len(layers) - 1):self.weights.append((2 * np.random.random((layers[i - 1] + 1, layers[i] + 1)) - 1) * 0.25)self.weights.append((2 * np.random.random((layers[i] + 1, layers[i + 1])) - 1) * 0.25)def fit(self, x, y, learning_rate=0.2, epochs=10000):x = np.atleast_2d(x)  # numpy arraytemp = np.ones([x.shape[0], x.shape[1] + 1])temp[:, 0:-1] = x  # adding the bias unit to the input layersx = tempy = np.array(y)for k in range(epochs):i = np.random.randint(x.shape[0])a = [x[i]]for l in range(len(self.weights)):  # going forward network,for each layera.append(self.activation(np.dot(a[l], self.weights[l])))error = y[i] - a[-1]  # compute the error at the top layerdeltas = [error * self.activation_deriv(a[-1])]  # for output layer# starting back propagationfor l in range(len(a) - 2, 0, -1):deltas.append(deltas[-1].dot(self.weights[l].T) * self.activation_deriv(a[l]))deltas.reverse()for i in range(len(self.weights)):layer = np.atleast_2d(a[i])delta = np.atleast_2d(deltas[i])self.weights[i] += learning_rate * layer.T.dot(delta)def predict(self, x):x = np.array(x)temp = np.ones(x.shape[0] + 1)a = tempfor l in range(0, len(self.weights)):a = self.activation(np.dot(a, self.weights[l]))return a

• 简单非线性关系数据集测试（XOR）

X	Y
0，0	0
0，1	1
1，0	1
1，1	1

# coding=utf-8
from NeuralNetwork import NeuralNetwork
import numpy as np'''
输入层：两个神经元
隐藏层：两个神经元
输出层：一个神经元
'''
nn = NeuralNetwork([2, 2, 1], 'tanh')
x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 1, 1, 0])
nn.fit(x, y)
for i in [[0, 0], [0, 1], [1, 0], [1, 1]]:print i, nn.predict(i)

4 监督学习-回归

4.1 简单线性回归

简单线性回归（Simple Linear Regression）

4.1.1 前提介绍

统计量：描述数据特征

• 集中趋势衡量：均值（mean），中位数（medium）、众数（mode）
• 离散程度衡量：方差（variance），标准差（standard deviation）
• 回归（Regression）：Y变量为连续型（continuous numerical variable），如房价、人数、降雨量
• 分类（Classification）：Y变量为类别型（categorical variable），如颜色类别，电脑品牌，有无信誉
• 简单线性回归很多做决定的过程，通常是根据两个或多个变量之间的关系
• 回归分析（Regression Analysis）用来建立方程，模拟两个或者多个变量之间如何关联
• 被预测的变量叫做因变量（dependent variable），输出（output）
• 被用来预测的变量叫做自变量（Independent variable），输入（input）
• 简单线性回归包含一个自变量和一个因变量，两个变量的关系用一条直线来模拟。如果包含两个以上自变量，则称多元回归分析（multiple regression）
• 简单线性回归模型被用来描述因变量和自变量以及偏差（error）之间关系的模型叫做回归模型
  
• 简单线性回归方程：E(y) = B0 + B1 * x

方程对应的图像是一条直线，称为回归线
B0是回归线的截距
B1是回归线的斜率
E(y)是在一个给定x值下y的期望（均值）

• 正向线性关系
  
• 负向线性关系
  
• 无关系
  
• 线性回归分析流程
  
• 关于偏差的假定

偏差是一个随即变量，均值为0
偏差的方差对于所有的自变量X是一样的
偏差的值是独立的
偏差满足正态分布

4.1.2 简单线性模型举例

• 汽车卖家做电视广告数量与卖出汽车的数量
  
• 如何计算适合简单线性回归模型的最佳回归线？
  
  
• python代码实现

# coding=utf-8
import numpy as np  # 科学计算包def fitSLR(x, y):"""计算简单线性回归模型的最佳回归线:param x:数组类型:param y:数组类型:return:最佳回归线参数：y = b0 + b1 * x"""n = len(x)  # 数据长度denominator = 0  # 分母numerator = 0  # 分子for i in range(0, n):numerator += (x[i] - np.mean(x)) * (y[i] - np.mean(y))denominator += (x[i] - np.mean(x)) ** 2print 'numerator:', numeratorprint 'denominator:', denominatorb1 = numerator / float(denominator)# b0 = np.mean(y) / float(np.mean(x))b0 = np.mean(y) - b1 * np.mean(x)return b0, b1def predict(x, b0, b1):return b0 + x * b1x = [1, 3, 2, 1, 3]
y = [14, 24, 18, 17, 27]b0, b1 = fitSLR(x, y)
print "intercept:", b0, "slope:", b1# 假设一周广告数量为6，预测的汽车销量是多少？
x_test = 6
y_test = predict(x_test, b0, b1)
print "y_test:", y_test

4.2 多元回归分析（Multiple Regression）

1. 与简单线性回归分析（simple linear regression）的区别：多个自变量x
2. 多元回归模型
   
3. 多元回归方程
   
4. 估计多元回归方程
   
5. 估计流程（与简单线性回归类似）
   
6. 估计方法：使sum of squares最小，运算与简单线性回归类似，涉及到线性代数和矩阵代数的运算
   
7. 例子：一家公司送货，X1表示运输里程，X2表示运输次数，Y表示总运输时间
   
8. 估计模型

• Time = b0 + b1 * Miles + b2 * Deliveries
• Time = -0.869 + 0.0611 * Miles + 0.923 * Deliveries
• b0:
• b1:平均每多送一英里，运输时间延长0.0611小时
• b2:平均每多一次运输，运输时间延长0.923小时

1. 预测：若一个运输任务是跑102英里，运输6次，预计10.9小时
2. 关于误差的分布
   
3. dataset and code

100,4,9.3
50,3,4.8
100,4,8.9
100,2,6.5
50,2,4.2
80,2,6.2
75,3,7.4
65,4,6.0
90,3,7.6
90,2,6.1

python源代码

# coding=utf-8
from numpy import genfromtxt  # 将CSV数据转换成Numpy Arrays
import numpy as np
from sklearn import datasets, linear_modeldataPath = r'D:\IDEA\ML\MachineLearningBasics\DataSets\Delivery.csv'
deliveryData = genfromtxt(dataPath, delimiter=',')  # 文件路径，分隔符print 'data:'
print deliveryDataX = deliveryData[:, :-1]  # 所有行且除最后一列之外的数据
Y = deliveryData[:, -1]  # 所有行的最后一列print 'X:'
print X
print 'Y:'
print Yregr = linear_model.LinearRegression()
regr.fit(X, Y)print 'Coefficients:'
print regr.coef_  # 参数预测
print 'intercept:'
print regr.intercept_  # 截面或截距xPred = [[102, 6]]
yPred = regr.predict(xPred)
print 'predicted y:'
print yPred

1. 如果自变量中有分类型变量（Categorical Data），该如何处理？
   

100,4,0,1,0,9.3
50,3,1,0,0,4.8
100,4,0,1,0,8.9
100,2,0,0,1,6.5
50,2,0,0,1,4.2
80,2,0,1,0,6.2
75,3,0,1,0,7.4
65,4,1,0,0,6
90,3,1,0,0,7.6

4.3 非线性回归-logistic regression

1. 概率（Probability）：对一件事情发生的可能性的衡量

• 范围：0 <= P <= 1
• 计算方法：根据个人置信；根据历史数据；根据模拟数据
• 条件概率
  
• 例子
  

1. 基本模型
   
   

• 向量表示
  
• 处理二值数据，引入Sigmoid函数时曲线平滑化
  
  
• 预测函数
  
• 用概率表示：正例（y=1）
  
• 用概率表示：反例（y=0）
  

1. Cost 函数

• 线性回归
  
  
  
  

1. 梯度下降方法实现

# coding=utf-8
import numpy as np
import random# m denotes the number of examples here, not the number of features
def gradientDescent(x, y, theta, alpha, m, numIterations):"""梯度下降方法:param x:矩阵，每一行代表一个实例:param y:一维向量:param theta:向量值，最终要学习的值:param alpha:学习率:param m:实例的总个数:param numIterations:重复次数:return:"""xTrans = x.transpose()  # 计算转置矩阵for i in range(0, numIterations):hypothesis = np.dot(x, theta)  # 内积,预测值loss = hypothesis - y# ave cost per example (the 2 in 2*m doesn't really matter here)# but to be consistent with the gradient, I include itcost = np.sum(loss ** 2) / (2 * m)  # 逐渐减少print ("Iteration: %d / Cost: %f" % (i, cost))# ave gradient per examplegradient = np.dot(xTrans, loss) / m# updatetheta = theta - alpha * gradientreturn thetadef genData(numPoints, bias, variance):"""生成数据:param numPoints:有多少个实例:param bias:偏好值:param variance:方差:return:"""x = np.zeros(shape=(numPoints, 2))  # 初始化numPoints行，2列y = np.zeros(shape=numPoints)  # 初始化numPoints行，1列# basically a straight linefor i in range(0, numPoints):  # [0,numPoints)# bias featurex[i][0] = 1  # 每一行的第一列为1x[i][1] = i  # 每一行的第二列为行号# cur target variabley[i] = (i + bias) + random.uniform(0, 1) * variance  #return x, y# generate 100 points with a bias of 25 and 10 variance as a bit of noisex, y = genData(100, 25, 10)
print 'x:'
print x
print 'y:'
print y
m, n = np.shape(x)  # x的行数和列数
n_y = np.shape(y)  # y的长度
print 'x shape:', str(m), ' ', str(n)
print 'y length:', str(n_y)numIterations = 100000
alpha = 0.0005
theta = np.zeros(n)
theta = gradientDescent(x, y, theta, alpha, m, numIterations)
print theta

4.3 回归中的相关度和R平方值

1. 皮尔逊相关系数（Pearson Correlation Coefficient）

• 衡量两个值线性相关强度的量，取值范围 [-1,1]
• 正相关：> 0，负相关：< 0，无相关性：= 0
  
  
  

1. R平方值

• 定义：决定系数，反应因变量的全部变异，能通过回归关系被自变量解释的比例
• 描述：如R平方为0.8，则表示回归关系可以解释因变量80%的变异，换句话说，如果我们能控制自变量不变，则因变量的变异程度会减少80%
• 简单线性回归：R^2 = r * r
• 多元线性回归：
  

# coding=utf-8
import numpy as np
from astropy.units import *
import mathdef ComputeCorrelation(X, Y):"""计算相关度:param X: 向量1:param Y: 向量2:return:相关度"""xBar = np.mean(X)  # 均值yBar = np.mean(Y)  # 均值SSR = 0varX = 0varY = 0for i in range(0, len(X)):diffXXBar = X[i] - xBardiffYYBar = Y[i] - yBarSSR += (diffXXBar * diffYYBar)varX += diffXXBar ** 2varY += diffYYBar ** 2SST = math.sqrt(varX * varY)return SSR / SST# Polynomial Regression
def polyFit(x, y, degree):results = {}coeffs = np.polyfit(x, y, degree)# Polynomial Coefficientsresults['polynomial'] = coeffs.tolist()# r.squaredp = np.poly1d(coeffs)# fit values,and meanyhat = p(x)ybar = np.sum(y) / len(y)ssreg = np.sum((yhat - ybar) ** 2)sstot = np.sum((y - ybar) ** 2)results['determination'] = ssreg / sstotreturn resultstestX = [1, 3, 8, 7, 9]
testY = [10, 12, 24, 21, 34]
print 'r:', ComputeCorrelation(testX, testY)
print 'r^2:', str(ComputeCorrelation(testX, testY) ** 2)
print polyFit(testX, testY, 1)['determination']

5 非监督学习

非监督学习（Unsupervised Learning）

5.1 聚类(Clustering):k-means算法

1. 归类：聚类（Clustering）属于非监督学习（unsupervised learning），无类别标记（Class Label）
2. 举例
   
3. K-mean算法

• Clustering中的经典算法，数据挖掘十大经典算法之一
• 算法接收参数K，将事先输入的N个数据对象划分为K个聚类以便使所获得的聚类满足：同一聚类中的对象相似度较高，而不同聚类中对象相似度较小
• 算法思想：以空间中K个点为中心进行聚类，对最靠近他们的对象归类。通过迭代的方法，逐次更新各聚类中心的值，直至得到最好的聚类结果

1. 算法描述：
   （1）适当选择C个类的初始中心
   （2）在第K次迭代中，对任意一个样本，求其到C各中心的距离，将该样本归到距离最短的中心所在的类。
   （3）利用均值等方法更新该类的中心值
   （4）对于所有的C个聚类中心，如果（2）（3）的迭代法更新后，值保持不变，则迭代结束，否则继续迭代
2. 算法流程
   输入：K，data[n]
   (1) 选择K个初始中心点，例如c[0]=data[0],…c[k-1]=data[k-1]
   (2) 对于data[0]…data[n]，分别与c[0]…c[k-1]比较，假定与c[i]差值最小，就标记为i
   (3) 对于所有标记为i点，重新计算c[i]={所有标记为i的data[j]之和} / 标记为i的个数
   (4) 重复（2）（3），直到所有c[i]值的变化小于给定阈值

1. 算法特点

• 优点速度快，简单
• 缺点：最终结果跟初始点选择相关，容易陷入局部最优，需要确定K值

1. Python代码实现

# coding=utf-8
import numpy as np# Function: K Means
def KMeans(x, k, maxIt):"""K-mean算法:param x: 数据集:param k: K个聚类:param maxIt: 最大迭代次数:return: 最多迭代次数"""numPoints, numDim = x.shape  # 矩阵的行和列dataSet = np.zeros((numPoints, numDim + 1))dataSet[:, :-1] = x  # 所有行+除去最后一列# Initialize centroids randomly#centroids = dataSet[np.random.randint(numPoints, size=k), :]  # 随机选取中心点，随机K行+所有列centroids = dataSet[0:2, :]# Randomly assign labels to initial centroidscentroids[:, -1] = range(1, k + 1)  # 初始化中心点[1,k)# Initialize book keeping varsiterations = 0  # 迭代次数oldCentroids = None# Run the Main k-Means Algorithmwhile not shouldStop(oldCentroids, centroids, iterations, maxIt):print 'Iterations:\n', iterationsprint 'dataSet:\n', dataSetprint 'centroids:\n', centroids# Save old centroids for convergence test.oldCentroids = np.copy(centroids)iterations += 1# Assign labels to each data points base on centroidsupdateLabels(dataSet, centroids)# Assign centroids base on dataPoint labelcentroids = getCentroids(dataSet, k)return dataSetdef shouldStop(oldCentroids, centroids, iterations, maxIt):"""迭代是否停止:param oldCentroids: 旧中心点:param centroids: 现中心点:param iterations: 现迭代次数:param maxIt: 最大迭代次数:return: true or false"""if iterations > maxIt:return Truereturn np.array_equal(oldCentroids, centroids)def updateLabels(dataSet, centroids):numPoints, numDim = dataSet.shapefor i in range(0, numPoints):dataSet[i, -1] = getLabelFromClosestCentroid(dataSet[i, :-1], centroids)def getLabelFromClosestCentroid(dataSetRow, centroids):label = centroids[0, -1]minDist = np.linalg.norm(dataSetRow - centroids[0, :-1])for i in range(1, centroids.shape[0]):dist = np.linalg.norm(dataSetRow - centroids[i, :-1])if dist < minDist:minDist = distlabel = centroids[i, -1]print 'minDist:', minDistreturn labeldef getCentroids(dataSet, k):result = np.zeros((k, dataSet.shape[1]))for i in range(1, k + 1):oneCluster = dataSet[dataSet[:, -1] == i, :-1]result[i - 1, :-1] = np.mean(oneCluster, axis=0)result[i - 1, -1] = ireturn resultx1 = np.array([1, 1])
x2 = np.array([2, 1])
x3 = np.array([4, 3])
x4 = np.array([5, 4])
testX = np.vstack((x1, x2, x3, x4))result = KMeans(testX, 2, 10)
print "final result:\n", result

5.2 聚类(Clustering):层次聚类

1. 假设有N个待聚类的样本，对于层次聚类来说
   (1) （初始化）把每个样本归为一类，计算两个类之间的距离，也就是样本与样本之间的相似度
   (2) 寻找各个类之间最近的两个类，把他们归为一类，这样类的总数就少了一个
   (3) 重新计算新生成的这个类与各个旧类之间的相似度
   (4) 重复2和3直到所有的样本归为一类，结束
   
2. 整个聚类过程其实是建立了一棵树，在建立的过程中，可以通过在第二步上设置一个阈值，当最近的两个类大于这个阈值，则认为迭代可以终止。另外关键的一步就是第三步，如何判断两个类之间的相似度有多种方法。

• SingleLinkage：又叫做nearest-neighbor，就是取两个类中距离最近的两个样本的距离作为这两个集合的距离，也就是说，最近两个样本之间的距离越小，这两个类之间的相似度就越大。容易造成一种叫做链式（chaining）的效果，两个聚类明明从大局上离得比较远，但是由于其中个别的点距离比较近就被合并了，并且这样合并之后，链式效果会进一步扩大，最后会得到比较松散的聚类。
• completeLinkage：这个则完全是SingleLinkage的反面极端，取两个集合中距离最远的两个点的距离作为两个集合的距离，其效果也是刚好相反的，限制非常大，两个聚类即使已经很接近了但是只要有不配合的点存在，就顽固到底，老死不相合并，也是不太好的办法，这两种相似度的定义方法的共同问题就是只考虑了某个有特点的数据，而没有考虑类内数据的整体特点。
• average-linkage：这种方法就是把两个集合中的点的距离全部放在一起求一个平均值，也能得到相对合适的结果。
• average-linkage：一个变种就是取两两距离的中值，与取均值相比更加能够解除个别偏离样本对结果的干扰。

6 小结

机器学习(Machine Learning)

1. 概念：多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度等多门学科，专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构，使之不断改善自身的性能。
2. 学科定位：人工智能（Artificial Intelligence）的核心，是计算机具有智能的根本途径，其应用遍及人工智能的各个领域，主要使用归纳和综合，而不是演绎
3. 定义

• 探究和开发一系列算法，使计算机不需要外部明显的指示，可以自己通过数据来学习和建模，并且利用建好的模型和新的输入来进行预测的学科。
• 一门不需要外部程序指示而让计算机有能力自我学习的学科。
• 机器学习是一门人工智能的科学，该领域主要研究对象是人工智能，特别是如何在经验中改善具体算法的性能。
• 机器学习是对能通过经验，自动改进的计算机算法的研究

1. 学习：针对经验E、一系列任务T、一定表现的衡量P，如果随经验E的积累，针对定义好的任务T可以提高表现P，就说计算机具有学习能力。例如，下棋、语音识别、自动驾驶

软件研发工程师转行机器学习之路相关推荐

1. Java软件研发工程师转行之深度学习(Deep Learning)进阶：手写数字识别+人脸识别+图像中物体分类+视频分类+图像与文字特征+猫狗分类

   本文适合于对机器学习和数据挖掘有所了解,想深入研究深度学习的读者 1.对概率基本概率有所了解 2.具有微积分和线性代数的基本知识 3.有一定的编程基础(Python) Java软件研发工程师转行之深度 ...

2. 图像算法工程师 转行之路

   图像算法工程师 转行之路 传统图像 + 深度学习图像 + 语言工具 + 光学基础知识 1.图像处理的基础:冈萨雷斯的<数字图像处理>这本书必看.里面算法虽然老,但是还是很实用的.搭配它拍套 ...

3. 机器学习的路，感觉很受用

   营长的一位转型AI的朋友,最近对营长抱怨,"走过的最远的路,就是机器学习过程中的弯路",然后开始各种blablabla,从论文的坑,到模型的坑,再到培训的坑...一路吐槽. 尤其是 ...

4. 仅需10分钟：开启你的机器学习之路

   选自freecodecamp 作者:Tirmidzi Faizal Aflahi 机器之心编译 机器学习之路虽漫漫无垠,但莘莘学子依然纷纷投入到机器学习的洪流中.如何更有效地开始机器学习呢?所谓「八仙 ...

5. 会计转行算法之路（一）会计转程序员

   会计转行算法之路(一)会计转程序员 回忆起来,要感谢互联网,感谢开源,没有互联网,就没有我的今天,我也就无法走上自己的追梦之路. 每次迷茫的时候,回忆一下初心,我的理想是什么? 通过科学技术,改善人们 ...

6. 干货 | 仅需10分钟，开启你的机器学习之路！

   点击"小詹学Python",选择"置顶"公众号 重磅干货,第一时间送达 本文转载自机器之心,禁二次转载 机器学习之路虽漫漫无垠,但莘莘学子依然纷纷投入到机器学习 ...

7. 程序员如何开启机器学习之路

   我曾是一名想进入AI行业的软件开发者.为了更快熟悉这里边的门道,我阅读了机器学习的书籍,浏览了不少帖子,还学习了Coursera上关于机器学习的课程. 但是,但是,依然不知道如何开始-- 你是否也有这 ...

8. 中科研研究生：从算法工程师转行产品经理之后

   向AI转型的程序员都关注了这个号???????????? 机器学习AI算法工程   公众号:datayx 2020年7月21日,从算法工程师转行AI产品经理的第一天,到现在满两个月了.说来我的路径也比 ...

9. AI芯片独角兽寒武纪 - 诚聘虚拟化/深度学习框架/系统软件研发工程师

   公司简介 寒武纪是全球智能芯片领域的先行者,公司的使命是打造各类智能云服务器.智能终端以及智能机器人的核心处理器芯片,让机器更好地理解和服务人类. 公司创始人.首席执行官陈天石博士,在处理器架构和人工 ...

最新文章

1. 2022-2028年中国锂电材料产业投资分析及前景预测报告
2. 入机器学习大坑，我需要什么样的数学水平？
3. 宋琦:PHP在微博优化中的“大显身手”
4. c语言用法 我说火罐火车 刘华火车,五塘村社区建“火车头广场”
5. Python中使用wordcloud生成漂亮的中文词云
6. 六、最通俗易懂的JavaScript进阶教程（二）
7. 创建一个dynamics CRM workflow (二) - Build in Workflows
8. bootstrap grid php,bootstrap grid用法
9. mysql中临时修改参数用什么关键字_postgresql 中的参数查看和修改方式
10. 本地java【动态监听】zk集群节点变化
11. 开放下载！《OSS运维基础实战手册》
12. 2021年净利润同比增长75.9% 孟晚舟称华为已穿过劫难黑障区
13. 经典算法冒泡 和二分法
14. linux批量配置文件,linux下根据用户输入批量修改配置文件ip
15. matlab按图像边缘抠图_干货：PS抠图的九种方法，最后一个简直是万能
16. WebEx Recorder
17. 智能中医诊疗系统php代码,智能新型中西医处方系统
18. 基于图神经网络的推荐系统
19. 解决Win10下安装Winpcap失败
20. WiFi-ESP8266入门http（3-3）网页认证上网-post请求-ESP8266程序

热门文章

1. 实战NFS服务搭建与配置
2. JavaScript中四种不同的属性检测方式比较
3. urllib基本使用-Handler和自定义的opener()
4. 软件工程——团队作业3
5. 虚幻4蓝图快速入门（二）
6. 判定一个点是否在三角形内
7. iOS开发～sizeClass和autolayout
8. C#Windows 服务制作安装删除. 用户注销后，程序继续运行 (转载）
9. python web开发第三方库_Python Web开发中常用的第三方库
10. 一只快乐的野指针_野酸枣