精华内容
参与话题
问答
  • python机器学习手写算法系列——线性回归

    万次阅读 多人点赞 2019-05-06 19:51:29
    本文致力于手把手教你实现一个最简单的机器学习模型--一元线性回归模型。短短的14行代码,就实现了。希望读完以后,你也能自己实现它。并对线性回归有更好的了解,或者从不了解到了解。

    本系列另一篇文章《决策树》
    https://blog.csdn.net/juwikuang/article/details/89333344

    本文源代码:
    https://github.com/juwikuang/machine_learning_step_by_step

    最近我发现我之前写的一篇文章《一个公式告诉你为什么程序员要转算法工程师》
    http://blog.csdn.net/juwikuang/article/details/73057194
    有很多人访问。我想,很多程序员和我当初一样,想从程序员转算法工程师。

    说说我当初为什么会想到升级成算法工程师。记得三年前,我还在印孚瑟斯(Infosys),我们的CFO非常自豪的宣布公司已经成功的让专科生的比例提高了,让本科生的比例降低了。我作为一个本科程序员,听了十分难受。当然,公司这样做是为了利润,也合理合法。换了我是CFO,我也会这样做,不过,我应该不会像他一样大声说。有些事,可以做,不能说。

    后来,机缘巧合,我学习了机器学习,走上了算法工程师这条路。当时我学机器学习,是从吴恩达(Andrew Ng)的Coursera课程开始的。很多人和我一样,也是开了这门课,开始机器学习的。这门课挺好,可惜开发语言用了Octave,以至于我每次写作业,都很痛苦,因为我还要学Octave语言,而且这东西学了也没啥用。另外,这门课是英语的,只有少数人能看懂。

    本文的目的,就是从最基本,最简单的机器学习算法讲起,手把手的教你实现这个算法。一边编程,一边就明白这个算法的原理了。我本人也是程序员转的算法工程师,我们的强项就是编程,弱项就是数学。我针对这个特点,专门做了以下教程。

    言归正传。首先我们看看线性回归在整个机器学习里的位置。

    从机器学习到线性回归

    线性回归在整个机器学习

    今天,我们只关注机器学习到线性回归这条线上的概念。别的以后再说。为了让大家听懂,我这次也不查维基百科了,直接按照自己的理解用大白话说,可能不是很严谨。

    机器学习就是机器可以自己学习,而机器学习的方法就是利用现有的数据和算法,解出算法的参数。从而得到可以用的模型。

    监督学习就是利用已有的数据(我们叫X,或者特征),和数据的标注(我们叫Y),找到x和y之间的对应关系,或者说是函数f。

    回归分析是一种因变量为连续值得监督学习。

    线性回归是一种x和y之间的关系为线性关系的回归分析。y=a1x1+a2x2+by=a_1x_1+a_2x_2+by=a1x1+a2x2+b,这个叫线性关系。如果这里出现了x2x^2x2,log(x)log(x)log(x), sin(x)sin(x)sin(x)之类的,那就不是线性关系了。

    一元线性回归说的是,自变量x是一个纯量(scalar)。scalar类型的变量,是不可再分的。

    我希望你能说明白这些概念的关系。不过,我自己也是花了很久才了解清楚的。如果你没听明白,也没关系。毕竟都是概念,没什么实际的例子,也很难理解。等你看完了本文,了解了一元线性回归。回过头来再看这些概念,就能更好的理解了。

    问题

    这里,我们的问题是,找出算法工程师和程序员之间的工资关系。这里直接给出北京,上海,杭州,深圳,广州的工资。

    城市 x-程序员工资 y-算法工程师工资
    北京 1.3854 2.1332
    上海 1.2213 2.0162
    杭州 1.1009 1.9138
    深圳 1.0655 1.8621
    广州 0.09503 1.8016

    把他们用图打出来看看他们之间的关系。

    程序员和算法工程师工资

    由图可见,他们之间大致是一个线性关系,这时候,我们就可以试着用一元线性回归去拟合(fit)他们之间的关系。

    数学模型

    一元线性回归公式

    以下是公式
    y=ax+b+εy=ax+b+εy=ax+b+ε

    y 为应变量 dependent variable
    x 为自变量 independent variable
    a 为斜率 coeffient
    b 为截距 intercept
    ε (读作epsilon)为误差,正态分布
    线性回归的目标是,找到一组a和b,使得ε最小
    y^=ax+b\hat{y}=ax+by^=ax+b
    ε=y−y^ε=y-\hat{y}ε=yy^

    y^\hat{y}y^ 读作y hat,也有人读作y帽子。这里的帽子一般表示估计值,用来区别真实值y。

    下图可以更好的帮助你理解。

    一元线性回归
    (图片来自互联网)

    黑色的点为观测样本,即y=ax+b+εy=ax+b+εy=ax+b+ε

    x红色的线为回归线,即y^=ax+b\hat{y}=ax+by^=ax+b

    x蓝色的线段为误差,即ε=y−y^ε=y-\hat{y}ε=yy^

    方差 - 损失函数 Cost Function

    在机器学习中,很多时候,我们需要找到一个损失函数。有了损失函数,我们就可以经过不断地迭代,找到损失函数的全局或者局部最小值(或者最大值)。损失函数使得我们的问题转化成数学问题,从而可以用计算机求解。在线性回归中,我们用方差作为损失函数。我们的目标是使得方差最小。

    下面的表格解释了什么是方差。

    方差

    其中SSE(Sum of Square Error)是总的方差,MSE(Mean Square Error)是方差的平均值。

    而这里的损失函数,用的是0.5 * MSE。即:

    J(a,b)=12n∑i=0n(yi−y^i)2J(a,b)=\frac{1}{2n}\sum_{i=0}^{n}(y_i−\hat{y}_i )^2J(a,b)=2n1i=0n(yiy^i)2

    记住,这里的损失函数是针对参数a和b的函数,y和y^\hat{y}y^ 其实都是已知的。

    优化方法 Optimization Function

    有了损失函数,我们还需要一个方法,使得我们可以找到这个损失函数的最小值。机器学习把他叫做优化方法。这里的优化方法,就是算损失的方向。或者说,当我的参数变化的时候,我的损失是变大了还是变小了。如果a变大了,损失变小了。那么,说明a增大这个方向是正确的,我们可以朝着这个方向继续小幅度的前进。反之,就应该考虑往相反的方向试试看。因为每个参数(a和b)都是一维的,所以,所谓的方向,无非就是正负符号。

    这里,我们需要用偏微分的方法,得到损失函数的变化量。即:

    ∂J∂a=∂12n∑i=0n(yi−y^i)2∂a\frac{\partial J}{\partial a} = \frac{\partial \frac{1}{2n}\sum_{i=0}^{n}(y_i−\hat{y}_i )^2}{\partial a}aJ=a2n1i=0n(yiy^i)2
    =1n∑i=0n(yi−axi−b)∂(yi−axi−b)∂a= \frac{1}{n}\sum_{i=0}^{n}(y_i-ax_i-b) \frac{\partial (y_i-ax_i-b)}{\partial a}=n1i=0n(yiaxib)a(yiaxib)
    =1n∑i=0n(yi−axi−b)(−xi)= \frac{1}{n}\sum_{i=0}^{n}(y_i-ax_i-b) (-x_i)=n1i=0n(yiaxib)(xi)
    =1n∑i=0nx(y^i−yi)= \frac{1}{n}\sum_{i=0}^{n}x(\hat{y}_i-y_i)=n1i=0nx(y^iyi)

    ∂J∂b=∂12n∑i=0n(yi−y^i)2∂a\frac{\partial J}{\partial b} = \frac{\partial \frac{1}{2n}\sum_{i=0}^{n}(y_i−\hat{y}_i )^2}{\partial a}bJ=a2n1i=0n(yiy^i)2
    =1n∑i=0n(yi−axi−b)∂(yi−axi−b)∂b= \frac{1}{n}\sum_{i=0}^{n}(y_i-ax_i-b) \frac{\partial (y_i-ax_i-b)}{\partial b}=n1i=0n(yiaxib)b(yiaxib)
    =1n∑i=0n(yi−axi−b)(−1)= \frac{1}{n}\sum_{i=0}^{n}(y_i-ax_i-b) (-1)=n1i=0n(yiaxib)(1)
    =1n∑i=0n(y^i−yi)= \frac{1}{n}\sum_{i=0}^{n}(\hat{y}_i-y_i)=n1i=0n(y^iyi)

    如果你已经忘了微积分,你暂时可以不必纠结上面的公式,只要知道公式给出了损失函数的变化就可以了。伟大的python还提供了sympy,你可以用sympy做微积分。这部分我也放在附件代码里了,有兴趣的可以看一下。

    之前说到,整过迭代过程是小幅度进行的。这里,就需要一个超参数来控制这个过程。这个超参数就是α\alphaα,通常是0.01.

    这时,我们就可以去更新a和b的值:
    a=a−α∂J∂aa = a - \alpha \frac{\partial J}{\partial a}a=aαaJ
    b=b−α∂J∂bb = b - \alpha \frac{\partial J}{\partial b}b=bαbJ

    到这里,在你继续往下读之前,你先自己考虑一下,为什么这里是负号?

    你考虑好了么,如果你考虑好了,我就公布答案了。

    本身∂J∂a\frac{\partial J}{\partial a}aJ∂J∂b\frac{\partial J}{\partial b}bJ 是损失函数的变化量。如果损失函数随着a变大了,即 ∂J∂a\frac{\partial J}{\partial a}aJ 为正。说明a的增大会导致损失函数的增大。那么是不是说,a的减小会使得损失函数减小呢?而我们的目标是使得J最小,所以,这个时候,我们的a要减小一点点。

    损失的方向
    (图片来自互联网)

    算法步骤

    1. a和b的起始值设置为零
    2. 通过模型y^=ax+b\hat{y}=ax+by^=ax+b,我们可以算出y^\hat{y}y^
    3. 有了y^\hat{y}y^,就可以用优化方法算去更新参数
    4. 重复2和3,直到找到J的最小值

    流程图如下:

    Created with Raphaël 2.2.0开始a=0, b=0计算模型y_hat=ax+b计算a和b的微分更新a和b找到损失函数的最小值结束yesno

    下图解释了模型,损失函数和优化方法之间的关系。

    模型,损失函数和优化方法之间的关系

    Python 实现

    理论部分先告一段落,我们现在开始写代码,实现一元线性回归。

    首先是模型,这个很简单:

    def model(a, b, x):
        return a*x + b
    

    接着,是损失函数:

    def cost_function(a, b, x, y):
        n = 5
        return 0.5/n * (np.square(y-a*x-b)).sum()
    

    最后,是优化函数:

    def optimize(a,b,x,y):
        n = 5
        alpha = 1e-1
        y_hat = model(a,b,x)
        da = (1.0/n) * ((y_hat-y)*x).sum()
        db = (1.0/n) * ((y_hat-y).sum())
        a = a - alpha*da
        b = b - alpha*db
        return a, b
    

    以上三个函数中a和b是标量(scalar value),x和y是向量(vector)
    至此,一元线性回归的主要部分就完成了。一共才14行代码,是不是很简单。

    训练模型

    有了模型,损失函数,优化函数,我们就可以训练模型了。具体过程请见附件代码。

    这里给出分别训练1次,再训练5次,再训练10次,再训练100,再训练10000次的模型。

    1次

    5次

    10次

    100次

    10000次

    从上面几幅图,我们可以看到,随着训练次数的增加,回归线越来越接近样本了。我们自己写的线性回归比较简单,我只能目测,凭直觉感觉损失函数已经达到了最小值,我们就停在10000次吧。

    看得再多,不如自己动手。阅读下一章节之前,请自己实现一元线性回归。

    这里有现成的代码,供你参考。

    http://download.csdn.net/download/juwikuang/10050886

    模型评价

    在机器学习中,模型的好坏是有标准的。在回归模型中,我们用R2R^2R2 来评价模型。公式:
    R2=SSR/SSTR^2=SSR/SSTR2=SSR/SST
    其中
    SSR=∑i=0n(y^i−yˉ)SSR=\sum_{i=0}^{n}(\hat{y}_i-\bar{y})SSR=i=0n(y^iyˉ)
    SST=∑i=0n(yi−yˉ)SST=\sum_{i=0}^{n}(y_i-\bar{y})SST=i=0n(yiyˉ)
    yˉ\bar{y}yˉ 读作y bar,是y的平均值。
    可以证明SST=SSR+SSESST=SSR+SSESST=SSR+SSE,证明过程又会涉及到期望等概念,我们这里不展开了。

    好了,现在你应该回到代码中去计算R2R^2R2 了。

    用scikit-learn训练和评价模型

    平时在工作中,我们不可能自己去写回归模型,最常用的第三方工具是scikit-learn。
    其官网是:
    http://scikit-learn.org/

    以下是ipython代码。

    import numpy as np
    from sklearn.linear_model import LinearRegression
    import matplotlib.pyplot as plt
    %matplotlib inline
    
    x = [13854,12213,11009,10655,9503] #程序员工资,顺序为北京,上海,杭州,深圳,广州
    x = np.reshape(x,newshape=(5,1)) / 10000.0
    y =  [21332, 20162, 19138, 18621, 18016] #算法工程师,顺序和上面一致
    y = np.reshape(y,newshape=(5,1)) / 10000.0
    # 调用模型
    lr = LinearRegression()
    # 训练模型
    lr.fit(x,y)
    # 计算R平方
    print lr.score(x,y)
    # 计算y_hat
    y_hat = lr.predict(x)
    # 打印出图
    plt.scatter(x,y)
    plt.plot(x, y_hat)
    plt.show()
    
    

    恭喜你,看完了本文,也学会了一元线性回归。如果对你有帮助,请给我一个赞。你的支持和鼓励是我继续写下去的动力。

    如果有疑问,请下面留言。

    python机器学习手写算法系列

    完整源代码:

    https://github.com/juwikuang/machine_learning_step_by_step

    欢迎阅读本系列其他文章:

    《python机器学习手写算法系列——线性回归》

    《python机器学习手写算法系列——逻辑回归》

    《python机器学习手写算法系列——决策树》

    《python机器学习手写算法系列——kmeans聚类》

    展开全文
  • Python数据分析与机器学习实战教程,该课程精心挑选真实的数据集为案例,通过python数据科学库numpy,pandas,matplot结合机器学习库scikit-learn完成一些列的机器学习案例。课程以实战为基础,所有课时都结合代码演示...
  • 从零开始学习机器学习视频教程

    万人学习 2017-12-04 22:38:30
    人工智能作为现在最为火热的领域,使得机器学习被越来越多的人所了解。机器学习难学,主要的难度在于算法模型多不好理解,各种各样的工具不知道如何使用,实际项目不知道如何开发。本门课程将系统入门机器学习,课程...
  • 机器学习水果识别——python+opencv实现物体特征提取

    万次阅读 多人点赞 2018-12-02 21:30:56
    文章目录一、用python+opencv实现物体特征值提取1、读取图像、转为灰度图像并降噪2、获取水果轮廓将最大轮廓画入最开始的img...要用机器学习来实现水果识别,无论是训练还是识别阶段都需要提取图片中水果的特征值。...

    刚接触机器学习时候写的了,当时只知道机器学习不知道深度学习还以为只能人为的提取特征根据特征训练,后来才发现有深度学习这样更好的选择可以自动提取特征值。除了特征,深度学习在复杂背景下的效果也会明显优于普通机器学习,所以还是建议使用深度学习的方法。2019.4.25

    一、用python+opencv实现物体特征值提取

    以水果为例。要用机器学习来实现水果识别,无论是训练还是识别阶段都需要提取图片中水果的特征值。本篇将讲述如何提取水果的周长面积颜色长度宽度7个特征值。

    1、读取图像、转为灰度图像并降噪

    from math import *
    import cv2 as cv
    import numpy as np
    
    img = cv.imread(path)
    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
    blurred = cv.GaussianBlur(gray, (3, 3), 0)
    

    2、获取水果轮廓

    这里使用图像梯度的方法

    xgrad = cv.Sobel(blurred, cv.CV_16SC1, 1, 0)
    ygrad = cv.Sobel(blurred, cv.CV_16SC1, 0, 1)
    edge_output = cv.Canny(xgrad, ygrad, 50, 150)
    
    cloneImg, contours, heriachy = cv.findContours(edge_output, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    

    cv.findContours将图片中识别到的轮廓返回给contours变量,contours是一个list类型数据,里面存放了识别到的所有轮廓。有时候并不能很好的将目标轮廓完整的识别出来或者有没有去除掉的噪点的干扰所以不能简单粗暴的将获取到的轮廓全部运用。我尝试了一下两种方法:

    将最大轮廓画入最开始的img图像并显示

    max = 0
    maxA = 0
    for i, contour in enumerate(contours):
        x, y, w, h = cv.boundingRect(contour)
        if w*h>maxA:
        	max=i
        	maxA=w*h
    cv.drawContours(img, contours, max, (0, 0, 255), 2)
    #画框
    x, y, w, h = cv.boundingRect(contours[max])
    img = cv.rectangle(img, (x, y), (x + w, y + h), (0, 255,  0), 2)
    cv.imshow('img', img)
    

    结果如图:
    理想状态下轮廓被识别为多部分

    这个方法有一个问题:如果目标物体的轮廓被分为了多个区域,则不能完全显示出来轮廓。
    所以想到了另一个方法:

    将小于某一规模的轮廓删除

    num=[]
    for i, contour in enumerate(contours):
    	x, y, w, h = cv.boundingRect(contour)
    	if w < 50 or h < 50:
            continue
        num.append(i)
    for i in num:
    	if i == 0:
    		continue
    	contours[0] = np.concatenate((contours[i], contours[0]))
    cv.drawContours(img, contours, max, (0, 0, 255), 2)
    #画框
    x, y, w, h = cv.boundingRect(contours[0])
    img = cv.rectangle(img, (x, y), (x + w, y + h), (0, 255,  0), 2)
    cv.imshow('img', img)
    

    轮廓拼接的效果
    这个方法可以去除噪点的影响并且将轮廓连接起来。虽然轮廓也不正确但是矩形框是正确的。
    轮廓可以通过cv2.contourArea和cv2.arcLength(cnt,True)分别获取面积和周长,但是因为轮廓是错误的,面积和周长求出来是不正确的。但是通过画出来的矩形框可以明显看出第二种方法是优于第一种方法的,所以我们要另找方法来获得周长和面积。到这里,已经可以拿到水果的长和宽了:

    length = 0
    width = 0
    if w > h:
        length = w
        width = h
    else:
        length = h
        width = w
    

    3、提取水果的面积周长及颜色

    为了提取面积和周长,这里分别再产生二值图和二值图的边缘提取图
    ###尽可能消除环境噪点的影响
    将要用到的图像先剪裁出刚才识别到的区域,减小背景对识别影响的可能性

    def myCut(img, x, y, w, h):
        cut = img[y:y + h, x:x + w]
        cv.imshow("cut", cut)
        return cut
    
    cut_img = myCut(img, x, y, w, h)
    cut_blurred = myCut(blurred, x, y, w, h)
    

    获取二值图并计算面积

    def GetArea(img):
        count = 0
        point_y = []
        point_x = []
        height, width = img.shape
        for h in range(0, height, 1):
            for w in range(0, width, 1):
                if (img[h, w] == 0):
                    count += 1
                    point_y.append(h)
                    point_x.append(w)
        return count, point_x, point_y
    
    ret, binary = cv.threshold(cut_blurred, 70, 255, cv.THRESH_BINARY)
    cv.imshow("bi", binary)  # 求面积
    area, point_x, point_y = GetArea(binary)
    

    其中point_x、point_y分别记录着面积的区域,之后求颜色需要用到。

    提取边缘并计算周长

    def GetCircumference(img):
        count = 0
        height, width = img.shape
        for h in range(0, height, 1):
            for w in range(0, width, 1):
                if (img[h, w] == 255):
                    count += 1
        return count
    
    edge = cv.Canny(binary, 40, 100)
    cv.imshow("edge", edge)  # 求周长
    circumference = GetCircumference(edge)
    

    提取平均颜色

    def GetColor(img, point_height, point_width):
        R = 0
        G = 0
        B = 0
        count = 0
        color = []
        for i in range(0, len(point_height), 1):
            count += 1
            R += img[point_height[i], point_width[i]][0]
            G += img[point_height[i], point_width[i]][1]
            B += img[point_height[i], point_width[i]][2]
        R = int(R / count)
        G = int(G / count)
        B = int(B / count)
        color.append(R)
        color.append(G)
        color.append(B)
        return color
    color = GetColor(cut_img, point_height, point_width)
    
    #打印刚才所求的面积周长及颜色
    print('area:', area, 'circumference:', circumference, 'longth:', longth, 'width:', width, 'color:', color)
    

    二、代码

    
    #!usr/env/bin python3
    
    from math import *
    import cv2 as cv
    import numpy as np
    
    file = '/Users/apple/Desktop/video/image-1/'
    p=file+'data.txt'
    #f = open(p, 'a')
    
    
    def myCut(img, x, y, w, h):
        cut = img[y:y + h, x:x + w]
        cv.imshow("cut", cut)
        return cut
    
    
    def GetColor(img, point_height, point_width):
        R = 0
        G = 0
        B = 0
        count = 0
        color = []
        for i in range(0, len(point_height), 1):
            count += 1
            R += img[point_height[i], point_width[i]][0]
            G += img[point_height[i], point_width[i]][1]
            B += img[point_height[i], point_width[i]][2]
        R = int(R / count)
        G = int(G / count)
        B = int(B / count)
        color.append(R)
        color.append(G)
        color.append(B)
        return color
    
    
    # 返回面积
    def GetArea(img):
        count = 0
        point_height = []
        point_width = []
        height, width = img.shape
        for h in range(0, height, 1):
            for w in range(0, width, 1):
                if (img[h, w] == 0):
                    count += 1
                    point_height.append(h)
                    point_width.append(w)
        return count, point_width, point_height
    
    
    # 返回周长
    def GetCircumference(img):
        count = 0
        height, width = img.shape
        for h in range(0, height, 1):
            for w in range(0, width, 1):
                if (img[h, w] == 255):
                    count += 1
        return count
    
    def edge(img):
        # 灰度图像
        gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
    
        # 高斯模糊,降低噪声
        blurred = cv.GaussianBlur(gray, (3, 3), 0)
    
        # 图像梯度
        xgrad = cv.Sobel(blurred, cv.CV_16SC1, 1, 0)
        ygrad = cv.Sobel(blurred, cv.CV_16SC1, 0, 1)
        # 计算边缘
        # 50和150参数必须符合1:3或者1:2
        edge_output = cv.Canny(xgrad, ygrad, 50, 150)
    
    
        cloneImg, contours, heriachy = cv.findContours(edge_output, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
    
        # max = 0
        # maxA = 0
        num = []
        for i, contour in enumerate(contours):
            x, y, w, h = cv.boundingRect(contour)
            # if (w * h > maxA):
            #     max = i
            #     maxA = w * h
    
            if w < 50 or h < 50:
                continue
            num.append(i)
    
        for i in num:
            # cv.drawContours(img, contours, i, (0, 0, 255), 2)
            # x, y, w, h = cv.boundingRect(contours[i])
            # img = cv.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
            if i == 0:
                continue
            contours[0] = np.concatenate((contours[i], contours[0]))
    
        cv.imshow('img', img)
    
        x, y, w, h = cv.boundingRect(contours[0])
    
        cut_img = myCut(img, x, y, w, h)
        cut_blurred = myCut(blurred, x, y, w, h)
        cv.imshow('cut', cut_blurred)
    
        ret, binary = cv.threshold(cut_blurred, 70, 255, cv.THRESH_BINARY)
        cv.imshow("bi", binary)  # 求面积
    
        edge = cv.Canny(binary, 40, 100)
        cv.imshow("edge", edge)  # 求周长
    
        longth = 0
        width = 0
        if w > h:
            longth = w
            width = h
        else:
            longth = h
            width = w
        area, point_width, point_height = GetArea(binary)
        circumference = GetCircumference(edge)
        color = GetColor(cut_img, point_height, point_width)
    
        print('area:', area, 'circumference:', circumference, 'longth:', longth, 'width:', width, 'color:', color)
        # f.write(str(area))
        # f.write(' ')
        # f.write(str(circumference))
        # f.write(' ')
        # f.write(str(longth))
        # f.write(' ')
        # f.write(str(width))
        # f.write(' ')
        # for i in range(3):
        #     f.write(str(color[i]))
        #     f.write(' ')
        # f.write('\n')
    
    
    def do():
        for i in range(1, 8, 1):
            print(i, ':')
            path = file + str(i) + '.jpg'
    
            src1 = cv.imread(path)
    
            # 图三(原图)
            size = src1.shape
            src = cv.resize(src1, ((int)(size[1] / 5), (int)(size[0] / 5)), cv.INTER_LINEAR)
            edge(src)
            cv.waitKey(0)
    
        cv.destroyAllWindows()
        #f.closed()
    do()
    
    1 :
    area: 7032 circumference: 605 longth: 183 width: 177 color: [34, 31, 35]
    2 :
    area: 8564 circumference: 619 longth: 206 width: 197 color: [34, 29, 32]
    3 :
    area: 9032 circumference: 623 longth: 221 width: 215 color: [44, 36, 37]
    4 :
    area: 9121 circumference: 630 longth: 232 width: 214 color: [44, 37, 38]
    5 :
    area: 10747 circumference: 714 longth: 224 width: 216 color: [43, 36, 40]
    6 :
    area: 9127 circumference: 630 longth: 196 width: 194 color: [44, 39, 44]
    7 :
    area: 9787 circumference: 636 longth: 198 width: 198 color: [46, 41, 47]
    
    展开全文
  • Python机器学习经典案例实战

    千人学习 2017-03-24 08:54:50
    Python机器学习领域应用是非常广泛的,比如,我们可以使用机器学习进行验证码识别,使用机器学习实现计算机视觉项目,或者,我们也可以使用机器学习技术实现网页分类、文本挖掘、情感分析等等各种各样的事情。机器...
  • Python 机器学习经典实例

    万次阅读 2018-04-12 10:44:15
    内容介绍 在如今这个处处以数据驱动的世界中,机器学习正变得越来越大众化。它已经被广泛地应用于不同领域,如搜索...用最火的 Python 语言、通过各种各样的机器学习算法来解决实际问题! 书中介绍的主要问题如下。 ...

    内容介绍

    在如今这个处处以数据驱动的世界中,机器学习正变得越来越大众化。它已经被广泛地应用于不同领域,如搜索引擎、机器人、无人驾驶汽车等。本书首先通过实用的案例介绍机器学习的基础知识,然后介绍一些稍微复杂的机器学习算法,例如支持向量机、极端随机森林、隐马尔可夫模型、条件随机场、深度神经网络,等等。

    用最火的 Python 语言、通过各种各样的机器学习算法来解决实际问题!

    书中介绍的主要问题如下。

    • 探索分类分析算法并将其应用于收入等级评估问题
    • 使用预测建模并将其应用到实际问题中
    • 了解如何使用无监督学习来执行市场细分
    • 探索数据可视化技术以多种方式与数据进行交互
    • 了解如何构建推荐引擎
    • 理解如何与文本数据交互并构建模型来分析它
    • 使用隐马尔科夫模型来研究语音数据并识别语音

    作者简介

    Prateek Joshi,人工智能专家,重点关注基于内容的分析和深度学习,曾在英伟达、微软研究院、高通公司以及硅谷的几家早期创业公司任职。

    本书内容

    译者序

    有一天,忽然想到自己整天面对着52个英文字母、9个数字、32个符号和一个空格,经常加班没有双休日,好傻。时间不断被各种噪声碎片化,完全就是毛姆在《月亮和六便士》里写的,“If you look on the ground in search of a sixpence, you don't look up, and so miss the moon”,整天低头刷手机,却不记得举头望明月。生活也愈发无序,感觉渐渐被掏空。薛定谔的《生命是什么》给我提了个醒,他在“以‘负熵’为生”(It Feeds On ‘negative Entropy’)一节指出:“要活着,唯一的办法就是从环境里不断地汲取负熵。”在介绍了熵的概念及其统计学意义之后,他紧接着在“从环境中引出‘有序’以维持组织”(Organization Maintained By Extracting ‘Order’From The Environment)一节进一步总结:“一个有机体使本身稳定在较高的有序水平上(等于熵的相当低的水平上)的办法,就是从环境中不断地吸取秩序。”这个秩序(负熵、klog(1/n))可以是食物,也可以是知识,按主流叫法就是“正能量”(有些所谓正能量却碰巧是增加系统无序水平的正熵)。于是,我开始渐渐放弃那些让人沮丧的老梗,远离那些引发混乱的噪声,重新读书,试着翻译,学会去爱。这几年最大的收获就是明白了“隔行如隔山”的道理,试着循序渐进,教学相长,做力所能及之事,让编程变简单。

    一般人都不喜欢编程,更不喜欢动手编程(时间消耗:编写 & 测试 40%、重构 40%、风格 & 文档 20%),却喜欢在心里、嘴上编程:“先这样,再那样,如果要 XX,就 YY,最后就可以 ZZ 了。”分分钟就可以说完几万行代码的项目,水还剩大半杯。一旦大期将近,即使要亲自动手 Copy 代码,也会觉得苦堪搬砖,键盘不是红与黑、屏幕不能左右推、小狗总是闹跑追,不断在数不清的理由中增加自己的熵。偶尔看编程书的目的也很明确,就是为了快速上手,找到答案。当然也是在 Google、StackOverflow、GitHub 网站上找不到答案之后,无可奈何之举。编程书把看着复杂的知识写得更复杂,虽然大多篇幅不输“飞雪连天射白鹿,笑书神侠倚碧鸳”等经典,且纲举目张、图文并茂,甚至有作者爱引经据典,却极少有令人拍案的惊奇之处。为什么同样是文以载道,编程书却不能像武侠小说一样简单具体,反而显得了无生趣,令人望而却步?虽然编程的目的就是用计算机系统解决问题,但是大多数问题的知识都在其他领域中,许多作者在介绍编程技巧时,又试图介绍一些并不熟悉的背景知识,显得生涩难懂,且增加了书的厚度。

    有时我们真正需要的,就是能快刀斩乱麻的代码。(Talk is cheap, show me the code.)编程与研究数理化不同,没有任何假设、原命题、思维实验,并非科学;与舞剑、奏乐、炒菜相似,都是手艺,只要基础扎实,便结果立判。编程技巧也可以像剑谱、乐谱、食谱一般立竿见影,这本《Python 机器学习经典实例》正是如此,直接上代码,照着做就行,不用纠结为什么。

    机器学习是交叉学科,应用广泛,目前主流方法为统计机器学习。既然是以统计学为基础,那么就不只是计算机与数学专业的私房菜了,机器学习在自然科学、农业科学、医药科学、工程与技术科学、人文与社会科学等多种学科中均可应用。如果你遇到了回归、分类、预测、聚类、文本分析、语音识别、图像处理等经典问题,需要快速用 Python 解决,那么这本菜谱适合你。即使你对机器学习方法还一知半解,也不妨一试。毕竟是 Python 的机器学习,还能难到哪儿去呢?目前十分流行的 Python 机器学习库 scikit-learn 是全书主角之一,功能全面,接口友好,许多经典的数据集和机器学习案例都来自Kaggle。若有时间追根溯源,请研究周志华教授的《机器学习》西瓜书,周教授啃着西瓜把机器学习调侃得淋漓尽致,详细的参考文献尤为珍贵。但是想当作菜谱看,拿来就用,还是需要费一番功夫;若看书不过瘾,还有吴恩达(Andrew Ng)教授在Coursera上的机器学习公开课,机器学习入门最佳视频教程,吴教授用的工具是 Matlab 的免费开源版本 Octave,你也可以用 Python 版演示教学示例。

    学而时习之,不亦乐乎。学习编程技巧,解决实际问题,是一件快乐的事情。希望这本 Python 机器学习经典案例,可以成为你的负熵,帮你轻松化解那些陈年老梗。如果再努努力,也许陆汝钤院士在《机器学习》序言中提出的6个问题,你也有答案了。

    示例代码:

    """打印ASCII字母表、数字、标点符号"""import stringfor item in [string.ascii_letters,             string.digits,             string.punctuation]:    print('{}\t{}'.format(len(item), item))

    输出结果:

    52 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ10 012345678932 !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

    见文末Python示例代码。

    Kaggle 是一个2010年成立的数据建模和数据分析竞赛平台,全球数据科学家、统计学家、机器学习工程师的聚集地,上面有丰富的数据集,经典的机器学习基础教程,以及让人流口水的竞赛奖金,支持Python、R、Julia、SQLite,同时也支持 jupyter notebook 在线编程环境,2017年3月8日被谷歌收购。

    分免费版和付费版(购买结业证书),学习内容一样。

    陆院士的6个问题分别是:1. 机器学习早期的符号机器学习,如何在统计机器学习主流中发展;2. 统计机器学习算法中并不现实的“独立同分布”假设如何解决;3. 深度学习得益于硬件革命,是否会取代统计机器学习;4. 机器学习用的都是经典的概率统计、代数逻辑,而目前仅有倒向微分方程用于预测,微分几何的流形用于降维,只是数学领域的一角,其他现代数学理论是否可以参与其中;5. 机器学习方法仍不够严谨,例如目前流形学习直接将高维数据集假设成微分流形,需要进一步完善;6. 大数据与统计机器学习是如何互动的。

    流形学习,Manifold learning,科普见此

    前言

    在如今这个处处以数据驱动的世界中,机器学习正变得越来越大众化。它已经被广泛地应用于不同领域,如搜索引擎、机器人、无人驾驶汽车等。本书不仅可以帮你了解现实生活中机器学习的应用场景,而且通过有趣的菜谱式教程教你掌握处理具体问题的算法。

    本书首先通过实用的案例介绍机器学习的基础知识,然后介绍一些稍微复杂的机器学习算法,例如支持向量机、极端随机森林、隐马尔可夫模型、条件随机场、深度神经网络,等等。本书是为想用机器学习算法开发应用程序的 Python 程序员准备的。它不仅适合 Python 初学者(当然,熟悉 Python 编程方法将有助于体验示例代码),而且也适合想要掌握机器学习技术的 Python 老手。

    通过本书,你不仅可以学会如何做出合理的决策,为自己选择合适的算法类型,而且可以学会如何高效地实现算法以获得最佳学习效果。如果你在图像、文字、语音或其他形式的数据处理中遇到困难,书中处理这些数据的机器学习技术一定会对你有所帮助!

    本书内容

    第1章介绍各种回归分析的监督学习技术。我们将学习如何分析共享自行车的使用模式,以及如何预测房价。

    第2章介绍各种数据分类的监督学习技术。我们将学习如何评估收入层级,以及如何通过特征评估一辆二手汽车的质量。

    第3章论述支持向量机的预测建模技术。我们将学习如何使用这些技术预测建筑物里事件发生的概率,以及体育场周边道路的交通情况。

    第4章阐述无监督学习算法,包括 K-means 聚类和均值漂移聚类。我们将学习如何将这些算法应用于股票市场数据和客户细分。

    第5章介绍推荐引擎的相关算法。我们将学习如何应用这些算法实现协同滤波和电影推荐。

    第6章阐述与文本数据分析相关的技术,包括分词、词干提取、词库模型等。我们将学习如何使用这些技术进行文本情感分析和主题建模。

    第7章介绍与语音数据分析相关的算法。我们将学习如何建立语音识别系统。

    第8章介绍分析时间序列和有序数据的相关技术,包括隐马尔可夫模型和条件随机场。我们将学习如何将这些技术应用到文本序列分析和股市预测中。

    第9章介绍图像内容分析与物体识别方面的算法。我们将学习如何提取图像特征,以及建立物体识别系统。

    第10章介绍在图像和视频中检测与识别面部的相关技术。我们将学习使用降维算法建立面部识别器。

    第11章介绍建立深度神经网络所需的算法。我们将学习如何使用神经网络建立光学文字识别系统。

    第12章介绍机器学习使用的数据可视化技术。我们将学习如何创建不同类型的图形和图表。

    阅读背景

    Python 2.x 和 Python 3.x 的版本之争尚未平息。一方面,我们坚信世界会向更好的版本不断进化,另一方面,许多开发者仍然喜欢使用 Python 2.x 的版本。目前许多操作系统仍然内置 Python 2.x。本书的重点是介绍 Python 机器学习,而非 Python 语言本身。另外,考虑到程序的兼容性,书中用到了一些尚未被迁移到 Python 3.x 版本的程序库,因此,本书依然选择 Python 2.x 的版本。我们会尽最大努力保持代码兼容各种 Python 版本,因为这样可以让你轻松地理解代码,并且很方便地将代码应用到不同场景中。

    读者对象

    本书是为想用机器学习算法开发应用程序的 Python 程序员准备的。它适合 Python 初学者阅读,不过熟悉 Python 编程方法对体验示例代码大有裨益。

    内容组织

    在本书中,你会频繁地看到下面这些标题(准备工作、详细步骤、工作原理、更多内容、另请参阅)。

    为了更好地呈现内容,本书采用以下组织形式。

    准备工作

    这部分首先介绍本节目标,然后介绍软件配置方法以及所需的准备工作。

    详细步骤

    这部分介绍具体的实践步骤。

    工作原理

    这部分通常是对前一部分内容的详细解释。

    更多内容

    这部分会补充介绍一些信息,帮助你更好地理解前面的内容。

    另请参阅

    这部分提供一些参考资料。

    排版约定

    在本书中,你会发现一些不同的文本样式。这里举例说明它们的含义。

    嵌入代码、命令、选项、参数、函数、字段、属性、语句等,用等宽的代码字体显示:“这里,我们将25%的数据用于测试,可以通过test_size参数进行设置。”

    代码块用如下格式:

    import numpy as npimport matplotlib.pyplot as pltimport utilities# Load input datainput_file = 'data_multivar.txt'X, y = utilities.load_data(input_file)

    命令行输入或输出用如下格式:

    $ python object_recognizer.py --input-image imagefile.jpg --model-fileerf.pkl --codebook-file codebook.pkl

    新术语和重要文字将采用黑体字。你在屏幕上看到的内容,包括对话框或菜单里的文本,都将这样显示:“如果你将数组改为(0, 0.2, 0, 0, 0),那么 Strawberry 部分就会高亮显示。”

    读者反馈

    我们非常欢迎读者的反馈。如果你对本书有些想法,有什么喜欢或是不喜欢的,请反馈给我们,这将有助于我们出版充分满足读者需求的图书。

    一般性反馈请发送电子邮件至 feedback@packtpub.com,并在邮件主题中注明书名。

    如果你在某个领域有专长,并有意编写一本书或是贡献一份力量,请参考我们的作者指南

    客户支持

    你现在已经是引以为傲的 Packt 读者了。为了能让你的购买物超所值,我们还为你准备了以下内容。

    下载示例代码

    你可以用你的账户从此处下载所有已购买 Packt 图书的示例代码文件。如果你是从其他途径购买的本书,可以访问此处并注册,我们将通过电子邮件把文件发送给你。

    可以通过以下步骤下载示例代码文件:

    (1) 用你的电子邮件和密码登录或注册我们的网站;

    (2) 将鼠标移到网站上方的客户支持(SUPPORT)标签;

    (3) 单击代码下载与勘误(Code Downloads & Errata)按钮;

    (4) 在搜索框(Search)中输入书名;

    (5) 选择你要下载代码文件的书;

    (6) 从下拉菜单中选择你的购书途径;

    (7) 单击代码下载(Code Download)按钮。

    你也可以通过单击 Packt 网站上本书网页上的代码文件(Code Files)按钮来下载示例代码,该网页可以通过在搜索框(Search)中输入书名获得。以上操作的前提是你已经登录了 Packt 网站。

    下载文件后,请确保用以下软件的最新版来解压文件:

    • WinRAR / 7-Zip for Windows ;

    • Zipeg / iZip / UnRarX for Mac ;

    • 7-Zip / PeaZip for Linux 。

    本书的代码包也可以在 GitHub 上获得。另外,我们在这里还有其他书的代码包和视频,请需要的读者自行下载。

    下载本书的彩色图片

    我们也为你提供了一份 PDF 文件,里面包含了书中的截屏和图表等彩色图片,彩色图片能帮助你更好地理解输出的变化。下载地址

    勘误

    虽然我们已尽力确保本书内容正确,但出错仍旧在所难免。如果你在书中发现错误,不管是文本还是代码,希望能告知我们,我们将不胜感激。这样做,你可以使其他读者免受挫败,也可以帮助我们改进本书的后续版本。如果你发现任何错误,请访问这里,选择本书,单击勘误表提交表单(Errata Submission Form)的链接,并输入详细说明。勘误一经核实,你提交的内容将被接受,此勘误会上传到本公司网站或添加到现有勘误表。

    访问这里,在搜索框中输入书名,可以在勘误(Errata)部分查看已经提交的勘误信息。

    盗版

    任何媒体都会面临版权内容在互联网上的盗版问题,Packt 也不例外。Packt 非常重视版权保护。如果你发现我们的作品在互联网上被非法复制,不管以什么形式,都请立即为我们提供相关网址或网站名称,以便我们寻求补救。

    请把可疑盗版材料的链接发到 copyright@packtpub.com。

    保护我们的作者,就是保护我们继续为你带来价值的能力,我们将不胜感激。

    问题

    如果你对本书内容存有疑问,不管是哪个方面的,都可以通过 questions@packtpub.com 联系我们,我们会尽最大努力解决。

    2020年之前应该不会终结。——译者注

    中文版勘误可以到这里查看和提交。——编者注

    第01章:监督学习(上)

    在这一章,我们将介绍以下主题:

    • 数据预处理技术

    • 标记编码方法

    • 创建线性回归器(linear regressor)

    • 计算回归准确性

    • 保存模型数据

    • 创建岭回归器(ridge regressor)

    • 创建多项式回归器(polynomial regressor)

    • 估算房屋价格

    • 计算特征的相对重要性

    • 评估共享单车的需求分布

    1.1 简介

    如果你熟悉机器学习的基础知识,那么肯定知道什么是监督学习。监督学习是指在有标记的样本(labeled samples)上建立机器学习的模型。例如,如果用尺寸、位置等不同参数建立一套模型来评估一栋房子的价格,那么首先需要创建一个数据库,然后为参数打上标记。我们需要告诉算法,什么样的参数(尺寸、位置)对应什么样的价格。有了这些带标记的数据,算法就可以学会如何根据输入的参数计算房价了。

    无监督学习与刚才说的恰好相反,它面对的是没有标记的数据。假设需要把一些数据分成不同的组别,但是对分组的条件毫不知情,于是,无监督学习算法就会以最合理的方式将数据集分成确定数量的组别。我们将在后面章节介绍无监督学习。

    建立书中的各种模型时,将使用许多 Python 程序包,像 NumPy、SciPy、scikit-learn、matplotlib 等。如果你使用 Windows 系统,推荐安装兼容 SciPy 关联程序包的 Python 发行版,这些 Python 发行版里已经集成了常用的程序包。如果你使用 Mac OS X 或者 Ubuntu 系统,安装这些程序包就相当简单了。下面列出来程序包安装和使用文档的链接:

    现在,请确保你的计算机已经安装了所有程序包。

    1.2 数据预处理技术

    在真实世界中,经常需要处理大量的原始数据,这些原始数据是机器学习算法无法理解的。为了让机器学习算法理解原始数据,需要对数据进行预处理。

    1.2.1 准备工作

    来看看 Python 是如何对数据进行预处理的。首先,用你最喜欢的文本编辑器打开一个扩展名为.py 的文件,例如 preprocessor.py。然后在文件里加入下面两行代码:

    import numpy as npfrom sklearn import preprocessing

    我们只是加入了两个必要的程序包。接下来创建一些样本数据。向文件中添加下面这行代码:

    data = np.array([[3,  -1.5,    2,  -5.4], [0,    4,    -0.3,  2.1], [1,    3.3,-1.9, -4.3]])

    现在就可以对数据进行预处理了。

    1.2.2 详细步骤

    数据可以通过许多技术进行预处理,接下来将介绍一些最常用的预处理技术。

    1.均值移除(Mean removal)

    通常我们会把每个特征的平均值移除,以保证特征均值为0(即标准化处理)。这样做可以消除特征彼此间的偏差(bias)。将下面几行代码加入之前打开的Python文件中:

        data_standardized = preprocessing.scale(data)    print "\nMean =", data_standardized.mean(axis=0)    print "Std deviation =", data_standardized.std(axis=0)

    现在来运行代码。打开命令行工具,然后输入以下命令:

        $ python preprocessor.py命令行工具中将显示以下结果:    Mean = [  5.55111512e-17  -1.11022302e-16  -7.40148683e-17  -7.40148683e-17]    Std deviation = [ 1.  1.  1.  1.]你会发现特征均值几乎是`0`,而且标准差为`1`。

    2.范围缩放(Scaling)

    数据点中每个特征的数值范围可能变化很大,因此,有时将特征的数值范围缩放到合理的大小是非常重要的。在 Python 文件中加入下面几行代码,然后运行程序:

        data_scaler = preprocessing.MinMaxScaler(feature_range=(0, 1))    data_scaled = data_scaler.fit_transform(data)    print "\nMin max scaled data =", data_scaled

    范围缩放之后,所有数据点的特征数值都位于指定的数值范围内。输出结果如下所示:

        Min max scaled data:    [[ 1.            0.            1.            0.        ]     [ 0.            1.            0.41025641    1.        ]     [ 0.33333333    0.87272727    0.            0.14666667]]

    3.归一化(Normalization)

    数据归一化用于需要对特征向量的值进行调整时,以保证每个特征向量的值都缩放到相同的数值范围。机器学习中最常用的归一化形式就是将特征向量调整为 L1范数,使特征向量的数值之和为1。增加下面两行代码到前面的 Python 文件中:

        data_normalized = preprocessing.normalize(data, norm='l1')    print "\nL1 normalized data =", data_normalized

    执行 Python 文件,就可以看到下面的结果:

        L1    normalized    data:    [[    0.25210084    -0.12605042    0.16806723    -0.45378151]     [    0.             0.625        -0.046875       0.328125  ]     [    0.0952381      0.31428571   -0.18095238    -0.40952381]]

    这个方法经常用于确保数据点没有因为特征的基本性质而产生较大差异,即确保数据处于同一数量级,提高不同特征数据的可比性。

    4.二值化(Binarization)

    二值化用于将数值特征向量转换为布尔类型向量。增加下面两行代码到前面的 Python 文件中:

        data_binarized = preprocessing.Binarizer(threshold=1.4).transform(data)    print "\nBinarized data =", data_binarized

    再次执行 Python 文件,就可以看到下面的结果:

        Binarized data:    [[    1.    0.    1.    0.]     [    0.    1.    0.    1.]     [    0.    1.    0.    0.]]

    如果事先已经对数据有了一定的了解,就会发现使用这个技术的好处了。

    5.独热编码

    通常,需要处理的数值都是稀疏地、散乱地分布在空间中,然而,我们并不需要存储这些大数值,这时就需要使用独热编码(One-Hot Encoding)。可以把独热编码看作是一种收紧(tighten)特征向量的工具。它把特征向量的每个特征与特征的非重复总数相对应,通过 one-of-k 的形式对每个值进行编码。特征向量的每个特征值都按照这种方式编码,这样可以更加有效地表示空间。例如,我们需要处理4维向量空间,当给一个特性向量的第 n 个特征进行编码时,编码器会遍历每个特征向量的第 n 个特征,然后进行非重复计数。如果非重复计数的值是 K ,那么就把这个特征转换为只有一个值是1其他值都是0的 K 维向量。增加下面几行代码到前面的 Python 文件中:

        encoder = preprocessing.OneHotEncoder()    encoder.fit([[0, 2, 1, 12], [1, 3, 5, 3], [2, 3, 2, 12], [1, 2, 4, 3]])    encoded_vector = encoder.transform([[2, 3, 5, 3]]).toarray()    print "\nEncoded vector =", encoded_vector

    结果如下所示:

        Encoded vector:    [[ 0.  0.  1.  0.  1.  0.  0.  0.  1.  1.  0.]]

    在上面的示例中,观察一下每个特征向量的第三个特征,分别是1524这4个不重复的值,也就是说独热编码向量的长度是4。如果你需要对5进行编码,那么向量就是[0, 1, 0, 0]。向量中只有一个值是1。第二个元素是1,对应的值是5

    1.3 标记编码方法

    在监督学习中,经常需要处理各种各样的标记。这些标记可能是数字,也可能是单词。如果标记是数字,那么算法可以直接使用它们,但是,许多情况下,标记都需要以人们可理解的形式存在,因此,人们通常会用单词标记训练数据集。标记编码就是要把单词标记转换成数值形式,让算法懂得如何操作标记。接下来看看如何标记编码。

    详细步骤

    (1) 新建一个 Python 文件,然后导入 preprocessing 程序包:

    from sklearn import preprocessing

    (2) 这个程序包包含许多数据预处理需要的函数。定义一个标记编码器(label encoder),代码如下所示:

    label_encoder = preprocessing.LabelEncoder()

    (3) label_encoder对象知道如何理解单词标记。接下来创建一些标记:

    input_classes = ['audi', 'ford', 'audi', 'toyota', 'ford', 'bmw']

    (4) 现在就可以为这些标记编码了:

    label_encoder.fit(input_classes)print "\nClass mapping:"for i, item in enumerate(label_encoder.classes_):    print item, '-->', i

    (5) 运行代码,命令行工具中显示下面的结果:

    Class mapping:audi --> 0bmw --> 1ford --> 2toyota --> 3

    (6) 就像前面结果显示的那样,单词被转换成从0开始的索引值。现在,如果你遇到一组标记,就可以非常轻松地转换它们了,如下所示:

    labels = ['toyota', 'ford', 'audi']encoded_labels = label_encoder.transform(labels)print "\nLabels =", labelsprint "Encoded labels =", list(encoded_labels)

    命令行工具中将显示下面的结果:

    Labels = ['toyota', 'ford', 'audi']Encoded labels = [3, 2, 0]

    (7) 这种方式比纯手工进行单词与数字的编码要简单许多。还可以通过数字反转回单词的功能检查结果的正确性:

    encoded_labels = [2, 1, 0, 3, 1]decoded_labels = label_encoder.inverse_transform(encoded_labels)print "\nEncoded labels =", encoded_labelsprint "Decoded labels =", list(decoded_labels)

    结果如下所示:

    Encoded labels = [2, 1, 0, 3, 1]Decoded labels = ['ford', 'bmw', 'audi', 'toyota', 'bmw']

    可以看到,映射结果是完全正确的。

    第01章:监督学习(中)

    1.4 创建线性回归器

    回归是估计输入数据与连续值输出数据之间关系的过程。数据通常是实数形式的,我们的目标是估计满足输入到输出映射关系的基本函数。让我们从一个简单的示例开始。考虑下面的输入与输出映射关系:

    1 → 2

    3 → 6

    4.3 → 8.6

    7.1 → 14.2

    如果要你估计输入与输出的关联关系,你可以通过模式匹配轻松地找到结果。我们发现输出结果一直是输入数据的两倍,因此输入与输出的转换公式就是这样:

    f(x) = 2x

    这是体现输入值与输出值关联关系的一个简单函数。但是,在真实世界中通常都不会这么简单,输入与输出的映射关系函数并不是一眼就可以看出来的。

    1.4.1 准备工作

    线性回归用输入变量的线性组合来估计基本函数。前面的示例就是一种单输入单输出变量的线性回归。

    现在考虑如图1-1所示的情况。

    {%}

    图 1-1

    线性回归的目标是提取输入变量与输出变量的关联线性模型,这就要求实际输出与线性方程预测的输出的残差平方和(sum of squares of differences)最小化。这种方法被称为普通最小二乘法(Ordinary Least Squares,OLS)。

    你可能觉得用一条曲线对这些点进行拟合效果会更好,但是线性回归不允许这样做。线性回归的主要优点就是方程简单。如果你想用非线性回归,可能会得到更准确的模型,但是拟合速度会慢很多。线性回归模型就像前面那张图里显示的,用一条直线近似数据点的趋势。接下来看看如何用 Python 建立线性回归模型。

    1.4.2 详细步骤

    假设你已经创建了数据文件 data_singlevar.txt,文件里用逗号分隔符分割字段,第一个字段是输入值,第二个字段是与逗号前面的输入值相对应的输出值。你可以用这个文件作为输入参数。

    (1) 创建一个 Python 文件 regressor.py,然后在里面增加下面几行代码:

    import sysimport numpy as npfilename = sys.argv[1]X = []y = []with open(filename, 'r') as f:    for line in f.readlines():        xt, yt = [float(i) for i in line.split(',')]        X.append(xt)        y.append(yt)

    把输入数据加载到变量Xy,其中X是数据,y是标记。在代码的for循环体中,我们解析每行数据,用逗号分割字段。然后,把字段转化为浮点数,并分别保存到变量Xy中。

    (2) 建立机器学习模型时,需要用一种方法来验证模型,检查模型是否达到一定的满意度(satisfactory level)。为了实现这个方法,把数据分成两组:训练数据集(training dataset)与测试数据集(testing dataset)。训练数据集用来建立模型,测试数据集用来验证模型对未知数据的学习效果。因此,先把数据分成训练数据集与测试数据集:

    num_training = int(0.8 * len(X))num_test = len(X) - num_training# 训练数据X_train = np.array(X[:num_training]).reshape((num_training,1))y_train = np.array(y[:num_training])# 测试数据X_test = np.array(X[num_training:]).reshape((num_test,1))y_test = np.array(y[num_training:])

    这里用80%的数据作为训练数据集,其余20%的数据作为测试数据集。

    (3) 现在已经准备好训练模型。接下来创建一个回归器对象,代码如下所示:

    from sklearn import linear_model# 创建线性回归对象linear_regressor = linear_model.LinearRegression()# 用训练数据集训练模型linear_regressor.fit(X_train, y_train)

    (4) 我们利用训练数据集训练了线性回归器。向fit方法提供输入数据即可训练模型。用下面的代码看看它如何拟合:

    import matplotlib.pyplot as plty_train_pred = linear_regressor.predict(X_train)plt.figure()plt.scatter(X_train, y_train, color='green')plt.plot(X_train, y_train_pred, color='black', linewidth=4)plt.title('Training data')plt.show()

    (5) 在命令行工具中执行如下命令:

    $ python regressor.py data_singlevar.txt

    就会看到如图1-2所示的线性回归。

    {90%}

    图 1-2

    (6) 在前面的代码中,我们用训练的模型预测了训练数据的输出结果,但这并不能说明模型对未知的数据也适用,因为我们只是在训练数据上运行模型。这只能体现模型对训练数据的拟合效果。从图1-2中可以看到,模型训练的效果很好。

    (7) 接下来用模型对测试数据集进行预测,然后画出来看看,代码如下所示:

    y_test_pred = linear_regressor.predict(X_test)plt.scatter(X_test, y_test, color='green')plt.plot(X_test, y_test_pred, color='black', linewidth=4)plt.title('Test data')plt.show()

    运行代码,可以看到如图1-3所示的线性回归。

    {90%}

    图 1-3

    1.5 计算回归准确性

    现在已经建立了回归器,接下来最重要的就是如何评价回归器的拟合效果。在模型评价的相关内容中,用误差(error)表示实际值与模型预测值之间的差值。

    1.5.1 准备工作

    下面快速了解几个衡量回归器拟合效果的重要指标(metric)。回归器可以用许多不同的指标进行衡量,部分指标如下所示。

    • 平均绝对误差(mean absolute error):这是给定数据集的所有数据点的绝对误差平均值。

    • 均方误差(mean squared error):这是给定数据集的所有数据点的误差的平方的平均值。这是最流行的指标之一。

    • 中位数绝对误差(median absolute error):这是给定数据集的所有数据点的误差的中位数。这个指标的主要优点是可以消除异常值(outlier)的干扰。测试数据集中的单个坏点不会影响整个误差指标,均值误差指标会受到异常点的影响。

    • 解释方差分(explained variance score):这个分数用于衡量我们的模型对数据集波动的解释能力。如果得分1.0分,那么表明我们的模型是完美的。

    • R方得分(R2 score):这个指标读作“R方”,是指确定性相关系数,用于衡量模型对未知样本预测的效果。最好的得分是1.0,值也可以是负数。

    1.5.2 详细步骤

    scikit-learn 里面有一个模块,提供了计算所有指标的功能。重新打开一个 Python 文件,然后输入以下代码:

    import sklearn.metrics as smprint "Mean absolute error =", round(sm.mean_absolute_error(y_test, y_test_pred), 2)print "Mean squared error =", round(sm.mean_squared_error(y_test, y_ test_pred), 2)print "Median absolute error =", round(sm.median_absolute_error(y_ test, y_test_pred), 2)print "Explained variance score =", round(sm.explained_variance_ score(y_test, y_test_pred), 2)print "R2 score =", round(sm.r2_score(y_test, y_test_pred), 2)

    每个指标都描述得面面俱到是非常乏味的,因此只选择一两个指标来评估我们的模型。通常的做法是尽量保证均方误差最低,而且解释方差分最高。

    1.6 保存模型数据

    模型训练结束之后,如果能够把模型保存成文件,那么下次再使用的时候,只要简单地加载就可以了。

    详细步骤

    用程序保存模型的具体操作步骤如下。

    (1) 在 Python 文件 regressor.py 中加入以下代码:

    import cPickle as pickleoutput_model_file = 'saved_model.pkl'with open(output_model_file, 'w') as f:    pickle.dump(linear_regressor, f)

    (2) 回归模型会保存在 saved_model.pkl 文件中。下面看看如何加载并使用它,代码如下所示:

    with open(output_model_file, 'r') as f:    model_linregr = pickle.load(f)y_test_pred_new = model_linregr.predict(X_test)print "\nNew mean absolute error =", round(sm.mean_absolute_ error(y_test, y_test_pred_new), 2)

    (3) 这里只是把回归模型从 Pickle 文件加载到model_linregr变量中。你可以将打印结果与前面的结果进行对比,确认模型与之前的一样。

    1.7 创建岭回归器

    线性回归的主要问题是对异常值敏感。在真实世界的数据收集过程中,经常会遇到错误的度量结果。而线性回归使用的普通最小二乘法,其目标是使平方误差最小化。这时,由于异常值误差的绝对值很大,因此会引起问题,从而破坏整个模型。

    1.7.1 准备工作

    先看图1-4。

    {%}

    图 1-4

    右下角的两个数据点明显是异常值,但是这个模型需要拟合所有的数据点,因此导致整个模型都错了。仅凭直觉观察,我们就会觉得如图1-5的拟合结果更好。

    {%}

    图 1-5

    普通最小二乘法在建模时会考虑每个数据点的影响,因此,最终模型就会像图1-4显示的直线那样。显然,我们发现这个模型不是最优的。为了避免这个问题,我们引入正则化项的系数作为阈值来消除异常值的影响。这个方法被称为岭回归

    1.7.2 详细步骤

    接下来看看如何用 Python 建立岭回归器。

    (1) 你可以从 data_multi_variable.txt 文件中加载数据。这个文件的每一行都包含多个数值。除了最后一个数值外,前面的所有数值构成输入特征向量。

    (2) 把下面的代码加入 regressor.py 文件中。我们用一些参数初始化岭回归器:

    ridge_regressor = linear_model.Ridge(alpha=0.01, fit_ intercept=True, max_iter=10000)

    (3) alpha参数控制回归器的复杂程度。当alpha趋于0时,岭回归器就是用普通最小二乘法的线性回归器。因此,如果你希望模型对异常值不那么敏感,就需要设置一个较大的alpha值。这里把alpha值设置为0.01

    (4) 下面让我们来训练岭回归器。

    ridge_regressor.fit(X_train, y_train)y_test_pred_ridge = ridge_regressor.predict(X_test)print "Mean absolute error =", round(sm.mean_absolute_error    (y_ test, y_test_pred_ridge), 2)print "Mean squared error =", round(sm.mean_squared_error    (y_test, y_test_pred_ridge), 2)print "Median absolute error =", round(sm.median_absolute_error    (y_ test, y_test_pred_ridge), 2)print "Explain variance score =", round(sm.explained_variance_ score    (y_test, y_test_pred_ridge), 2)print "R2 score =", round(sm.r2_score(y_test, y_test_pred_ridge), 2)

    运行代码检查误差指标。可以用同样的数据建立一个线性回归器,并与岭回归器的结果进行比较,看看把正则化引入回归模型之后的效果如何。

    第01章:监督学习(下)

    1.8 创建多项式回归器

    线性回归模型有一个主要的局限性,那就是它只能把输入数据拟合成直线,而多项式回归模型通过拟合多项式方程来克服这类问题,从而提高模型的准确性。

    1.8.1 准备工作

    先看图1-6。

    {%}

    图 1-6

    从图1-6中可以看到,数据点本身的模式中带有自然的曲线,而线性模型是不能捕捉到这一点的。再来看看多项式模型的效果,如图1-7所示。

    {%}

    图 1-7

    图1-7中的虚线表示线性回归模型,实线表示多项式回归模型。这个模型的曲率是由多项式的次数决定的。随着模型曲率的增加,模型变得更准确。但是,增加曲率的同时也增加了模型的复杂性,因此拟合速度会变慢。当我们对模型的准确性的理想追求与计算能力限制的残酷现实发生冲突时,就需要综合考虑了。

    1.8.2 详细步骤

    (1) 将下面的代码加入 Python 文件 regressor.py 中:

    from sklearn.preprocessing import PolynomialFeaturespolynomial = PolynomialFeatures(degree=3)

    (2) 上一行将曲线的多项式的次数的初始值设置为3。下面用数据点来计算多项式的参数:

    X_train_transformed = polynomial.fit_transform(X_train)

    其中,X_train_transformed表示多项式形式的输入,与线性回归模型是一样大的。

    (3) 接下来用文件中的第一个数据点来检查多项式模型是否能够准确预测:

    datapoint = [0.39,2.78,7.11]poly_datapoint = polynomial.fit_transform(datapoint)poly_linear_model = linear_model.LinearRegression()poly_linear_model.fit(X_train_transformed, y_train)print "\nLinear regression:", linear_regressor.predict(datapoint) [0]print "\nPolynomial regression:", poly_linear_model.predict(poly_datapoint)[0]

    多项式回归模型计算变量数据点的值恰好就是输入数据文件中的第一行数据值。再用线性回归模型测试一下,唯一的差别就是展示数据的形式。运行代码,可以看到下面的结果:

    Linear regression: -11.0587294983Polynomial regression: -10.9480782122

    可以发现,多项式回归模型的预测值更接近实际的输出值。如果想要数据更接近实际输出值,就需要增加多项式的次数。

    (4) 将多项式的次数加到10看看结果:

    polynomial = PolynomialFeatures(degree=10)

    可以看到下面的结果:

    Polynomial regression: -8.20472183853

    现在,你可以发现预测值与实际的输出值非常地接近。

    1.9 估算房屋价格

    是时候用所学的知识来解决真实世界的问题了。让我们用这些原理来估算房屋价格。房屋估价是理解回归分析最经典的案例之一,通常是一个不错的切入点。它符合人们的直觉,而且与人们的生活息息相关,因此在用机器学习处理复杂事情之前,通过房屋估价可以更轻松地理解相关概念。我们将使用带 AdaBoost 算法的决策树回归器(decision tree regressor)来解决这个问题。

    1.9.1 准备工作

    决策树是一个树状模型,每个节点都做出一个决策,从而影响最终结果。叶子节点表示输出数值,分支表示根据输入特征做出的中间决策。AdaBoost 算法是指自适应增强(adaptive boosting)算法,这是一种利用其他系统增强模型准确性的技术。这种技术是将不同版本的算法结果进行组合,用加权汇总的方式获得最终结果,被称为弱学习器(weak learners)。AdaBoost 算法在每个阶段获取的信息都会反馈到模型中,这样学习器就可以在后一阶段重点训练难以分类的样本。这种学习方式可以增强系统的准确性。

    首先使用 AdaBoost 算法对数据集进行回归拟合,再计算误差,然后根据误差评估结果,用同样的数据集重新拟合。可以把这些看作是回归器的调优过程,直到达到预期的准确性。假设你拥有一个包含影响房价的各种参数的数据集,我们的目标就是估计这些参数与房价的关系,这样就可以根据未知参数估计房价了。

    1.9.2 详细步骤

    (1) 创建一个新的 Python 文件 housing.py,然后加入下面的代码:

    import numpy as npfrom sklearn.tree import DecisionTreeRegressorfrom sklearn.ensemble import AdaBoostRegressorfrom sklearn import datasetsfrom sklearn.metrics import mean_squared_error, explained_variance_scorefrom sklearn.utils import shuffleimport matplotlib.pyplot as plt

    (2) 网上有一个标准房屋价格数据库,人们经常用它来研究机器学习。你可以在这里下载数据。不过 scikit-learn 提供了数据接口,可以直接通过下面的代码加载数据:

    housing_data = datasets.load_boston()

    每个数据点由影响房价的13个输入参数构成。你可以用housing_data.data获取输入的数据,用housing_data.target获取对应的房屋价格。

    (3) 接下来把输入数据与输出结果分成不同的变量。我们可以通过shuffle函数把数据的顺序打乱:

    X, y = shuffle(housing_data.data, housing_data.target, random_ state=7)

    (4) 参数random_state用来控制如何打乱数据,让我们可以重新生成结果。接下来把数据分成训练数据集和测试数据集,其中80%的数据用于训练,剩余20%的数据用于测试:

    num_training = int(0.8 * len(X))X_train, y_train = X[:num_training], y[:num_training]X_test, y_test = X[num_training:], y[num_training:]

    (5) 现在已经可以拟合一个决策树回归模型了。选一个最大深度为4的决策树,这样可以限制决策树不变成任意深度:

    dt_regressor = DecisionTreeRegressor(max_depth=4)dt_regressor.fit(X_train, y_train)

    (6) 再用带 AdaBoost 算法的决策树回归模型进行拟合:

    ab_regressor =AdaBoostRegressor(DecisionTreeRegressor(max_depth=4), n_estimators=400, random_state=7)ab_regressor.fit(X_train, y_train)

    这样可以帮助我们对比训练效果,看看 AdaBoost 算法对决策树回归器的训练效果有多大改善。

    (7) 接下来评价决策树回归器的训练效果:

    y_pred_dt = dt_regressor.predict(X_test)mse = mean_squared_error(y_test, y_pred_dt)evs = explained_variance_score(y_test, y_pred_dt)print "\n#### Decision Tree performance ####"print "Mean squared error =", round(mse, 2)print "Explained variance score =", round(evs, 2)

    (8) 现在评价一下 AdaBoost 算法改善的效果:

    y_pred_ab = ab_regressor.predict(X_test)mse = mean_squared_error(y_test, y_pred_ab)evs = explained_variance_score(y_test, y_pred_ab)print "\n#### AdaBoost performance ####"print "Mean squared error =", round(mse, 2)print "Explained variance score =", round(evs, 2)

    (9) 命令行工具显示的输出结果如下所示:

    #### 决策树学习效果 ####Mean squared error = 14.79Explained variance score = 0.82#### AdaBoost算法改善效果 ####Mean squared error = 7.54Explained variance score = 0.91

    前面的结果表明,AdaBoost 算法可以让误差更小,且解释方差分更接近1。

    1.10 计算特征的相对重要性

    所有特征都同等重要吗?在这个案例中,我们用了13个特征,它们对模型都有贡献。但是,有一个重要的问题出现了:如何判断哪个特征更加重要?显然,所有的特征对结果的贡献是不一样的。如果需要忽略一些特征,就需要知道哪些特征不太重要。scikit-learn 里面有这样的功能。

    详细步骤

    (1) 画出特征的相对重要性,在 housing.py 文件中加入下面几行代码:

    plot_feature_importances(dt_regressor.feature_importances_,        'Decision Tree regressor', housing_data.feature_names)plot_feature_importances(ab_regressor.feature_importances_,        'AdaBoost regressor', housing_data.feature_names)

    回归器对象有一个feature_importances_方法会告诉我们每个特征的相对重要性。

    (2) 接下来需要定义plot_feature_importances来画出条形图:

    def plot_feature_importances(feature_importances, title, feature_names):    # 将重要性值标准化    feature_importances = 100.0 * (feature_importances / max(feature_importances))    # 将得分从高到低排序    index_sorted = np.flipud(np.argsort(feature_importances))    # 让X坐标轴上的标签居中显示    pos = np.arange(index_sorted.shape[0]) + 0.5    # 画条形图    plt.figure()    plt.bar(pos, feature_importances[index_sorted], align='center')    plt.xticks(pos, feature_names[index_sorted])    plt.ylabel('Relative Importance')    plt.title(title)    plt.show()

    (3) 我们从feature_importances_方法里取值,然后把数值放大到0~100的范围内。运行前面的代码,可以看到两张图(不带 AdaBoost 算法与带 AdaBoost 算法两种模型)。仔细观察图1-8和图1-9,看看能从决策树回归器中获得什么。

    {%}

    图 1-8

    (4) 从图1-8可以发现,不带 AdaBoost 算法的决策树回归器显示的最重要特征是 RM。再看看带 AdaBoost 算法的决策树回归器的特征重要性排序条形图,如图1-9所示。

    {%}

    图 1-9

    加入 AdaBoost 算法之后,房屋估价模型的最重要特征是 LSTAT。在现实生活中,如果对这个数据集建立不同的回归器,就会发现最重要的特征是 LSTAT,这足以体现 AdaBoost 算法对决策树回归器训练效果的改善。

    1.11 评估共享单车的需求分布

    本节将用一种新的回归方法解决共享单车的需求分布问题。我们采用随机森林回归器(random forest regressor)估计输出结果。随机森林是一个决策树集合,它基本上就是用一组由数据集的若干子集构建的决策树构成,再用决策树平均值改善整体学习效果。

    1.11.1 准备工作

    我们将使用 bike_day.csv 文件中的数据集获取。这份数据集一共16列,前两列是序列号与日期,分析的时候可以不用;最后三列数据是不同类型的输出结果;最后一列是第十四列与第十五列的和,因此建立模型时可以不考虑第十四列与第十五列。

    1.11.2 详细步骤

    接下来看看 Python 如何解决这个问题。如果你下载了本书源代码,就可以看到 bike_sharing.py 文件里已经包含了完整代码。这里将介绍若干重要的部分。

    (1) 首先导入一些新的程序包,如下:

    import csvfrom sklearn.ensemble import RandomForestRegressorfrom housing import plot_feature_importances

    (2) 我们需要处理 CSV 文件,因此加入了 csv 程序包来读取 CSV 文件。由于这是一个全新的数据集,因此需要自己定义一个数据集加载函数:

    def load_dataset(filename):    file_reader = csv.reader(open(filename, 'rb'), delimiter=',')    X, y = [], []    for row in file_reader:        X.append(row[2:13])        y.append(row[-1])    # 提取特征名称    feature_names = np.array(X[0])    # 将第一行特征名称移除,仅保留数值    return np.array(X[1:]).astype(np.float32), np.array(y[1:]).astype(np.float32), feature_names

    在这个函数中,我们从 CSV 文件读取了所有数据。把数据显示在图形中时,特征名称非常有用。把特征名称数据从输入数值中分离出来,并作为函数返回值。

    (3) 读取数据,并打乱数据顺序,让新数据与原来文件中数据排列的顺序没有关联性:

    X, y, feature_names = load_dataset(sys.argv[1])X, y = shuffle(X, y, random_state=7)

    (4) 和之前的做法一样,需要将数据分成训练数据和测试数据。这一次,我们将90%的数据用于训练,剩余10%的数据用于测试:

    num_training = int(0.9 * len(X))X_train, y_train = X[:num_training], y[:num_training]X_test, y_test = X[num_training:], y[num_training:]

    (5) 下面开始训练回归器:

    rf_regressor = RandomForestRegressor(n_estimators=1000, max_depth=10, min_samples_split=1)rf_regressor.fit(X_train, y_train)

    其中,参数n_estimators是指评估器(estimator)的数量,表示随机森林需要使用的决策树数量;参数max_depth是指每个决策树的最大深度;参数min_samples_split是指决策树分裂一个节点需要用到的最小数据样本量。

    (6) 评价随机森林回归器的训练效果:

    y_pred = rf_regressor.predict(X_test)mse = mean_squared_error(y_test, y_pred)evs = explained_variance_score(y_test, y_pred)print "\n#### Random Forest regressor performance ####"print "Mean squared error =", round(mse, 2)print "Explained variance score =", round(evs, 2)

    (7) 由于已经有画出特征重要性条形图的函数plot_feature_importances了,接下来直接调用它:

    plot_feature_importances(rf_regressor.feature_importances_, 'Random Forest regressor', feature_names)

    执行代码,可以看到如图1-10所示的图形。

    {%}

    图 1-10

    看来温度(temp)是影响自行车租赁的最重要因素。

    1.11.3 更多内容

    把第十四列与第十五列数据加入数据集,看看结果有什么区别。在新的特征重要性条形图中,除了这两个特征外,其他特征都变成了0。这是由于输出结果可以通过简单地对第十四列与第十五列数据求和得出,因此算法不需要其他特征计算结果。在数据集加载函数load_dataset中,我们需要对for循环内的取值范围稍作调整:

    X.append(row[2:15])

    现在再画出特征重要性条形图,可以看到如图1-11所示的柱形图。

    {%}

    图 1-11

    与预想的一样,从图中可以看出,只有这两个特征是重要的,这确实也符合常理,因为最终结果仅仅是这两个特征相加得到的。因此,这两个变量与输出结果有直接的关系,回归器也就认为它不需要其他特征来预测结果了。在消除数据集冗余变量方面,这是非常有用的工具。

    还有一份按小时统计的自行车共享数据 bike_hour.csv。我们需要用到第3~14列,因此先对数据集加载函数load_dataset做一点调整:

    X.append(row[2:14])

    运行代码,可以看到回归器的训练结果如下:

    #### 随机森林学习效果 ####Mean squared error = 2619.87Explained variance score = 0.92

    特征重要性条形图如图1-12所示。

    {%}

    图 1-12

    图1-12中显示,最重要的特征是一天中的不同时点(hr),这也完全符合人们的直觉;其次重要的是温度,与我们之前分析的结果一致。

    第02章:创建分类器(上)

    在这一章,我们将介绍以下主题:

    • 建立简单分类器(simple classifier)

    • 建立逻辑回归分类器(logistic regression classifier)

    • 建立朴素贝叶斯分类器(Naïve Bayes classifier)

    • 将数据集分割成训练集和测试集

    • 用交叉验证(cross-validation)检验模型准确性

    • 混淆矩阵(confusion matrix)可视化

    • 提取性能报告

    • 根据汽车特征评估质量

    • 生成验证曲线(validation curves)

    • 生成学习曲线(learning curves)

    • 估算收入阶层(income bracket)

    2.1 简介

    在机器学习领域中,分类是指利用数据的特性将其分成若干类型的过程。分类与上一章介绍的回归不同,回归的输出结果是实数。监督学习分类器就是用带标记的训练数据建立一个模型,然后对未知数据进行分类。

    分类器可以是实现分类功能的任意算法,最简单的分类器就是简单的数学函数。在真实世界中,分类器可以是非常复杂的形式。在学习过程中,可以看到二元(binary)分类器,将数据分成两类,也可以看到多元(multiclass)分类器,将数据分成两个以上的类型。解决分类问题的数据手段都倾向于解决二元分类问题,可以通过不同的形式对其进行扩展,进而解决多元分类问题。

    分类器准确性的估计是机器学习领域的重要内容。我们需要学会如何使用现有的数据获取新的思路(机器学习模型),然后把模型应用到真实世界中。在这一章里,我们将看到许多类似的主题。

    2.2 建立简单分类器

    本节学习如何用训练数据建立一个简单分类器。

    2.2.1 详细步骤

    (1)使用 simple_classifier.py 文件作为参考。假设你已经和上一章一样导入了numpymatplotlib.pyplot程序包,那么需要创建一些样本数据:

    X = np.array([[3,1], [2,5], [1,8], [6,4], [5,2], [3,5], [4,7], [4,-1]])

    (2) 为这些数据点分配一些标记:

    y = [0, 1, 1, 0, 0, 1, 1, 0]

    (3) 因为只有两个类,所以y列表包含0和1。一般情况下,如果你有 N个类,那么y的取值范围就是从0到 N-1。接下来按照类型标记把样本数据分成两类:

    class_0 = np.array([X[i] for i in range(len(X)) if y[i]==0])class_1 = np.array([X[i] for i in range(len(X)) if y[i]==1])

    (4) 为了对数据有个直观的认识,把图像画出来,如下所示:

    plt.figure()plt.scatter(class_0[:,0], class_0[:,1], color='black', marker='s')plt.scatter(class_1[:,0], class_1[:,1], color='black', marker='x')

    这是一个散点图(scatterplot),用方块和叉表示两类数据。在前面的代码中,参数marker用来表示数据点的形状。用方块表示class_0的数据,用叉表示class_1的数据。运行代码,可以看到如图2-1所示的图形。

    (5) 在之前的两行代码中,只是用变量Xy之间的映射关系创建了两个列表。如果要你直观地展示数据点的不同类型,在两类数据间画一条分割线,那么怎么实现呢?你只要用直线方程在两类数据之间画一条直线就可以了。下面看看如何实现:

    line_x = range(10)line_y = line_x

    (6) 用数学公式 y = x 创建一条直线。代码如下所示:

    plt.figure()plt.scatter(class_0[:,0], class_0[:,1], color='black', marker='s')plt.scatter(class_1[:,0], class_1[:,1], color='black', marker='x')plt.plot(line_x, line_y, color='black', linewidth=3)plt.show()

    {90%}

    图 2-1

    (7) 运行代码,可以看到如图2-2所示的图形。

    {90%}

    图 2-2

    2.2.2 更多内容

    用以下规则建立了一个简单的分类器:如果输入点(a, b)a大于或等于b,那么它属于类型class_0;反之,它属于class_1。如果对数据点逐个进行检查,你会发现每个数都是这样,这样你就建立了一个可以识别未知数据的线性分类器(linear classifier)。之所以称其为线性分类器,是因为分割线是一条直线。如果分割线是一条曲线,就是非线性分类器(nonlinear classifier)。

    这样简单的分类器之所以可行,是因为数据点很少,可以直观地判断分割线。如果有几千个数据点呢?如何对分类过程进行一般化处理(generalize)呢?下一节将介绍这一主题。

    2.3 建立逻辑回归分类器

    虽然这里也出现了上一章介绍的回归这个词,但逻辑回归其实是一种分类方法。给定一组数据点,需要建立一个可以在类之间绘制线性边界的模型。逻辑回归就可以对训练数据派生的一组方程进行求解来提取边界。

    详细步骤

    (1) 下面看看用 Python 如何实现逻辑回归。我们使用 logistic_regression.py 文件作为参考。假设已经导入了需要使用的程序包,接下来创建一些带训练标记的样本数据:

    import numpy as npfrom sklearn import linear_modelimport matplotlib.pyplot as pltX = np.array([[4, 7], [3.5, 8], [3.1, 6.2], [0.5, 1], [1, 2],[1.2, 1.9], [6, 2], [5.7, 1.5], [5.4, 2.2]])y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2])

    这里假设一共有3个类。

    (2) 初始化一个逻辑回归分类器:

    classifier = linear_model.LogisticRegression(solver='liblinear', C=100)

    前面的函数有一些输入参数需要设置,但是最重要的两个参数是solverC。参数solver用于设置求解系统方程的算法类型,参数C表示正则化强度,数值越小,表示正则化强度越高。

    (3) 接下来训练分类器:

    classifier.fit(X, y)

    (4) 画出数据点和边界:

    plot_classifier(classifier, X, y)

    需要定义如下画图函数:

    def plot_classifier(classifier, X, y):    # 定义图形的取值范围    x_min, x_max = min(X[:, 0]) - 1.0, max(X[:, 0]) + 1.0    y_min, y_max = min(X[:, 1]) - 1.0, max(X[:, 1]) + 1.0

    预测值表示我们在图形中想要使用的数值范围,通常是从最小值到最大值。我们增加了一些余量(buffer),例如上面代码中的1.0。

    (5) 为了画出边界,还需要利用一组网格(grid)数据求出方程的值,然后把边界画出来。下面继续定义网格:

        # 设置网格数据的步长    step_size = 0.01    # 定义网格    x_values, y_values = np.meshgrid(np.arange(x_min, x_max, step_size), np.arange(y_min, y_max, step_size))

    变量x_valuesy_values包含求解方程数值的网格点。

    (6) 计算出分类器对所有数据点的分类结果:

        # 计算分类器输出结果    mesh_output = classifier.predict(np.c_[x_values.ravel(), y_values.ravel()])    # 数组维度变形    mesh_output = mesh_output.reshape(x_values.shape)

    (7) 用彩色区域画出各个类型的边界:

        # 用彩图画出分类结果    plt.figure()    # 选择配色方案    plt.pcolormesh(x_values, y_values, mesh_output, cmap=plt.cm.gray)

    这基本算是一个三维画图器,既可以画二维数据点,又可以用色彩清单(color scheme)表示不同区域的相关属性。你可以在这里找到所有的色彩清单。

    (8) 接下来再把训练数据点画在图上:

        plt.scatter(X[:, 0], X[:, 1], c=y, s=80, edgecolors='black', linewidth=1, cmap=plt.cm.Paired)    # 设置图形的取值范围    plt.xlim(x_values.min(), x_values.max())    plt.ylim(y_values.min(), y_values.max())    # 设置X轴与Y轴    plt.xticks((np.arange(int(min(X[:, 0])-1), int(max(X[:, 0])+1), 1.0)))    plt.yticks((np.arange(int(min(X[:, 1])-1), int(max(X[:, 1])+1), 1.0)))    plt.show()

    其中,plt.scatter把数据点画在二维图上。X[:, 0]表示0轴(X轴)的坐标值,X[:, 1]表示1轴(Y轴)的坐标值。c=y表示颜色的使用顺序。用目标标记映射cmap的颜色表。我们肯定希望不同的标记使用不同的颜色,因此,用y作为映射。坐标轴的取值范围由plt.xlimplt.ylim确定。为了标记坐标轴的数值,需要使用plt.xticksplt.yticks。在坐标轴上标出坐标值,就可以直观地看出数据点的位置。在前面的代码中,我们希望坐标轴的最大值与最小值之前的刻度是单位刻度,还希望这些刻度值是整数,因此用int()函数对最值取整。

    (9) 运行代码,就可以看到如图2-3所示的输出结果。

    {90%}

    图 2-3

    (10) 下面看看参数C对模型的影响。参数C表示对分类错误(misclassification)的惩罚值(penalty)。如果把参数C设置为1.0,会得到如图2-4所示的结果。

    {90%}

    图 2-4

    (11) 如果把参数C设置为10000,会得到如图2-5所示的结果。

    {90%}

    图 2-5

    随着参数C的不断增大,分类错误的惩罚值越高。因此,各个类型的边界更优。

    2.4 建立朴素贝叶斯分类器

    朴素贝叶斯分类器是用贝叶斯定理进行建模的监督学习分类器。下面看看如何建立一个朴素贝叶斯分类器。

    详细步骤

    (1) 我们使用naive_bayes.py文件作为参考。首先导入两个程序包:

    from sklearn.naive_bayes import GaussianNBfrom logistic_regression import plot_classifier

    (2) 下载的示例代码中有一个data_multivar.txt文件,里面包含了将要使用的数据,每一行数据都是由逗号分隔符分割的数值。从文件中加载数据:

    input_file = 'data_multivar.txt'X = []y = []with open(input_file, 'r') as f:    for line in f.readlines():        data = [float(x) for x in line.split(',')]        X.append(data[:-1])        y.append(data[-1])X = np.array(X)y = np.array(y)

    我们已经把输入数据和标记分别加载到变量Xy中了。

    (3) 下面建立一个朴素贝叶斯分类器:

    classifier_gaussiannb = GaussianNB()classifier_gaussiannb.fit(X, y)y_pred = classifier_gaussiannb.predict(X)

    GaussianNB函数指定了正态分布朴素贝叶斯模型(Gaussian Naive Bayes model)。

    (4) 接下来计算分类器的准确性:

    accuracy = 100.0 * (y == y_pred).sum() / X.shape[0]print "Accuracy of the classifier =", round(accuracy, 2), "%"

    (5) 画出数据点和边界:

    plot_classifier(classifier_gaussiannb, X, y)

    可以看到如图2-6所示的图形。

    {90%}

    图 2-6

    从图2-6中可以发现,这里的边界没有严格地区分所有数据点。在前面这个例子中,我们是对所有的数据进行训练。机器学习的一条最佳实践是用没有重叠(nonoverlapping)的数据进行训练和测试。理想情况下,需要一些尚未使用的数据进行测试,可以方便准确地评估模型在未知数据上的执行情况。scikit-learn 有一个方法可以非常好地解决这个问题,我们将在下一节介绍它。

    第02章:创建分类器(中)

    2.5 将数据集分割成训练集和测试集

    本节一起来看看如何将数据合理地分割成训练数据集和测试数据集。

    详细步骤

    (1) 增加下面的代码片段到上一节的 Python 文件中:

    from sklearn import cross_validationX_train, X_test, y_train, y_test = cross_validation.train_test_split(X, y, test_size=0.25, random_state=5)classifier_gaussiannb_new = GaussianNB()classifier_gaussiannb_new.fit(X_train, y_train)

    这里,我们把参数test_size设置成0.25,表示分配了25%的数据给测试数据集。剩下75%的数据将用于训练数据集。

    (2) 用分类器对测试数据进行测试:

    y_test_pred = classifier_gaussiannb_new.predict(X_test)

    (3) 计算分类器的准确性:

    accuracy = 100.0 * (y_test == y_test_pred).sum() / X_test.shape[0]print "Accuracy of the classifier =", round(accuracy, 2), "%"

    (4) 画出测试数据的数据点及其边界:

    plot_classifier(classifier_gaussiannb_new, X_test, y_test)

    (5) 可以看到如图2-7所示的图形。

    {90%}

    图 2-7

    2.6 用交叉验证检验模型准确性

    交叉验证是机器学习的重要概念。在上一节中,我们把数据分成了训练数据集和测试数据集。然而,为了能够让模型更加稳定,还需要用数据集的不同子集进行反复的验证。如果只是对特定的子集进行微调,最终可能会过度拟合(overfitting)模型。过度拟合是指模型在已知数据集上拟合得超级好,但是一遇到未知数据就挂了。我们真正想要的,是让机器学习模型能够适用于未知数据。

    2.6.1 准备工作

    介绍如何实现交叉验证之前,先讨论一下性能指标。当处理机器学习模型时,通常关心3个指标:精度(precision)、召回率(recall)和F1得分(F1 score)。可以用参数评分标准(parameter scoring)获得各项指标的得分。精度是指被分类器正确分类的样本数量占分类器总分类样本数量的百分比(分类器分类结果中,有一些样本分错了)。召回率是指被应正确分类的样本数量占某分类总样本数量的百分比(有一些样本属于某分类,但分类器却没有分出来)。

    假设数据集有100个样本,其中有82个样本是我们感兴趣的,现在想用分类器选出这82个样本。最终,分类器选出了73个样本,它认为都是我们感兴趣的。在这73个样本中,其实只有65个样本是我们感兴趣的,剩下的8个样本我们不感兴趣,是分类器分错了。可以如下方法计算分类器的精度:

    • 分类正确的样本数量 = 65

    • 总分类样本数量 = 73

    • 精度 = 65 / 73 = 89.04%

    召回率的计算过程如下:

    • 数据集中我们感兴趣的样本数量 = 82

    • 分类正确的样本数量 = 65

    • 召回率 = 65 / 82 = 79.26%

    一个给力的机器学习模型需要同时具备良好的精度和召回率。这两个指标是二律背反的,一个指标达到100%,那么另一个指标就会非常差!我们需要保持两个指标能够同时处于合理高度。为了量化两个指标的均衡性,引入了 F1得分指标,是精度和召回率的合成指标,实际上是精度和召回率的调和均值(harmonic mean):

    F1 得分=2×精度×召回率 / (精度+召回率)

    上面示例中 F1得分的计算过程如下:

    F1 得分=2×0.89×0.79 / (0.89+0.79)=0.8370

    2.6.2 详细步骤

    (1) 下面看看如何实现交叉验证,并提取性能指标。首先计算精度:

    num_validations = 5accuracy = cross_validation.cross_val_score(classifier_gaussiannb,        X, y,scoring='accuracy', cv=num_validations)print "Accuracy: " + str(round(100*accuracy.mean(), 2)) + "%"

    (2) 用前面的方程分别计算精度、召回率和F1得分:

    f1 = cross_validation.cross_val_score(classifier_gaussiannb,        X, y, scoring='f1_weighted', cv=num_validations)print "F1: " + str(round(100*f1.mean(), 2)) + "%"precision = cross_validation.cross_val_score(classifier_ gaussiannb,        X, y, scoring='precision_weighted', cv=num_validations)print "Precision: " + str(round(100*precision.mean(), 2)) + "%"recall = cross_validation.cross_val_score(classifier_gaussiannb,        X, y, scoring='recall_weighted', cv=num_validations)print "Recall: " + str(round(100*recall.mean(), 2)) + "%"

    2.7 混淆矩阵可视化

    混淆矩阵(confusion matrix)是理解分类模型性能的数据表,它有助于我们理解如何把测试数据分成不同的类。当想对算法进行调优时,就需要在对算法做出改变之前了解数据的错误分类情况。有些分类效果比其他分类效果更差,混淆矩阵可以帮助我们理解这些问题。先看看如图2-8所示的混淆矩阵。

    {%}

    图 2-8

    在图2-8中,我们可以看出不同类型的分类数据。理想情况下,我们希望矩阵非对角线元素都是0,这是最完美的分类结果。先看看class 0,一共52个样本属于class 0。如果对第一行数据求和,总数就是52。但是现在,只有45个样本被正确地预测出来,分类器说另外4个样本属于class 1,还有3个样本属于class 2。用同样的思路分析另外两行数据,有意思的是,class 1里面有11个样本被错误地预测成了class 0,占到了class 1总数的16%。这就是模型需要优化的切入点。

    详细步骤

    (1) 我们用 confusion_matrix.py 文件作为参考。首先看看如何从数据中提取混淆矩阵:

    from sklearn.metrics import confusion_matrixy_true = [1, 0, 0, 2, 1, 0, 3, 3, 3]y_pred = [1, 1, 0, 2, 1, 0, 1, 3, 3]confusion_mat = confusion_matrix(y_true, y_pred)plot_confusion_matrix(confusion_mat)

    这里用了一些样本数据,一共有4种类型,取值范围是0~3,也列出了预测的标记类型。用confusion_matrix方法提取混淆矩阵,然后把它画出来。

    (2) 继续定义混淆矩阵的画图函数:

    # 显示混淆矩阵def plot_confusion_matrix(confusion_mat):    plt.imshow(confusion_mat, interpolation='nearest', cmap=plt.cm.Paired)    plt.title('Confusion matrix')    plt.colorbar()    tick_marks = np.arange(4)    plt.xticks(tick_marks, tick_marks)    plt.yticks(tick_marks, tick_marks)    plt.ylabel('True label')    plt.xlabel('Predicted label')    plt.show()

    这里用imshow函数画混淆矩阵,其他函数都非常简单,只使用相关函数设置了图形的标题、颜色栏、刻度和标签。参数tick_marks的取值范围是0~3,因为数据集中有4个标记类型。np.arange函数会生成一个numpy数组。

    (3) 运行代码,可以看到如图2-9所示的图形。

    {90%}

    图 2-9

    从图2-9中可以看出,对角线的颜色很亮,我们希望它们越亮越好。黑色区域表示0。在非对角线的区域有一些灰色区域,表示分类错误的样本量。例如,当样本真实标记类型是0,而预测标记类型是1时,就像在第一行的第二格看到的那样。事实上,所有的错误分类都属于class-1,因为第二列有3个不为0的格子。这在图2-9中显示得一目了然。

    2.8 提取性能报告

    也可以直接用 scikit-learn 打印精度、召回率和 F1得分。接下来看看如何实现。

    详细步骤

    (1) 在一个新的 Python 文件中加入下面的代码:

    from sklearn.metrics import classification_reporty_true = [1, 0, 0, 2, 1, 0, 3, 3, 3]y_pred = [1, 1, 0, 2, 1, 0, 1, 3, 3]target_names = ['Class-0', 'Class-1', 'Class-2', 'Class-3']print(classification_report(y_true, y_pred, target_names=target_names))

    (2) 运行代码,可以在命令行工具中看到如图2-10所示的结果。

    {%}

    图 2-10

    不需要单独计算各个指标,可以直接用这个函数从模型中提取所有统计值。

    2.9 根据汽车特征评估质量

    接下来看看如何用分类技术解决现实问题。我们将用一个包含汽车多种细节的数据集,例如车门数量、后备箱大小、维修成本等,来确定汽车的质量。分类的目的是把车辆的质量分成4种类型:不达标、达标、良好、优秀。

    2.9.1 准备工作

    你可以从这里下载数据集。

    你需要把数据集中的每个值看成是字符串。考虑数据集中的6个属性,其取值范围是这样的:

    • buying:取值范围是vhighhighmedlow

    • maint:取值范围是vhighhighmedlow

    • doors:取值范围是2345等;

    • persons:取值范围是24等;

    • lug_boot:取值范围是smallmedbig

    • safety:取值范围是lowmedhigh

    考虑到每一行都包含字符串属性,需要假设所有特征都是字符串,并设置分类器。在上一章中,我们用随机森林建立过回归器,这里再用随机森林建立分类器。

    2.9.2 详细步骤

    (1) 参考 car.py 文件中的源代码。首先导入两个软件包:

    from sklearn import preprocessingfrom sklearn.ensemble import RandomForestClassifier

    (2) 加载数据集:

    input_file = 'path/to/dataset/car.data.txt'# 读取数据X = []count = 0with open(input_file, 'r') as f:    for line in f.readlines():        data = line[:-1].split(',')        X.append(data)X = np.array(X)

    每一行都包含由逗号分隔的单词列表。因此,我们解析输入文件,对每一行进行分割,然后将该列表附加到主数据。我们忽略每一行最后一个字符,因为那是一个换行符。由于 Python 程序包只能处理数值数据,所以需要把这些属性转换成程序包可以理解的形式。

    (3) 在上一章中,我们介绍过标记编码。下面可以用这个技术把字符串转换成数值:

    # 将字符串转化为数值label_encoder = []X_encoded = np.empty(X.shape)for i,item in enumerate(X[0]):    label_encoder.append(preprocessing.LabelEncoder())    X_encoded[:, i] = label_encoder[-1].fit_transform(X[:, i])X = X_encoded[:, :-1].astype(int)y = X_encoded[:, -1].astype(int)

    由于每个属性可以取有限数量的数值,所以可以用标记编码器将它们转换成数字。我们需要为不同的属性使用不同的标记编码器,例如,lug_boot属性可以取3个不同的值,需要建立一个懂得给这3个属性编码的标记编码器。每一行的最后一个值是类,将它赋值给变量y

    (4) 接下来训练分类器:

    # 建立随机森林分类器params = {'n_estimators': 200, 'max_depth': 8, 'random_state': 7}classifier = RandomForestClassifier(**params)classifier.fit(X, y)

    你可以改变n_estimatorsmax_depth参数的值,观察它们如何改变分类器的准确性。我们将用一个标准化的方法处理参数选择问题。

    (5) 下面进行交叉验证:

    # 交叉验证from sklearn import cross_validationaccuracy = cross_validation.cross_val_score(classifier,        X, y, scoring='accuracy', cv=3)print "Accuracy of the classifier: " + str(round(100*accuracy. mean(), 2)) + "%"

    一旦训练好分类器,我们就需要知道它是如何执行的。我们用三折交叉验证(three-fold cross-validation,把数据分3组,轮换着用其中两组数据验证分类器)来计算分类器的准确性。

    (6) 建立分类器的主要目的就是要用它对孤立的和未知的数据进行分类。下面用分类器对一个单一数据点进行分类:

    # 对单一数据示例进行编码测试input_data = ['vhigh', 'vhigh', '2', '2', 'small', 'low']input_data_encoded = [-1] * len(input_data)for i,item in enumerate(input_data):    input_data_encoded[i] = int(label_encoder[i].transform(input_data[i]))input_data_encoded = np.array(input_data_encoded)

    第一步是把数据转换成数值类型。需要使用之前训练分类器时使用的标记编码器,因为我们需要保持数据编码规则的前后一致。如果输入数据点里出现了未知数据,标记编码器就会出现异常,因为它不知道如何对这些数据进行编码。例如,如果你把列表中的第一个值vhigh改成abcd,那么标记编码器就不知道如何编码了,因为它不知道怎么处理这个字符串。这就像是错误检查,看看输入数据点是否有效。

    (7) 现在可以预测出数据点的输出类型了:

    # 预测并打印特定数据点的输出output_class = classifier.predict(input_data_encoded)print "Output class:", label_encoder[-1].inverse_transform(output_class)[0]

    我们用predict方法估计输出类型。如果输出被编码的输出标记,那么它对我们没有任何意义。因此,用inverse_transform方法对标记进行解码,将它转换成原来的形式,然后打印输出类。

    第02章:创建分类器(下)

    2.10 生成验证曲线

    前面用随机森林建立了分类器,但是并不知道如何定义参数。本节来处理两个参数:n_estimatorsmax_depth参数。它们被称为超参数(hyperparameters),分类器的性能是由它们决定的。当改变超参数时,如果可以看到分类器性能的变化情况,那就再好不过了。这就是验证曲线的作用。这些曲线可以帮助理解每个超参数对训练得分的影响。基本上,我们只对感兴趣的超参数进行调整,其他参数可以保持不变。下面将通过可视化图片演示超参数的变化对训练得分的影响。

    详细步骤

    (1) 打开上一节的 Python 文件,加入以下代码:

    # 验证曲线from sklearn.learning_curve import validation_curveclassifier = RandomForestClassifier(max_depth=4, random_state=7)parameter_grid = np.linspace(25, 200, 8).astype(int)train_scores, validation_scores = validation_curve(classifier, X, y, "n_estimators", parameter_grid, cv=5)print "\n##### VALIDATION CURVES #####"print "\nParam: n_estimators\nTraining scores:\n", train_scoresprint "\nParam: n_estimators\nValidation scores:\n", validation_ scores

    在这个示例中,我们通过固定max_depth参数的值来定义分类器。我们想观察评估器数量对训练得分的影响,于是用parameter_grid定义了搜索空间。评估器数量会在25~200之间每隔8个数迭代一次,获得模型的训练得分和验证得分。

    (2) 运行代码,可以在命令行工具中看到如图2-11所示的结果。

    {90%}

    图 2-11

    (3) 把数据画成图形:

    # 画出曲线图plt.figure()plt.plot(parameter_grid, 100*np.average(train_scores, axis=1), color='black')plt.title('Training curve')plt.xlabel('Number of estimators')plt.ylabel('Accuracy')plt.show()

    (4) 得到的图形如图2-12所示。

    {90%}

    图 2-12

    (5) 用类似的方法对max_depth参数进行验证:

    classifier = RandomForestClassifier(n_estimators=20, random_ state=7)parameter_grid = np.linspace(2, 10, 5).astype(int)train_scores, valid_scores = validation_curve(classifier, X, y, "max_depth",        parameter_grid, cv=5)print "\nParam: max_depth\nTraining scores:\n", train_scoresprint "\nParam: max_depth\nValidation scores:\n", validation_ scores

    我们把n_estimators参数固定为20,看看max_depth参数变化对性能的影响。命令行工具的输出结果如图2-13所示。

    (6) 把数据画成图形:

    # 画出曲线图plt.figure()plt.plot(parameter_grid, 100*np.average(train_scores, axis=1), color='black')plt.title('Validation curve')plt.xlabel('Maximum depth of the tree')plt.ylabel('Accuracy')plt.show()

    {90%}

    图 2-13

    (7) 运行代码,可以看到如图2-14所示的图形。

    {90%}

    图 2-14

    2.11 生成学习曲线

    学习曲线可以帮助我们理解训练数据集的大小对机器学习模型的影响。当遇到计算能力限制时,这一点非常有用。下面改变训练数据集的大小,把学习曲线画出来。

    详细步骤

    (1) 打开上一节的 Python 文件,加入以下代码:

    # 学习曲线from sklearn.learning_curve import learning_curveclassifier = RandomForestClassifier(random_state=7)parameter_grid = np.array([200, 500, 800, 1100])train_sizes, train_scores, validation_scores = learning_ curve(classifier,        X, y, train_sizes=parameter_grid, cv=5)print "\n##### LEARNING CURVES #####"print "\nTraining scores:\n", train_scoresprint "\nValidation scores:\n", validation_scores

    我们想分别用200、500、800、1100的训练数据集的大小测试模型的性能指标。我们把learning_curve方法中的cv参数设置为5,就是用五折交叉验证。

    (2) 运行代码,可以在命令行工具中看到如图2-15所示的结果。

    {%}

    图 2-15

    (3) 把数据画成图形:

    # 画出曲线图plt.figure()plt.plot(parameter_grid, 100*np.average(train_scores, axis=1), color='black')plt.title('Learning curve')plt.xlabel('Number of training samples')plt.ylabel('Accuracy')plt.show()

    (4) 得到的图形如图2-16所示。

    {90%}

    图 2-16

    虽然训练数据集的规模越小,仿佛训练准确性越高,但是它们很容易导致过度拟合。如果选择较大规模的训练数据集,就会消耗更多的资源。因此,训练数据集的规模选择也是一个需要结合计算能力进行综合考虑的问题。

    2.12 估算收入阶层

    本节将根据14个属性建立分类器评估一个人的收入等级。可能的输出类型是“高于50K”和“低于或等于50K”。这个数据集稍微有点复杂,里面的每个数据点都是数字和字符串的混合体。数值数据是有价值的,在这种情况下,不能用标记编码器进行编码。需要设计一套既可以处理数值数据,也可以处理非数值数据的系统。我们将用美国人口普查收入数据集中的数据

    详细步骤

    (1) 我们将用 income.py 文件作为参考,用朴素贝叶斯分类器解决问题。首先导入两个软件包:

    from sklearn import preprocessingfrom sklearn.naive_bayes import GaussianNB

    (2) 加载数据集:

    input_file = 'path/to/adult.data.txt'# 读取数据X = []y = []count_lessthan50k = 0count_morethan50k = 0num_images_threshold = 10000

    (3) 我们将使用数据集中的20 000个数据点——每种类型10 000个,保证初始类型没有偏差。在模型训练时,如果你的大部分数据点都属于一个类型,那么分类器就会倾向于这个类型。因此,最好使用每个类型数据点数量相等的数据进行训练:

    with open(input_file, 'r') as f:    for line in f.readlines():        if '?' in line:            continue        data = line[:-1].split(', ')        if data[-1] == '<=50K' and count_lessthan50k < num_images_threshold:            X.append(data)            count_lessthan50k = count_lessthan50k + 1        elif data[-1] == '>50K' and count_morethan50k < num_images_threshold:            X.append(data)            count_morethan50k = count_morethan50k + 1        if count_lessthan50k >= num_images_threshold and count_morethan50k >= num_images_threshold:            breakX = np.array(X)

    同样地,这也是一个带逗号分隔符的文件。我们还是像之前那样处理,把数据加载到变量X

    (4) 我们需要把字符串属性转换为数值数据,同时需要保留原有的数值数据:

    # 将字符串转换为数值数据label_encoder = []X_encoded = np.empty(X.shape)for i,item in enumerate(X[0]):    if item.isdigit():        X_encoded[:, i] = X[:, i]    else:        label_encoder.append(preprocessing.LabelEncoder())        X_encoded[:, i] = label_encoder[-1].fit_transform(X[:, i])X = X_encoded[:, :-1].astype(int)y = X_encoded[:, -1].astype(int)

    isdigit()函数帮助我们判断一个属性是不是数值数据。我们把字符串数据转换为数值数据,然后把所有的标记编码器保存在一个列表中,便于在后面处理未知数据时使用。

    (5) 训练分类器:

    # 建立分类器classifier_gaussiannb = GaussianNB()classifier_gaussiannb.fit(X, y)

    (6) 把数据分割成训练数据集和测试数据集,方便后面获取性能指标:

    # 交叉验证from sklearn import cross_validationX_train, X_test, y_train, y_test = cross_validation.train_test_split(X, y, test_size=0.25, random_state=5)classifier_gaussiannb = GaussianNB()classifier_gaussiannb.fit(X_train, y_train)y_test_pred = classifier_gaussiannb.predict(X_test)

    (7) 提取性能指标:

    # 计算分类器的F1得分f1 = cross_validation.cross_val_score(classifier_gaussiannb,        X, y, scoring='f1_weighted', cv=5)print "F1 score: " + str(round(100*f1.mean(), 2)) + "%"

    (8) 接下来看看如何为单一数据点分类。我们需要把数据点转换成分类器可以理解的形式:

    # 对单一数据示例进行编码测试input_data = ['39', 'State-gov', '77516', 'Bachelors', '13', 'Never-married', 'Adm-clerical', 'Not-in-family', 'White', 'Male', '2174', '0', '40', 'United-States']count = 0input_data_encoded = [-1] * len(input_data)for i,item in enumerate(input_data):    if item.isdigit():        input_data_encoded[i] = int(input_data[i])    else:        input_data_encoded[i] = int(label_encoder[count].transform(input_data[i]))        count = count + 1input_data_encoded = np.array(input_data_encoded)

    (9) 这样就可以进行分类了:

    # 预测并打印特定数据点的输出结果output_class = classifier_gaussiannb.predict(input_data_encoded)print label_encoder[-1].inverse_transform(output_class)[0]

    和之前的分类案例一样,我们用predict方法获取输出类型,然后用inverse_transform对标记进行解码,将它转换成原来的形式,然后在命令行工具中打印出来。

    第03章:预测建模(上)
    第03章:预测建模(下)
    第04章:无监督学习——聚类(上)
    第04章:无监督学习——聚类(中)
    第04章:无监督学习——聚类(下)
    第05章:构建推荐引擎(上)
    第05章:构建推荐引擎(中)
    第05章:构建推荐引擎(下)
    第06章:分析文本数据(上)
    第06章:分析文本数据(中)
    第06章:分析文本数据(下)
    第07章:语音识别(上)
    第07章:语音识别(下)
    第08章:解剖时间序列和时序数据(上)
    第08章:解剖时间序列和时序数据(下)
    第09章:图像内容分析(上)
    第09章:图像内容分析(下)
    第10章:人脸识别(上)
    第10章:人脸识别(中)
    第10章:人脸识别(下)
    第11章:深度神经网络(上)
    第11章:深度神经网络(中)
    第11章:深度神经网络(下)
    第12章:可视化数据(上)
    第12章:可视化数据(下)

    阅读全文: http://gitbook.cn/gitchat/geekbook/5a3c787a902f0f2223e2526f

    展开全文
  • python机器学习案例系列教程——LightGBM算法

    万次阅读 多人点赞 2018-05-08 16:23:08
    安装pip install lightgbmgitup网址:https://github.com/Microsoft/LightGBM中文教程http://lightgbm.apachecn.org/cn/latest/index.htmllightGBM简介xgboost的出现,让数据民工们告别了传统的机器学习算法们:RF、...

    分享一个朋友的人工智能教程。零基础!通俗易懂!风趣幽默!还带黄段子!大家可以看看是否对自己有帮助:点击打开


    全栈工程师开发手册 (作者:栾鹏)
    python教程全解

    安装

    pip install lightgbm
    

    gitup网址:https://github.com/Microsoft/LightGBM

    中文教程

    http://lightgbm.apachecn.org/cn/latest/index.html

    lightGBM简介

    xgboost的出现,让数据民工们告别了传统的机器学习算法们:RF、GBM、SVM、LASSO………。现在微软推出了一个新的boosting框架,想要挑战xgboost的江湖地位。

    顾名思义,lightGBM包含两个关键点:light即轻量级,GBM 梯度提升机。

    LightGBM 是一个梯度 boosting 框架,使用基于学习算法的决策树。它可以说是分布式的,高效的,有以下优势:

    • 更快的训练效率

    • 低内存使用

    • 更高的准确率

    • 支持并行化学习

    • 可处理大规模数据

    xgboost缺点

    其缺点,或者说不足之处:

    每轮迭代时,都需要遍历整个训练数据多次。如果把整个训练数据装进内存则会限制训练数据的大小;如果不装进内存,反复地读写训练数据又会消耗非常大的时间。

    预排序方法(pre-sorted):首先,空间消耗大。这样的算法需要保存数据的特征值,还保存了特征排序的结果(例如排序后的索引,为了后续快速的计算分割点),这里需要消耗训练数据两倍的内存。其次时间上也有较大的开销,在遍历每一个分割点的时候,都需要进行分裂增益的计算,消耗的代价大。

    对cache优化不友好。在预排序后,特征对梯度的访问是一种随机访问,并且不同的特征访问的顺序不一样,无法对cache进行优化。同时,在每一层长树的时候,需要随机访问一个行索引到叶子索引的数组,并且不同特征访问的顺序也不一样,也会造成较大的cache miss。

    lightGBM特点

    以上与其说是xgboost的不足,倒不如说是lightGBM作者们构建新算法时着重瞄准的点。解决了什么问题,那么原来模型没解决就成了原模型的缺点。

    概括来说,lightGBM主要有以下特点:

    • 基于Histogram的决策树算法

    • 带深度限制的Leaf-wise的叶子生长策略

    • 直方图做差加速

    • 直接支持类别特征(Categorical Feature)

    • Cache命中率优化

    • 基于直方图的稀疏特征优化

    • 多线程优化

    前2个特点使我们尤为关注的。

    Histogram算法

    直方图算法的基本思想:先把连续的浮点特征值离散化成k个整数,同时构造一个宽度为k的直方图。遍历数据时,根据离散化后的值作为索引在直方图中累积统计量,当遍历一次数据后,直方图累积了需要的统计量,然后根据直方图的离散值,遍历寻找最优的分割点。

    带深度限制的Leaf-wise的叶子生长策略

    Level-wise过一次数据可以同时分裂同一层的叶子,容易进行多线程优化,也好控制模型复杂度,不容易过拟合。但实际上Level-wise是一种低效算法,因为它不加区分的对待同一层的叶子,带来了很多没必要的开销,因为实际上很多叶子的分裂增益较低,没必要进行搜索和分裂。

    Leaf-wise则是一种更为高效的策略:每次从当前所有叶子中,找到分裂增益最大的一个叶子,然后分裂,如此循环。因此同Level-wise相比,在分裂次数相同的情况下,Leaf-wise可以降低更多的误差,得到更好的精度。

    Leaf-wise的缺点:可能会长出比较深的决策树,产生过拟合。因此LightGBM在Leaf-wise之上增加了一个最大深度限制,在保证高效率的同时防止过拟合。

    xgboost和lightgbm

    决策树算法

    XGBoost使用的是pre-sorted算法,能够更精确的找到数据分隔点;

    • 首先,对所有特征按数值进行预排序。
    • 其次,在每次的样本分割时,用O(# data)的代价找到每个特征的最优分割点。
    • 最后,找到最后的特征以及分割点,将数据分裂成左右两个子节点。

    优缺点:

    这种pre-sorting算法能够准确找到分裂点,但是在空间和时间上有很大的开销。

    • i. 由于需要对特征进行预排序并且需要保存排序后的索引值(为了后续快速的计算分裂点),因此内存需要训练数据的两倍。
    • ii. 在遍历每一个分割点的时候,都需要进行分裂增益的计算,消耗的代价大。

    LightGBM使用的是histogram算法,占用的内存更低,数据分隔的复杂度更低。

    其思想是将连续的浮点特征离散成k个离散值,并构造宽度为k的Histogram。然后遍历训练数据,统计每个离散值在直方图中的累计统计量。在进行特征选择时,只需要根据直方图的离散值,遍历寻找最优的分割点。

    Histogram 算法的优缺点:

    • Histogram算法并不是完美的。由于特征被离散化后,找到的并不是很精确的分割点,所以会对结果产生影响。但在实际的数据集上表明,离散化的分裂点对最终的精度影响并不大,甚至会好一些。原因在于decision tree本身就是一个弱学习器,采用Histogram算法会起到正则化的效果,有效地防止模型的过拟合。
    • 时间上的开销由原来的O(#data * #features)降到O(k * #features)。由于离散化,#bin远小于#data,因此时间上有很大的提升。
    • Histogram算法还可以进一步加速。一个叶子节点的Histogram可以直接由父节点的Histogram和兄弟节点的Histogram做差得到。一般情况下,构造Histogram需要遍历该叶子上的所有数据,通过该方法,只需要遍历Histogram的k个捅。速度提升了一倍。

    决策树生长策略

    XGBoost采用的是按层生长level(depth)-wise生长策略,如Figure 1所示,能够同时分裂同一层的叶子,从而进行多线程优化,不容易过拟合;但不加区分的对待同一层的叶子,带来了很多没必要的开销。因为实际上很多叶子的分裂增益较低,没必要进行搜索和分裂。

    这里写图片描述

    LightGBM采用leaf-wise生长策略,如Figure 2所示,每次从当前所有叶子中找到分裂增益最大(一般也是数据量最大)的一个叶子,然后分裂,如此循环。因此同Level-wise相比,在分裂次数相同的情况下,Leaf-wise可以降低更多的误差,得到更好的精度。Leaf-wise的缺点是可能会长出比较深的决策树,产生过拟合。因此LightGBM在Leaf-wise之上增加了一个最大深度的限制,在保证高效率的同时防止过拟合。

    这里写图片描述

    网络通信优化

    XGBoost由于采用pre-sorted算法,通信代价非常大,所以在并行的时候也是采用histogram算法;LightGBM采用的histogram算法通信代价小,通过使用集合通信算法,能够实现并行计算的线性加速。

    LightGBM支持类别特征

    实际上大多数机器学习工具都无法直接支持类别特征,一般需要把类别特征,转化one-hotting特征,降低了空间和时间的效率。而类别特征的使用是在实践中很常用的。基于这个考虑,LightGBM优化了对类别特征的支持,可以直接输入类别特征,不需要额外的0/1展开。并在决策树算法上增加了类别特征的决策规则。

    lightGBM调参

    所有的参数含义,参考:http://lightgbm.apachecn.org/cn/latest/Parameters.html

    调参过程:

    (1)num_leaves

    LightGBM使用的是leaf-wise的算法,因此在调节树的复杂程度时,使用的是num_leaves而不是max_depth。

    大致换算关系:num_leaves = 2^(max_depth)

    (2)样本分布非平衡数据集:可以param[‘is_unbalance’]=’true’

    (3)Bagging参数:bagging_fraction+bagging_freq(必须同时设置)、feature_fraction

    (4)min_data_in_leaf、min_sum_hessian_in_leaf

    sklearn接口形式的LightGBM示例

    这里主要以sklearn的使用形式来使用lightgbm算法,包含建模,训练,预测,网格参数优化。

    import lightgbm as lgb
    import pandas as pd
    from sklearn.metrics import mean_squared_error
    from sklearn.model_selection import GridSearchCV
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.datasets import  make_classification
    # 加载数据
    print('Load data...')
    
    iris = load_iris()
    data=iris.data
    target = iris.target
    X_train,X_test,y_train,y_test =train_test_split(data,target,test_size=0.2)
    
    # df_train = pd.read_csv('../regression/regression.train', header=None, sep='\t')
    # df_test = pd.read_csv('../regression/regression.test', header=None, sep='\t')
    # y_train = df_train[0].values
    # y_test = df_test[0].values
    # X_train = df_train.drop(0, axis=1).values
    # X_test = df_test.drop(0, axis=1).values
    
    print('Start training...')
    # 创建模型,训练模型
    gbm = lgb.LGBMRegressor(objective='regression',num_leaves=31,learning_rate=0.05,n_estimators=20)
    gbm.fit(X_train, y_train,eval_set=[(X_test, y_test)],eval_metric='l1',early_stopping_rounds=5)
    
    print('Start predicting...')
    # 测试机预测
    y_pred = gbm.predict(X_test, num_iteration=gbm.best_iteration_)
    # 模型评估
    print('The rmse of prediction is:', mean_squared_error(y_test, y_pred) ** 0.5)
    
    # feature importances
    print('Feature importances:', list(gbm.feature_importances_))
    
    # 网格搜索,参数优化
    estimator = lgb.LGBMRegressor(num_leaves=31)
    
    param_grid = {
        'learning_rate': [0.01, 0.1, 1],
        'n_estimators': [20, 40]
    }
    
    gbm = GridSearchCV(estimator, param_grid)
    
    gbm.fit(X_train, y_train)
    
    print('Best parameters found by grid search are:', gbm.best_params_)
    
    

    原生形式使用lightgbm

    # coding: utf-8
    # pylint: disable = invalid-name, C0111
    import json
    import lightgbm as lgb
    import pandas as pd
    from sklearn.metrics import mean_squared_error
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.datasets import  make_classification
    
    iris = load_iris()
    data=iris.data
    target = iris.target
    X_train,X_test,y_train,y_test =train_test_split(data,target,test_size=0.2)
    
    
    # 加载你的数据
    # print('Load data...')
    # df_train = pd.read_csv('../regression/regression.train', header=None, sep='\t')
    # df_test = pd.read_csv('../regression/regression.test', header=None, sep='\t')
    #
    # y_train = df_train[0].values
    # y_test = df_test[0].values
    # X_train = df_train.drop(0, axis=1).values
    # X_test = df_test.drop(0, axis=1).values
    
    # 创建成lgb特征的数据集格式
    lgb_train = lgb.Dataset(X_train, y_train)
    lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)
    
    # 将参数写成字典下形式
    params = {
        'task': 'train',
        'boosting_type': 'gbdt',  # 设置提升类型
        'objective': 'regression', # 目标函数
        'metric': {'l2', 'auc'},  # 评估函数
        'num_leaves': 31,   # 叶子节点数
        'learning_rate': 0.05,  # 学习速率
        'feature_fraction': 0.9, # 建树的特征选择比例
        'bagging_fraction': 0.8, # 建树的样本采样比例
        'bagging_freq': 5,  # k 意味着每 k 次迭代执行bagging
        'verbose': 1 # <0 显示致命的, =0 显示错误 (警告), >0 显示信息
    }
    
    print('Start training...')
    # 训练 cv and train
    gbm = lgb.train(params,lgb_train,num_boost_round=20,valid_sets=lgb_eval,early_stopping_rounds=5)
    
    print('Save model...')
    # 保存模型到文件
    gbm.save_model('model.txt')
    
    print('Start predicting...')
    # 预测数据集
    y_pred = gbm.predict(X_test, num_iteration=gbm.best_iteration)
    # 评估模型
    print('The rmse of prediction is:', mean_squared_error(y_test, y_pred) ** 0.5)
    
    
    展开全文
  • Python机器学习实训营(原理推导+代码复现+实验分析)课程旨在帮助同学们在机器学习领域打下坚实基础。课程注重算法原理讲解与数学公式推导并基于Python语言给出完整的代码实现,从零开始实现每一模块功能(非调用...
  • Python常用的机器学习Python在科学计算中用途广泛:计算机视觉、人工智能、数学、天文等。它同样适用于机器学习也是意料之中的事。 这篇文章就列举并描述Python的最有用的机器学习工具和库。这个列表中,我们不...
  • Python机器学习--四大基础库

    千人学习 2017-09-06 13:48:15
    科学计算库Numpy ,数据分析处理库Pandas,可视化库Matplotlib与Seaborn 是Python机器学习中最基本的四大机器学习库,也是Python机器学习的发展主线。本课程重点介绍了Python库的基本知识点,使用方法并配合案列...
  • [机器学习篇]机器学习知识总结篇

    千次阅读 热门讨论 2017-03-08 22:36:48
    1、机器学习的数学基础1 - 数学分析 机器学习的一般方法和横向比较 数学是有用的:以SVD为例 机器学习的角度看数学 复习数学分析 直观解释常数e 导数/梯度 随机梯度下降 Taylor展式的落地应用 gini...
  • Python机器学习算法和实践

    千人学习 2018-06-22 15:49:25
    机器学习算法实战教程,包括各种常用机器学习算法,该课程教学视频以手写形式+普通话授课(类似斯坦福大学授课方式),+Python代码。经典算法进行原理推导与案例实战双管齐下,具体课程内容包括K-Means算法、KNN算法...
  • 机器学习实战》学习笔记(一):机器学习基础

    千次阅读 多人点赞 2019-08-19 17:01:32
    专栏【机器学习】 【机器学习】《机器学习实战》读书笔记及代码 总目录 https://blog.csdn.net/TeFuirnever/article/details/99701256 ————————————————————————————————————...
  • 机器学习】广义回归神经网络(GRNN)的python实现

    万次阅读 多人点赞 2018-12-12 21:29:34
    机器学习】广义回归神经网络(GRNN)的python实现一、广义回归神经网络原理1.1、GRNN与PNN的关系2.2、GRNN的网络结构二、广义回归神经网络的优点与不足2.1、优点2.2、不足三、GRNN的python实现参考资料 ...
  • Python机器学习进阶实战视频教学

    千人学习 2018-11-14 14:51:56
    进阶实战课程旨在帮助同学们掌握机器学习进阶算法原理并应用Python工具包进行实战任务,学习过程中建议大家先掌握机器学习经典算法再加入进阶实战课程中。课程整体风格通俗易懂,用最接地气的方式带大家轻松入门...
  • python机器学习库sklearn——神经网络

    万次阅读 2018-01-15 15:02:16
    python数据挖掘系列教程 神经网络算法详情参考: https://blog.csdn.net/luanpeng825485697/article/details/79009050 https://blog.csdn.net/luanpeng825485697/article/details/79009154 https://blog...
  • 问题来自慕课斯坦福机器学习课程 更多内容访问omegaxyz.com问题·输入数据只有一维:房子的面积 ·目标的数据只有一维:房子的价格 根据已知房子的面积和价格进行机器学习和模型预测 数据见文章末尾 数据需要...
  • Python机器学习之Logistic回归

    万次阅读 2016-04-14 17:11:38
    大数据时代,数据犹如一座巨大的金矿,等待我们去发掘。而机器学习和数据挖掘的相关技术,无疑就是...作为一个范例,今天将演示在Python 中利用Scikit-Learn所提供的函数来实现基于Logistic Regression分类机器学习技术
  • 点击打开链接
  • 全栈工程师开发手册 (作者:栾鹏) python数据挖掘系列教程 学习预测函数的参数,并在相同数据集上进行测试... 为了避免这种情况,在进行(监督)机器学习实验时,通常取出部分可利用数据作为 test set(测试...
  • python机器学习框架

    千次阅读 2018-08-29 14:32:07
    转载奶爸码农,非常感谢大神分享。原文 随着2016年Alpha Go在围棋击败李世石,2017年初卡内基梅隆大学人工智能系统Libratus在长达20天的鏖战中,打败4名世界顶级德州扑克玩家,这标志着人工智能技术又达到了一个新...
  • python 机器学习类库

    千次阅读 2013-08-13 15:40:18
    链接地址: 点击打开链接 有空的时候再学习
  • Python机器学习——学习曲线

    千次阅读 2018-09-27 14:01:07
    机器学习分为有监督学习和无监督的学习。 有监督学习:对数据的若干特征与若干标签之间的关联性进行建模的过程,确定模型后就能应用到新的未知数据中。进一步可以分为分类和回归任务。分类对应离散型数据,而回归...
  • Python 机器学习框架

    千次阅读 2017-12-06 16:26:48
    NuPIC: Numenta Platform for Intelligent ComputingNuPIC 是一个基于一种被称为分层式即时记忆(HTM/ Hierarchical Temporal Memory)的新皮质理论的开源项目。... The Shogun Machine Learning ToolboxShogun
  • python机器学习算法(Keras)

    千次阅读 2017-07-11 09:46:11
    python机器学习算法
  • Python机器学习

    千次阅读 2014-02-26 22:01:28
    Python在科学计算领域,有两个重要的扩展模块:Numpy和Scipy。其中Numpy是一个用python实现的科学计算包。包括: 一个强大的N维数组对象Array;比较成熟的(广播)函数库;用于整合C/C++和Fortran代码的工具...

空空如也

1 2 3 4 5 ... 20
收藏数 277,924
精华内容 111,169
关键字:

python机器学习

python 订阅