「深度学习福利」大神带你进阶工程师,立即查看>>>
前言
本文主要是介绍了,给定一个卷积神经网络的配置之后,如何大概估算它的浮点数运算量。
基于MXNet实现的计算网络模型运算量的小工具：
Python版本
Scala版本
在知乎上写了一篇博客算是对本文的内容的一些补充： https://zhuanlan.zhihu.com/p/65248401
正文
对于炼丹师来说,针对任务调整网络结构或者在做模型精简的时候,尤其是对模型的速度有要求的时候,
都想知道新模型的运算量有多大,虽然这个只是一个间接参考值,网络真正的运行速度还要考虑其他的
因素（具体解释可以参考 shufflenet v2 这篇文章）。那么对于给定一个卷积神经网络的模型定义,
该如何估算其浮点数运算量,对于卷积神经网络来说,卷积层的运算量是占网络总运算量的大头,而对于
一些像素级别任务,反卷积层也要算上,而全连接的权值大小是占网络权值的大头,运算量也有些。
所以一般来说把这三个层考虑上了,就能大概估算一个网络的运算量了。当然激活层（一般指relu）,
BatchNorm层,比如残差网络会有elementwise sum,池化层,这些也会占一定的运算量。不过其实对于
BN来说,一般标配是conv + bn + relu,在上线使用过程中,可以把 bn 的权值融合进卷积层的权值中,
所以相当于没了bn这一层,变成 conv +relu,所以bn其实不用考虑,当然并不是所有的网络都是这样配置的。
网络各层运算量计算方法
卷积层运算量
对于卷积层来说,计算运算量的话其实很简单,因为卷积层的操作其实可以改写为矩阵乘法,这个思想很
经典了,把输入的feature map通过im2col操作生成一个矩阵,然后就可以和权值矩阵做乘法就得到了
输出的feature map,具体见下图：
画的有点难看,Cin是输入feature map 通道数,Hin和Win是输入feature map空间大小,
同样的Cout,Hout,Wout 对应输出feature map,然后 k表示卷积核空间大小。
首先最左边的权值矩阵很好理解,然后中间的矩阵就是输入feature map通过 im2col操作,
生成的矩阵,而输出矩阵的每个位置对应一个卷积核和输入的一个局域做一次卷积操作,
一个卷积核的大小就是 Cin * k * k,输入的一个区域要算上输入通道数,所以就对应了权值
矩阵的一行乘以输入矩阵的一列。
这样,卷积层的运算量就很明显了： conv flops = Cout * Cin * k * k * Hout * Wout * BatchSize
如果还有偏置项的话,还要加上 BatchSize * Cout * Hout * Wout .
当然上面的公式没有考虑分组卷积的情况,但是demo的代码里面考虑了。
反卷积层运算量
反卷积其实也叫做转置卷积,其正反向传播,和卷积的正反向刚好相反,其运算量还是用画个图好解释。
这里要注意和上面卷积的符号定义区分开,这里的 Cin指的是反卷积层输入 feature map的
通道数,Hin 和 Win是输入的空间大小。所以Cout,Hout和Wout是反卷积层的输出大小。
而权值的形状为何是Cin * Cout * k * k,看图就很清晰了,首先我们知道反卷积的bp就是
卷积的fp,那么先从反卷积bp的角度来看,就相当于卷积的fp,中间的矩阵乘法就很好理解了。
然后反卷积的fp相当于把权值矩阵转置放到右边,就得到了反卷积的输出,然后这个输出并不是
最后的输出,还要通过col2im操作,把这个矩阵的值,回填到 Cout * Hout * Wout 这个矩阵里。
这样,反卷积层的运算量就很明显了： deconv flops = Cin * Cout * k * k * Hin * Win * BatchSize
如果还有偏置项的话,还要加上 BatchSize * Cout * Hout * Wout .
所以计算反卷积的运算量,除了权值大小,输出大小（计算偏置）,还需要知道输入的大小。
全连接层运算量
对与全连接层,即使矩阵向量乘法,其运算量就等于权值矩阵的大小,
所以 fullyconnected flops = BatchSize * Cout * Cin
Cout为全连接输出向量维度,Cin为输入维度。
如果有偏置项,还要加上： BatchSize * Cout。
池化层运算量
池化层的话就相当于卷积的简化版,这里根据池化的参数配置又可以分为两种情况,
如果是全局池化：
那么 pooling flops = BatchSize * Cin * Hin * Win
如果是一般的池化：
那么从输出的角度来考虑,输出的feature map上每一个通道上的每一个点就对应着
输入feature map同样通道的上的一个k * k 区域的 max ,sum或者avg池化操作,
所以 pooling flops = BatchSize * Cout * Hout * Wout * k * k

「深度学习福利」大神带你进阶工程师,立即查看>>>
摘要： 9月19日,2018杭州·云栖大会现场,杭州城市大脑2.0正式发布,管辖范围扩大28倍,覆盖面积增至420平方公里,相当于65个西湖大小。 ET城市大脑等数字化城市解决方案,掀开了“杭州故事”的新篇章。
9 月19 日,2018杭州·云栖大会现场,杭州城市大脑2.0正式发布,管辖范围扩大28倍,覆盖面积增至420平方公里,相当于65个西湖大小。
ET 城市大脑等数字化城市解决方案,掀开了“杭州故事”的新篇章。今天的杭州,已从千年古城变为全球领先的数字化城市样本。
“这些新杭州故事,明天将会在更多城市发生。”阿里云总裁胡晓明在大会上表示,将以杭州为起点,向全球更多城市输出数字中国的“杭州方案”。
从人文胜地到科技之都 科技改变一座城
自古以来,杭州就是人文的代名词。“江南忆,最忆是杭州”诠释着人们对杭州的全部想象。
然而,今天的杭州不只是“人间天堂”,过去几年来,杭州在中国城市竞争中异军突起,变身为一座“科技之都”。
本次云栖大会上,杭州市政府联合阿里云等企业建设的杭州城市大脑2.0 正式发布。仅一年时间,城市大脑已成为杭州新基础设施：管辖范围扩大28倍,覆盖全城420平方公里,相当于65个西湖大小。通过交警手持的移动终端,大脑实时指挥200多名交警。在城市大脑的作用下,杭州交通拥堵率从2016年时的全国第5降至2018年的全国第57名。
除了依靠大数据、人工智能摆脱拥堵,今天的杭州,还是“移动支付之城”、“移动办事之城”、“智慧医疗之城”。
在杭州,出门办事“最多跑一次”,全市59 个政府部门368.32亿条信息汇聚在基于阿里云打造的政务服务平台上,市民可凭身份证一证通办296项事务。
在杭州,超过95 ％的超市便利店、超过98％的出租车、5000余辆公交车都支持移动支付,堪称全球最大的移动支付之城。
在杭州,近年来,智慧医疗让近7000 万人次在杭州市属医院看病时间平均缩短2小时以上。
在杭州,成千上万的摊贩店主不再需要每天记账本、跑银行；跑航运、港运、路运的师傅不再需要花很多时间办数不清的证件；法院审理某些案子不再需要原告被告到场,甚至不需要书记员；去医院拍片子做CT ,不再需要去固定医院就诊,也不需要将片子全部打印出来；而创业公司也不再需要自己搭建服务器、数据中心,每天可能只需几十块钱就可以享受跟大公司一样的计算服务。
在杭州,一度遭遇低潮的百货业焕发新活力,银泰转型为大数据驱动的消费解决方案提供商。商超向新零售升级,世纪联华积极拥抱新技术。杭州银行携手云计算革新用户体验,具备了互联网金融能力。以吉利汽车为代表的汽车制造从营销到生产全流程数字化。
在传统工业制造领域,通过云计算与人工智能,沉默的数据被唤醒,中策橡胶、正泰新能源等工业企业的生产流程大幅优化,良品率上升带来利润增长。随着200 家工业企业相继入驻SupET工业互联网,杭州智造正在成为“新制造”的典型样本。
曾经,西雅图走出了亚马逊和微软两大科技巨头,反过来,两者也用数字化技术铸造了全新的西雅图。今天,杭州孕育了领先全球的云计算企业阿里云,而阿里巴巴则推动着千年古城杭州在新一轮数字化变革中走在前列。
“新杭州故事”只是刚刚开始
“ 我们今天讲述的新杭州故事只是开始,阿里云希望向全球更多城市输出新杭州背后的技术和实践。”在胡晓明看来,杭州被打造成数字中国的标杆城市,但新杭州故事的意义不止于杭州。
近年来,以阿里云为代表的科技企业走向海外,正在改变国际社会对中国的认知。国际社会已经将目光投入到中国科技带来的数字化转型上,科技领域的“中国方案”受到关注。区别于传统商品为主的国际贸易,中国技术走向世界不仅能为中国企业出海铺好“数字丝绸之路”,也能为当地经济增长带去新动能。
在中东,阿里云正在和有“中东MIT ”之称的哈利法大学共同探索解决能源领域的重大前沿问题；在传统工业大国德国,阿里云正在和世界知名的企业管理方案供应商SAP扩展全球合作伙伴关系,为全球企业提供更好的数字化转型解决方案；在非洲,阿里云正在和肯尼亚政府打造智能野生动物保护平台,保护更多珍稀动物；在奥运领域,阿里云正在和奥运转播服务公司OBS打造奥林匹克转播云,用视频云技术,让更多偏远地区可以更智能的方式观看奥运比赛视频；在马来西亚,ET城市大脑在杭州率先成功的特种车辆优先调度方案被吉隆坡引入,测试显示救护车到达现场的时间缩短了48.9%。未来,“杭州红绿灯”可能成为世界全新的一种红绿灯控制系统。
中国是全球数字化转型的试验场,而杭州是中国数字化浪潮的中心。100 年前,伦敦向世界输出了地铁,巴黎输出了下水道,纽约输出了电网。今天,中国杭州携手阿里云,正向世界贡献数字化城市方案。
杭州,是阿里云技术理想和家国情怀的起点和原点。
作者：阿里云头条
原文链接

「深度学习福利」大神带你进阶工程师,立即查看>>>
简单人像背景虚化处理思路如下： 对图像内容分割,提取人像,背景 背景模糊处理 人像与模糊处理后的背景融合
本实例使用DeepLabV3图像分割深度学习模型实现。代码如下： import numpy as np import tensorflow as tf import cv2 from deeplabmodel import * def create_pascal_label_colormap(): colormap = np.zeros((256, 3), dtype=int) ind = np.arange(256, dtype=int) for shift in reversed(range(8)): for channel in range(3): colormap[:, channel] |= ((ind >> channel) & 1) << shift ind >>= 3 return colormap def label_to_color_image(label): if label.ndim != 2: raise ValueError('Expect 2-D input label') colormap = create_pascal_label_colormap() if np.max(label) >= len(colormap): raise ValueError('label value too large.') return colormap[label] def load_model(): model_path = '../resources/models/tensorflow/deeplabv3_mnv2_pascal_train_aug_2018_01_29.tar.gz'#'deeplab_model.tar.gz' MODEL = DeepLabModel(model_path) print('model loaded successfully!') return MODEL model = load_model() src = cv2.imread('../resources/images/person2.jpg') # 背景图像 src_view = cv2.imread('../resources/images/view.jpg') resized_im, seg_map = model.run2(src) resized_view = cv2.resize(src_view,(resized_im.shape[1],resized_im.shape[0])) resized_view = cv2.medianBlur(resized_view,11) seg_image = label_to_color_image(seg_map).astype(np.uint8) print(seg_map.dtype) # seg_map = cv2.GaussianBlur(np.uint8(seg_map),(11,11),0) src_resized = cv2.resize(src,(resized_im.shape[1],resized_im.shape[0])) # seg_image = cv2.GaussianBlur(seg_image,(11,11),0) bg_img = np.zeros_like(src_resized) # 复制背景 bg_img[seg_map == 0] = src_resized[seg_map == 0] blured_bg = cv2.GaussianBlur(bg_img,(11,11),0) result = np.zeros_like(bg_img) # 合成 result[seg_map > 0] = resized_im[seg_map > 0] result[seg_map == 0] = blured_bg[seg_map == 0] # 背景变换与合成 result_2 = np.zeros_like(bg_img) result_2[seg_map > 0] = src_resized[seg_map > 0] result_2[seg_map == 0] = resized_view[seg_map == 0] cv2.imshow('src',src) cv2.imshow('resized_im',resized_im) cv2.imshow("seg_image",seg_image) cv2.imshow('bg_image',bg_img) cv2.imshow('blured_bg',blured_bg) cv2.imshow('result',result) cv2.imshow('result_2',result_2) cv2.waitKey() cv2.destroyAllWindows()
程序运行结果：
原始图像：
提取的人像Mask图像：
背景图像：
背景模糊图像：
背景虚化结果：
背景替换结果：
基本实现人像背景虚化效果与背景替换,但是还有很多细节没有优化,后期将进一步优化。

「深度学习福利」大神带你进阶工程师,立即查看>>>
简单实现思路： 对图像内容进行分割,提取人像 对图像背景进行模糊化处理 将人像和背景重新合成
在这里,使用DeepLabV3模型对图像内容进行分割并提取人像,实现的代码如下： import numpy as np import tensorflow as tf import cv2 from deeplabmodel import * def create_pascal_label_colormap(): colormap = np.zeros((256, 3), dtype=int) ind = np.arange(256, dtype=int) for shift in reversed(range(8)): for channel in range(3): colormap[:, channel] |= ((ind >> channel) & 1) << shift ind >>= 3 return colormap def label_to_color_image(label): if label.ndim != 2: raise ValueError('Expect 2-D input label') colormap = create_pascal_label_colormap() if np.max(label) >= len(colormap): raise ValueError('label value too large.') return colormap[label] def load_model(): model_path = '../resources/models/tensorflow/deeplabv3_mnv2_pascal_train_aug_2018_01_29.tar.gz'#'deeplab_model.tar.gz' MODEL = DeepLabModel(model_path) print('model loaded successfully!') return MODEL model = load_model() src = cv2.imread('../resources/images/person2.jpg') resized_im, seg_map = model.run2(src) seg_image = label_to_color_image(seg_map).astype(np.uint8) print(seg_map.dtype) # seg_map = cv2.GaussianBlur(np.uint8(seg_map),(11,11),0) src_resized = cv2.resize(src,(resized_im.shape[1],resized_im.shape[0])) seg_image = cv2.GaussianBlur(seg_image,(11,11),0) bg_img = np.zeros_like(src_resized) bg_img[seg_map == 0] = src_resized[seg_map == 0] blured_bg = cv2.GaussianBlur(bg_img,(11,11),0) result = np.zeros_like(bg_img) result[seg_map > 0] = resized_im[seg_map > 0] result[seg_map == 0] = blured_bg[seg_map == 0] cv2.imshow("seg_image",seg_image) cv2.imshow('bg_image',bg_img) cv2.imshow('blured_bg',blured_bg) cv2.imshow('result',result) cv2.waitKey() cv2.destroyAllWindows()
原图：
人像提取结果：
背景图像：
背景模糊图像：
合成结果：
效果不太理想,但总体上实现了背景虚化。后期将进行细节优化。

「深度学习福利」大神带你进阶工程师,立即查看>>>
项目 githup地址
项目的目的 爬取链家楼盘数据 数据可视化分析
工具 python3 scrapy
创建项目
scrapy安装及使用可以参考教程 scrapy ,在pycharm软件的Terminal上操作： scrapy startproject scrapys 生成的目录如下：
项目创建好了,下一步分析网页数据
爬取数据 打开主网页
打开链家官网,设定城市,以广州新楼盘为例‘ https://gz.fang.lianjia.com/loupan/’ 网站类似如下：
当然可以爬取更多城市的数据,url中gz改为城市代码即可,可以设置城市列表自动来爬取各个城市数据。 需求字段
网页中我们能看到楼盘列表,并且含有很多页,每页大概10个楼盘,每个楼盘包含的信息有(名称、房屋类型、地点、面积、均价、总价、标签等),我们选定爬取的字段有： 楼盘名称、房屋类型、面积、均价、总价、标签,6个字段数据。
在项目items.py文件中添加字段类： class LianjiaItem(scrapy.Item): # define the fields for your item here like: name = scrapy.Field() type = scrapy.Field() area_range = scrapy.Field() start_price = scrapy.Field() mean_price = scrapy.Field() tags = scrapy.Field() 网页分析
按F12进入页面代码分析,点击元素选择图标->在选择左边需要的字段信息,在代码区就能看到所在的位置,如下图：
也可以ctrl+f在输入框中搜索,或用xpath获取需要的信息,框中用输入 //div[@class="resblock-name"] 也能看到有10条信息。
各个字段的位置信息如下： 总路径：'//ul[@class="resblock-list-wrapper"]/li' name ：'div/div[@class="resblock-name"]/a[@class="name"]/text()' type ：'div/div[@class="resblock-name"]/span[@class="resblock-type"]/text()' area_range ：'div/div[@class="resblock-area"]/span/text()' mean_price ：'div/div[@class="resblock-price"]/div[@class="main-price"]/span[@class="number"]/text()' mean_unit ：'div/div[@class="resblock-price"]/div[@class="main-price"]/span[@class="desc"]/text()' start_price ：'div/div[@class="resblock-price"]/div[@class="second"]/text()' tags ：'div/div[@class="resblock-tag"]/span/text()' 数据爬取程序
分析好了数据获取路径,我们开始构建爬虫程序。 我们在spiders文件夹下新建一个爬虫脚本lianjia_spider.py： import re import scrapy from scrapy.http import Request from scrapys.items import LianjiaItem # scrapy用yield异步处理网页,想顺序处理网页,可以参考https://stackoverflow.com/questions/6566322/scrapy-crawl-urls-in-order class LJ_houseSpider(scrapy.Spider): name = "lianjia" allowed_domains = ["gz.fang.lianjia.com"] # 允许爬取的域名,非此域名的网页不会爬取 start_urls = [ "http://gz.fang.lianjia.com/loupan/" ] def start_requests(self): """ 这是一个重载函数,它的作用是发出第一个Request请求 :return: """ # 请求self.start_urls[0],返回的response会被送到回调函数parse中 yield Request(self.start_urls[0]) def parse(self, response): max_page_text = response.xpath('//div[@class="page-box"]/@data-total-count').extract() nums = re.findall(r'(\d+)',max_page_text[0]) max_num = int(nums[0]) max_num //= 10 print('max page>>>>>>>>>>>',max_num) for i in range(max_num): print(i) url = self.start_urls[0]+'pg'+str(i+1) yield Request(url, callback=self.extract_content, priority=max_num-i) #该方法及其他的Request回调函数必须返回一个包含 Request 及(或) Item 的可迭代的对象 def extract_content(self, response): paths = response.xpath('//ul[@class="resblock-list-wrapper"]/li') items = [] for sel in paths: item = LianjiaItem() name = sel.xpath('div/div[@class="resblock-name"]/a[@class="name"]/text()').extract() type = sel.xpath('div/div[@class="resblock-name"]/span[@class="resblock-type"]/text()').extract() area_range = sel.xpath('div/div[@class="resblock-area"]/span/text()').extract() mean_price = sel.xpath('div/div[@class="resblock-price"]/div[@class="main-price"]/span[@class="number"]/text()').extract() mean_unit = sel.xpath('div/div[@class="resblock-price"]/div[@class="main-price"]/span[@class="desc"]/text()').extract() start_price = sel.xpath('div/div[@class="resblock-price"]/div[@class="second"]/text()').extract() tags = sel.xpath('div/div[@class="resblock-tag"]/span/text()').extract() item['name'] = name[0] if name else 'NAN' item['type'] = type[0] if type else 'NAN' item['area_range'] = re.findall(r'\d+',area_range[0])+re.findall(r'-[\d+](.)+',area_range[0]) if area_range else [] item['mean_price'] = mean_price[0] +' '+ ' '.join(re.findall(r'\w[/]\w',mean_unit[0])) if mean_price and mean_unit else 'NAN' item['start_price'] = re.findall(r'\d+',start_price[0])+re.findall(r'[\d+](.)+[/]',start_price[0]) if start_price else [] item['tags'] = tags items.append(item) return items 数据存储到excel
将数据存储于excel文件中,在主目录下新建一个存数据的文件夹results；修改pipelines.py如下 import xlwt class ScrapysPipeline(object): def process_item(self, item, spider): return item class LianJiaPipeline(object): def __init__(self): self.filename = 'results/tianjing_houses.xls' self.outputbook = xlwt.Workbook() self.table = self.outputbook.add_sheet('sheet1', cell_overwrite_ok=True) self.nrow = 0 def process_item(self, item, spider): self.table.write(self.nrow, 0, item['name']) self.table.write(self.nrow, 1, item['type']) self.table.write(self.nrow, 2, ' '.join(item['area_range'])) self.table.write(self.nrow, 3, item['mean_price']) self.table.write(self.nrow, 4, ' '.join(item['start_price'])) self.table.write(self.nrow, 5, ' '.join(item['tags'])) self.nrow += 1 def close_spider(self, spider): self.outputbook.save(self.filename) 运行爬虫
在命令行输入 scrapy crawl lianjia 或者通过pycharm来运行,在主目录建文件main.py: #coding=utf8 from scrapy import cmdline cmdline.execute("scrapy crawl lianjia".split())
点击运行,结果如下：
数据可视化
（待续...）

「深度学习福利」大神带你进阶工程师,立即查看>>>
摘要： 深度学习背后的主要原因是人工智能应该从人脑中汲取灵感。本文就用一个小例子无死角的介绍一下深度学习！
人脑模拟
深度学习背后的主要原因是人工智能应该从人脑中汲取灵感。此观点引出了“神经网络”这一术语。人脑中包含数十亿个神经元,它们之间有数万个连接。很多情况下,深度学习算法和人脑相似,因为人脑和深度学习模型都拥有大量的编译单元（神经元）,这些编译单元（神经元）在独立的情况下都不太智能,但是当他们相互作用时就会变得智能。
我认为人们需要了解到深度学习正在使得很多幕后的事物变得更好。深度学习已经应用于谷歌搜索和图像搜索,你可以通过它搜索像“拥抱”这样的词语以获得相应的图像。－杰弗里·辛顿
神经元
神经网络的基本构建模块是人工神经元,它模仿了人类大脑的神经元。这些神经元是简单、强大的计算单元,拥有加权输入信号并且使用激活函数产生输出信号。这些神经元分布在神经网络的几个层中。
inputs 输入 outputs 输出 weights 权值 activation 激活
人工神经网络的工作原理是什么？
深度学习由人工神经网络构成,该网络模拟了人脑中类似的网络。当数据穿过这个人工网络时,每一层都会处理这个数据的一方面,过滤掉异常值,辨认出熟悉的实体,并产生最终输出。
输入层： 该层由神经元组成,这些神经元只接收输入信息并将它传递到其他层。输入层的图层数应等于数据集里的属性或要素的数量。 输出层： 输出层具有预测性,其主要取决于你所构建的模型类型。 隐含层： 隐含层处于输入层和输出层之间,以模型类型为基础。隐含层包含大量的神经元。处于隐含层的神经元会先转化输入信息,再将它们传递出去。随着网络受训练,权重得到更新,从而使其更具前瞻性。
神经元的权重
权重是指两个神经元之间的连接的强度或幅度。你如果熟悉线性回归的话,可以将输入的权重类比为我们在回归方程中用的系数。权重通常被初始化为小的随机数值,比如数值0-1。
前馈深度网络
前馈监督神经网络曾是第一个也是最成功的学习算法。该网络也可被称为深度网络、多层感知机（MLP）或简单神经网络,并且阐明了具有单一隐含层的原始架构。每个神经元通过某个权重和另一个神经元相关联。
该网络处理向前处理输入信息, 激活 神经元,最终产生输出值。在此网络中,这称为前向传递。
input layer 输入层 hidden layer 输出层 output layer 输出层
激活函数
激活函数就是求和加权的输入到神经元的输出的映射。之所以称之为激活函数或传递函数是因为它控制着激活神经元的初始值和输出信号的强度。
用数学表示为：
我们有许多激活函数,其中使用最多的是整流线性单元函数、双曲正切函数和solfPlus函数。
激活函数的速查表如下：
反向传播
在网络中,我们将预测值与预期输出值相比较,并使用函数计算其误差。然后,这个误差会传回这个网络,每次传回一个层,权重也会根绝其导致的误差值进行更新。这个聪明的数学法是 反向传播算法 。这个步骤会在训练数据的所有样本中反复进行,整个训练数据集的网络更新一轮称为一个时期。一个网络可受训练数十、数百或数千个时期。
prediction error 预测误差
代价函数和梯度下降
代价函数度量了神经网络对给定的训练输入和预期输出“有多好”。该函数可能取决于权重、偏差等属性。
代价函数是单值的,并不是一个向量,因为它从整体上评估神经网络的性能。在运用梯度下降最优算法时,权重在每个时期后都会得到增量式地更新。
兼容代价函数
用数学表述为差值平方和：
target 目标值 output 输出值
权重更新的大小和方向是由在代价梯度的反向上采取步骤计算出的。
其中η 是学习率
其中Δ w 是包含每个权重系数w的权重更新的向量,其计算方式如下：
target 目标值 output 输出值
图表中会考虑到单系数的代价函数
initial weight 初始权重 gradient 梯度 global cost minimum 代价极小值
在导数达到最小误差值之前,我们会一直计算梯度下降,并且每个步骤都会取决于斜率（梯度）的陡度。
多层感知器（前向传播）
这类网络由多层神经元组成,通常这些神经元以前馈方式（向前传播）相互连接。一层中的每个神经元可以直接连接后续层的神经元。在许多应用中,这些网络的单元会采用S型函数或整流线性单元（整流线性激活）函数作为 激活函数 。
现在想想看要找出处理次数这个问题,给定的账户和家庭成员作为输入
要解决这个问题,首先,我们需要先创建一个前向传播神经网络。我们的输入层将是家庭成员和账户的数量,隐含层数为1, 输出层将是处理次数。
将图中输入层到输出层的给定权重作为输入：家庭成员数为2、账户数为3。
现在将通过以下步骤使用前向传播来计算隐含层（i,j）和输出层（k）的值。
步骤：
1, 乘法－添加方法。
2, 点积（输入＊权重）。
3,一次一个数据点的前向传播。
4, 输出是该数据点的预测。
i的值将从相连接的神经元所对应的输入值和权重中计算出来。
i = (2 * 1) + (3 * 1) → i = 5
同样地,j = (2 * -1) + (3 * 1) → j = 1
K = (5 * 2) + (1 * -1) → k = 9
Python 中的多层感知器问题的解决

激活函数的使用
为了使神经网络达到其最大预测能力,我们需要在隐含层应用一个激活函数,以捕捉非线性。我们通过将值代入方程式的方式来在输入层和输出层应用激活函数。
这里我们使用整流线性激活（ReLU）:

用Keras开发第一个神经网络
关于Keras：
Keras是一个高级神经网络的应用程序编程接口,由Python编写,能够搭建在TensorFlow,CNTK,或Theano上。
使用PIP在设备上安装Keras,并且运行下列指令。
在keras执行深度学习程序的步骤
1,加载数据；
2,创建模型；
3,编译模型；
4,拟合模型；
5,评估模型；
开发Keras模型
全连接层用Dense表示。我们可以指定层中神经元的数量作为第一参数,指定初始化方法为第二参数,即初始化参数,并且用激活参数确定激活函数。既然模型已经创建,我们就可以 编译 它。我们在底层库（也称为后端）用高效数字库编译模型,底层库可以用Theano或TensorFlow。目前为止,我们已经完成了创建模型和编译模型,为进行有效计算做好了准备。现在可以在PIMA数据上运行模型了。我们可以在模型上调用拟合函数f（）,以在数据上训练或拟合模型。
我们先从KERAS中的程序开始,

神经网络一直训练到150个时期,并返回精确值。
作者：【方向】
原文链接

「深度学习福利」大神带你进阶工程师,立即查看>>>
摘要： 不吹不黑,绝对史上最全的机器学习学习材料！
本文包含了迄今为止大家公认的最佳教程内容。它绝不是网上每个ML相关教程的详尽列表,而是经过精挑细选而成的,毕竟网上的东西并不全是好的。我作者汇总的目标是为了补充我即将出版的新书,为它寻找在机器学习和NLP领域中找到的最佳教程。
通过这些最佳教程的汇总,我可以快速的找到我想要得到的教程。从而避免了阅读更广泛覆盖范围的书籍章节和苦恼的研究论文,你也许知道,当你的数学功底不是很好的时候这些论文你通常是拿不下的。为什么不买书呢？没有哪一个作者是一个全能先生。当你尝试学习特定的主题或想要获得不同的观点时,教程可能是非常有帮助的。
我将这篇文章分为四个部分： 机器学习 , NLP , Python 和 数学 。我在每个部分都包含了一些主题,但由于机器学习是一个非常复杂的学科,我不可能包含所有可能的主题。
如果有很好的教程你知道我错过了,请告诉我！我将继续完善这个学习教程。我在挑选这些链接的时候,都试图保证每个链接应该具有与其他链接不同的材料或以不同的方式呈现信息（例如,代码与幻灯片）或从不同的角度。
机器学 习
从机器学习入手 （machinelearningmastery.com）
机器学习很有趣！ （medium.com/@ageitgey）
机器学习规则：ML工程的最佳实践 （martin.zinkevich.org）
机器学习速成课程： 第一部分 , 第二部分 , 第三部分 （伯克利机器学习）
机器学习理论及其应用简介：用一个小例子进行视觉教程 （toptal.com）
机器学习的简单指南 （monkeylearn.com）
我应该使用哪种机器学习算法？ （sas.com）
机器学习入门 （sas.com）
初学者机器学习教程 （kaggle.com/kanncaa1）
激活函数和 Dropout 函数
Sigmoid神经​​元 （neuralnetworksanddeeplearning.com）
激活函数在神经网络中的作用是什么？ （quora.com）
神经网络中常见的激活函数的优缺点比较列表 （stats.stackexchange.com）
激活函数及其类型 对比（medium.com）
理解对数损失 （exegetic.biz）
损失函数 （斯坦福CS231n）
L1与L2损失函数 （rishy.github.io）
交叉熵成本函数 （neuralnetworksanddeeplearning.com）
偏差（bias）
偏差在神经网络中的作用 （stackoverflow.com）
神经网络中的偏差节点 （makeyourownneuralnetwork.blogspot.com）
什么是人工神经网络的偏差？ （quora.com）
感知器
感知器 （neuralnetworksanddeeplearning.com）
感知 器（natureofcode.com）
单层神经网络（感知器） （dcu.ie）
从Perceptrons到Deep Networks （toptal.com）
回 归
线性回归分析介绍 （duke.edu）
线性回归 （ufldl.stanford.edu）
线性回归 （readthedocs.io）
Logistic回归 （readthedocs.io）
机器学习的简单线性回归教程 （machinelearningmastery.com）
机器学习的Logistic回归教程 （machinelearningmastery.com）
Softmax回归 （ufldl.stanford.edu）
梯度下降
在梯度下降中学习 （neuralnetworksanddeeplearning.com）
梯度下降 （iamtrask.github.io）
如何理解梯度下降算法 （kdnuggets.com）
梯度下降优化算法概述 （sebastianruder.com）
优化：随机梯度下降 （斯坦福CS231n）
生成学 习（Generative Learning）
生成学习算法 （斯坦福CS229）
朴素贝叶斯分类器 的 实用解释 （monkeylearn.com）
支持向量机
支持向量机（SVM）简介 （monkeylearn.com）
支持向量机 （斯坦福CS229）
线性分类：支持向量机,Softmax （Stanford 231n）
反向 传 播
你应该了解 的backprop（medium.com/@karpathy）
你能给出神经网络反向传播算法的直观解释吗？ （github.com/rasbt）
反向传播算法的工作原理 （neuralnetworksanddeeplearning.com）
通过时间 反向 传播和消失的渐变 （wildml.com）
时间反向传播的简单介绍 （machinelearningmastery.com）
反向传播,直觉 （斯坦福CS231n）
深度学 习
YN²深度学习指南 （yerevann.com）
深度学习论文阅读路线图 （github.com/floodsung）
Nutshell中的深度学习 （nikhilbuduma.com）
深度学习教程 （Quoc V.Le）
什么是深度学习？ （machinelearningmastery.com）
人工智能,机器学习和深度学习之间有什么区别？ （nvidia.com）
深度学习–简单介绍 （gluon.mxnet.io）
最优化和降维
数据降维减少的七种技术 （knime.org）
主成分分析 （斯坦福CS229）
Dropout：一种改善神经网络的简单方法 （Hinton @ NIPS 2012）
如何训练你的深度神经网络 ?（rishy.github.io）
长短期记忆（ LSTM ）
长短期记忆网络的通俗介绍 （machinelearningmastery.com）
了解LSTM 神经网络Networks （colah.github.io）
探索LSTM （echen.me）
任何人都可以学习用Python 编写 LSTM-RNN （iamtrask.github.io）
卷 积 神 经 网 络 （ CNN ）
卷积网络 介绍（neuralnetworksanddeeplearning.com）
深度学习和卷积神经网络 （medium.com/@ageitgey）
Conv Nets：模块化视角 （colah.github.io）
了解卷积 （colah.github.io）
递归神经网络（ RNN ）
递归神经网络教程 （wildml.com）
注意和增强的递归神经网络 （distill.pub）
递归 神经网络的不合理有效性 （karpathy.github.io）
深入了解 递归 神经网络 （nikhilbuduma.com）
强化学习
强化学习初学者入门及其实施指南 （analyticsvidhya.com）
强化学习教程 （mst.edu）
学习强化学习 （wildml.com）
深度强化学习：来自像素的乒乓球 （karpathy.github.io）
生成 对 抗网 络 （ GAN ）
对抗机器学习 简介（aaai18adversarial.github.io）
什么是生成性对抗网络？ （nvidia.com）
滥用生成对抗网络制作8位像素艺术 （medium.com/@ageitgey）
Generative Adversarial Networks简介（TensorFlow中的代码） （aylien.com）
初学者的生成对抗网络 （oreilly.com）
多任 务 学 习
深度神经网络中多任务学习概述 （sebastianruder.com）
NLP
自然语言处理很有趣！ （medium.com/@ageitgey）
自然语言处理神经网络模型入门 （Yoav Goldberg）
自然语言处理权威指南 （monkeylearn.com）
自然语言处理简介 （algorithmia.com）
自然语言处理教程 （vikparuchuri.com）
自然语言处理（NLP）来自Scratch （arxiv.org）
深度学 习 和 NLP
深度学习适用于NLP （arxiv.org）
NLP的深度学习（没有魔法） （Richard Socher）
了解NLP的卷积神经网络 （wildml.com）
深度学习、NLP、表示 （colah.github.io）
最先进的NLP模型的新深度学习公式： 嵌入、编码、参与、预测 （explosion.ai）
使用Torch深度神经网络进行自然语言 处理（nvidia.com）
使用Pytorch进行深度学习NLP （pytorich.org）
词向 量
使用 词袋模型解决 电影评论分类（kaggle.com）
词嵌入介绍 第一部分 , 第二部分 , 第三部分 （sebastianruder.com）
词向量的惊人力量 （acolyer.org）
word2vec参数学习解释 （arxiv.org）
Word2Vec教程-  Skip-Gram模型 , 负抽样 （mccormickml.com）
编码器 - 解 码 器
深度学习和NLP中的注意力机制和记忆力 模型（wildml.com）
序列模型（tensorflow.org）
使用神经网络进行序列学习 （NIPS 2014）
机器学习很有趣第五部分：深度学习的语言翻译和序列的魔力 （medium.com/@ageitgey）
如何使用编码器-解码器LSTM来回显随机整数序列 （machinelearningmastery.com）
tf-seq2seq （google.github.io）
Python
机器学习速成课程 （google.com）
令人敬畏的机器学习 （github.com/josephmisiti）
使用Python掌握机器学习的7个步骤 （kdnuggets.com）
一个示例机器学习笔记 （nbviewer.jupyter.org）
使用Python进行机器学习 （tutorialspoint.com）
实战案例
如何在Python中从头开始实现感知器算法 （machinelearningmastery.com）
在Python中使用Scratch实现神经网络 （wildml.com）
使用 11行代码在Python中实现神经网络 （iamtrask.github.io）
使用Python实现你自己的k-Nearest Neighbor算法 （kdnuggets.com）
来自Scatch的ML （github.com/eriklindernoren）
Python机器学习（第2版）代码库 （github.com/rasbt）
Scipy 和 numpy
Scipy讲义 （scipy-lectures.org）
Python Numpy教程 （斯坦福CS231n）
Numpy和Scipy简介 （UCSB CHE210D）
Python中的科学家 速成 课程 （nbviewer.jupyter.org）
scikit 学 习
PyCon scikit-learn教程索引 （nbviewer.jupyter.org）
scikit-learn分类算法 （github.com/mmmayo13）
scikit-learn教程 （scikit-learn.org）
简短的 scikit-learn教程 （github.com/mmmayo13）
Tensorflow
Tensorflow教程 （tensorflow.org）
TensorFlow简介 - CPU与GPU （medium.com/@erikhallstrm）
TensorFlow （metaflow.fr）
Tensorflow中的RNN （wildml.com）
在TensorFlow中实现CNN进行文本分类 （wildml.com）
如何使用TensorFlow运行文本摘要 （surmenok.com）
PyTorch
PyTorch教程 （pytorch.org）
PyTorch的简单介绍 （gaurav.im）
教程：PyTorch中的深度学习 （iamtrask.github.io）
PyTorch示例 （github.com/jcjohnson）
PyTorch教程 （github.com/MorvanZhou）
深度学习研究人员的PyTorch教程 （github.com/yunjey）
数学
机器学习数学 （ucsc.edu）
机器学习数学 （UMIACS CMSC422）
线性代 数
线性代数直观指南 （betterexplained.com）
程序员对矩阵乘法的直觉 （betterexplained.com）
了解Cross产品 （betterexplained.com）
了解Dot产品 （betterexplained.com）
用于机器学习的线性代数 （布法罗大学CSE574）
用于深度学习的线性代数备忘单 （medium.com）
线性代数评论与参考 （斯坦福CS229）
概率论
用比率理解贝叶斯定理 （betterexplained.com）
概率论 入门（斯坦福CS229）
机器学习的概率论 教程（斯坦福CS229）
概率论 （布法罗大学CSE574）
机器学习的概率论 （多伦多大学CSC411）
微积分
如何理解导数：商数规则,指数和对数 （betterexplained.com）
如何理解导数：产品,动力和链条规则 （betterexplained.com）
矢量微积分：了解渐变 （betterexplained.com）
微分学 （斯坦福CS224n）
微积分概述 （readthedocs.io）

本文由 阿里云云栖社区 组织翻译。
文章原标题《over-200-of-the-best-machine-learning-nlp-and-python-tutorials-2018-edition》
作者：【方向】
原文链接

「深度学习福利」大神带你进阶工程师,立即查看>>>
1.加载已知身份人脸数据 #载入已经人脸数据 def load_known_faces(dirname): for img in fnmatch.filter(os.listdir(dirname), '*.jpg'): print('load image:',img) image = facer.load_image_file(dirname + img) en_img = facer.face_encodings(image) if len(en_img) > 0: known_face_encodings.append(en_img[0]) known_face_names.append(img[:-4])
在这里,使用了几个公众人物的图像作为载入数据：
Andrew:
范冰冰(程序中使用fanbb代替)
2.载入测试数据并识别身份 def detect_and_authorization(know_faces_dir,image_for_testing): #加载已经身份的人脸数据 load_known_faces(know_faces_dir) #加载测试人脸数据 test_img = facer.load_image_file(image_for_testing) test_img = cv2.cvtColor(test_img,cv2.COLOR_BGR2RGB) cv2.imshow('test_img',test_img) #检测脸部数据 faces = facer.face_locations(test_img) encod_faces = facer.face_encodings(test_img, faces) #把测试脸部数据与已经加载的人脸数据比较,从实现身份识别 for (top, right, bottom, left), encod_face in zip(faces, encod_faces): #比较脸部数据 matches = facer.compare_faces(known_face_encodings, encod_face) #通过比较结果获取身份名称 if True in matches: foundindex = matches.index(True) name = known_face_names[foundindex] else: name = "Unknown" #绘制身份名称 cv2.rectangle(test_img, (left, top), (right, bottom), (0, 255, 0), 2) cv2.rectangle(test_img, (left, bottom - 35), (right, bottom), (0, 255, 0), cv2.FILLED) cv2.putText(test_img, name, (left + 6, bottom - 6), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1.0, (255, 255, 255), 1) cv2.imshow("Face ID", test_img) cv2.waitKey(0) cv2.destroyAllWindows()
3.程序运行结果

「深度学习福利」大神带你进阶工程师,立即查看>>>
1.安装环境
推荐使用linux安装TensorFlow,用Window完全是个坑,各种异常问题,安装方式连接： linux pip安装 tensorlfow (python2.7)
2.运行demo
为了对tensorflow有直观的认识,请运行以下demo : TensorFlow demo
3.界面呈现
tensorflow 界面的呈现可以使用工具TensorBoard,了解请使用 TensorBoard

「深度学习福利」大神带你进阶工程师,立即查看>>>
2018年4月16日,美国商务部宣布将在未来7年禁止美国公司以任何形式向中兴通讯销售零部件、商品、软件和技术。4月17日,中兴通讯（股票代码：000063.SZ）停牌,停牌期间商、政、学各界与美方积极协调磋商,即便如此,中兴在6月13日复牌后还是迎来了8个连续跌停,市值蒸发了超700亿。而中兴通讯港股（股票代码：00763.HK）开盘第一天便暴跌42%。与此同时,整个A股市场对于芯片相关的科技股走势也是一片恐慌。
伴随着股价大跌的是社会各界和民众对于中国无“芯”之痛的准确认知和深刻反思。
信息传递到一级市场,则是与芯片设计和制造相关的企业迅速成为资本寒冬下有限的优质标的,其中AI芯片行业的关注度尤高,该领域的领跑者寒武纪科技也在中兴通讯受挫时迅速敲定了估值25亿美金的B轮融资,国家队的继续领投也给中国“芯”带来慰藉。媒体和资方甚至将AI芯片视为中国芯片行业弯道超越的重大良机。
那么被如此寄予厚望的AI芯片到底和传统芯片有何区别,而当前AI芯片的国际和国内市场格局如何？AI芯片又是否真的可以带领中国“芯”走出困境呢？

「深度学习福利」大神带你进阶工程师,立即查看>>> 利用Farnback光流算法将视频序列生成光流并输出 def preprocessing(): print("开始获取数据...") # clips_directory = gb.glob(os.path.join(datasetTestDir, "*")) # 训练集 clips_directory = gb.glob(os.path.join(datasetTestDir, "Test???")) # 测试集光流生成算法 # 遍历所有数据集中的clip片段 for dir in clips_directory: curClip = dir.split('\\')[-1] print(curClip) img_path = gb.glob(os.path.join(dir, '*.tif')) prvs = cv2.cvtColor(cv2.imread(img_path[0]), cv2.COLOR_BGR2GRAY) hsv = np.zeros_like(cv2.imread(img_path[0])) hsv[..., 1] = 255 for i, curFrame in enumerate(img_path): print("curFrame: ", curFrame) img = cv2.imread(curFrame) next = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) flow = cv2.calcOpticalFlowFarneback(prvs, next, None, 0.5, 3, 15, 3, 5, 1.2, 0) mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1]) hsv[..., 0] = ang * 180 / np.pi / 2 hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX) rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR) # font = cv2.FONT_HERSHEY_SIMPLEX # 使用默认字体 # cv2.putText(img, str(i+1), (0, 20), font, 0.8, (255, 255, 255), 1) # #添加文字,1.2表示字体大小,（0,40）是初始的位置,(255,255,255)表示颜色,2表示粗细 # cv2.putText(rgb, str(i+1), (0, 20), font, 0.8, (255, 255, 255), 1) # #添加文字,1.2表示字体大小,（0,40）是初始的位置,(255,255,255)表示颜色,2表示粗细 cv2.namedWindow("rawImageFrame", 0) cv2.namedWindow("opticalFlowImageFrame", 1) cv2.resizeWindow("rawImageFrame", 360, 240) cv2.resizeWindow("opticalFlowImageFrame", 360, 240) cv2.imshow('rawImageFrame', img) cv2.imshow('opticalFlowImageFrame', rgb) # 将 opticalflow 图像写入相关文档 saveFolder = os.path.join(opticalflowTestDir, curClip) if not os.path.exists(saveFolder): os.makedirs(saveFolder) cv2.imwrite(saveFolder + "\\" + str(i+1) + '.tif', rgb) k = cv2.waitKey(30) & 0xff if k == 27: break elif k == ord('s'): cv2.imwrite('opticalfb.png', img) cv2.imwrite('opticalhsv.png', rgb) prvs = next cv2.destroyAllWindows()
利用Farnback光流算法将视频序列生成光流并输出

「深度学习福利」大神带你进阶工程师,立即查看>>> def _stop_unix(self, errors): """ UNIX implementation of process killing @param errors: error messages. stop() will record messages into this list. @type errors: [str] """ self.exit_code = self.popen.poll() if self.exit_code is not None: logger.debug("process[%s].stop(): process has already returned %s", self.name, self.exit_code) #print "process[%s].stop(): process has already returned %s"%(self.name, self.exit_code) self.popen = None self.stopped = True return pid = self.popen.pid pgid = os.getpgid(pid) logger.info("process[%s]: killing os process with pid[%s] pgid[%s]", self.name, pid, pgid) try: # Start with SIGINT and escalate from there. logger.info("[%s] sending SIGINT to pgid [%s]", self.name, pgid) os.killpg(pgid, signal.SIGINT) logger.info("[%s] sent SIGINT to pgid [%s]", self.name, pgid) timeout_t = time.time() + _TIMEOUT_SIGINT retcode = self.popen.poll() while time.time() < timeout_t and retcode is None: time.sleep(0.1) retcode = self.popen.poll() # Escalate non-responsive process if retcode is None: printerrlog("[%s] escalating to SIGTERM"%self.name) timeout_t = time.time() + _TIMEOUT_SIGTERM os.killpg(pgid, signal.SIGTERM) logger.info("[%s] sent SIGTERM to pgid [%s]"%(self.name, pgid)) retcode = self.popen.poll() while time.time() < timeout_t and retcode is None: time.sleep(0.2) logger.debug('poll for retcode') retcode = self.popen.poll() if retcode is None: printerrlog("[%s] escalating to SIGKILL"%self.name) errors.append("process[%s, pid %s]: required SIGKILL. May still be running."%(self.name, pid)) try: os.killpg(pgid, signal.SIGKILL) logger.info("[%s] sent SIGKILL to pgid [%s]"%(self.name, pgid)) # #2096: don't block on SIGKILL, because this results in more orphaned processes overall #self.popen.wait() #os.wait() logger.info("process[%s]: sent SIGKILL", self.name) except OSError as e: if e.args[0] == 3: printerrlog("no [%s] process with pid [%s]"%(self.name, pid)) else: printerrlog("errors shutting down [%s], see log for details"%self.name) logger.error(traceback.format_exc()) else: logger.info("process[%s]: SIGTERM killed with return value %s", self.name, retcode) else: logger.info("process[%s]: SIGINT killed with return value %s", self.name, retcode) finally: self.popen = None
参考： http://wiki.ros.org/roslaunch

「深度学习福利」大神带你进阶工程师,立即查看>>>
人脸识别在现实生活中有非常广泛的应用,例如iPhone X的识别人脸解锁屏幕、人脸识别考勤机、人脸识别开门禁、刷脸坐高铁,还有识别人脸虚拟化妆、美颜,甚至支付宝还推出了刷脸支付、建设银行还实现了刷脸取钱……,可见人脸识别的用处非常广。

既然人脸识别这么有用, 那我们能否自己来实现一个人脸识别模型呢？
答案是肯定的。
接下来将在之前我们搭建好的AI基础环境上（见文章： 搭建AI基础环境 ）,实现人脸识别模型。
0、人脸识别主要流程
要识别一张人脸,一般需要经过以下步骤：（1）通过摄像头或上传图片等方式采集图像；（2）检测图像里面有没有人脸,如果有就把人脸所在的区域圈出来；（3）对人脸图像进行灰度处理、噪声过滤等预处理；（4）提取人脸的特征数据出来；（5）将提取的人脸特征数据与人脸库进行匹配,输出识别结果。主要流程如下图所示：

下面将按步骤逐个介绍实现方式。
1、图像采集
本文采用OpenCV采集图像。

OpenCV是处理图像的流行工具,具备多种图像处理的能力,可跨平台运行在Linux、Windows、Mac OS等多个平台,使用C++编写,提供Python、C++、Ruby等语言的接口。在Python环境中,OpenCV和Tensorflow能很好地相互配合,利用OpenCV可方便快速地采集、处理图像,配合Tensorflow能很好地实现图像的建模工作。
（1）安装OpenCV
在conda虚拟环境中,OpenCV的安装方式如下： conda install --channel https://conda.anaconda.org/menpo opencv3
（2）采集图像
在OpenCV中调用摄像头采集图像的方式如下： # 1、调用摄像头进行拍照 cap = cv2.VideoCapture(0) ret, img = cap.read() cap.release()
如果已经是有现成的图片,则在OpenCV中直接读取就可以： # 2、根据提供的路径读取图像 img=cv2.imread(img_path)

2、人脸检测
人脸检测的主要目的是检测采集的图像中有没有人脸,并确定出人脸所在的位置和大小。检测人脸有很多种方式,下面介绍几种常用的方法：
（1）使用OpenCV检测人脸
OpenCV中自带了人脸检测器,基于Haar算法进行人脸检测。Haar算法的基本思路是这样的,通过使用一些矩形模板对图像进行扫描,例如下图中的两个矩形模板,中间一幅在扫描到眼睛时发现眼睛区域的颜色比周边脸颊区域的颜色深,表示符合眼睛的特征；右边一幅在扫描到鼻梁时发现鼻梁两侧比鼻梁的颜色要深,符合鼻梁的特征。同样地,再通过其它的矩形模板进行扫描,当发现具备眼睛、鼻梁、嘴巴等特征且超过一定的阈值时,则判定为是一张人脸。

使用OpenCV检测人脸,要先加载人脸分类器
代码如下： # 1、使用 opencv 检测人脸 # 加载人脸检测分类器（正面人脸）,位于OpenCV的安装目录下 face_cascade=cv2.CascadeClassifier('/data/anaconda3/envs/tensorflow/share/OpenCV/haarcascades/haarcascade_frontalface_default.xml') # 转灰度图 img_gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) # 检测人脸（可能有多张）,返回人脸位置信息(x,y,w,h) img_faces=face_cascade.detectMultiScale(img_gray)
（2）使用Dlib检测人脸

Dlib是一个包含机器学习算法开源工具包,基于C++编写,同样也提供了Python语言接口。使用Dlib也能很方便地检测出人脸,检测的效果要比OpenCV好,安装方式如下： # 安装 Dlib # 激活 conda 虚拟环境 conda activate tensorflow # 安装 Dlib conda install -c menpo dlib
代码如下： # Dlib 人脸检测 detector = dlib.get_frontal_face_detector() dets = detector(img, 1) # 获取人脸所在的位置 img_faces=[] for i in range(len(dets)): x = dlib.rectangle.left(dets[i]) y = dlib.rectangle.top(dets[i]) h = dlib.rectangle.height(dets[i]) w = dlib.rectangle.width(dets[i]) img_faces.append([x,y,w,h])

（3）使用face_recognition检测人脸

face_recognition是基于dlib的深度学习人脸识别库,在户外脸部检测数据库基准（Labeled Faces in the Wild benchmark,简称LFW）上的准确率达到了99.38%。
使用face_recognition检测人脸,安装方式如下： # 安装 face_recognition # 需要先安装dlib , 还有 CMake ( sudo apt-get install cmake ) # 激活 conda 虚拟环境 conda activate tensorflow # 由于 face_recognition 在 conda 中没有相应的软件包,因此通过 pip 安装 pip install face_recognition
代码如下： # 检测人脸 face_locations = face_recognition.face_locations(img) # 获取人脸的位置信息 img_faces = [] for i in range(len(face_locations)): x = face_locations[i][3] y = face_locations[i][0] h = face_locations[i][2] - face_locations[i][0] w = face_locations[i][1] - face_locations[i][3] img_faces.append([x, y, w, h])

（4）使用FaceNet检测人脸

FaceNet是谷歌发布的人脸检测算法,发表于CVPR 2015,这是基于深度学习的人脸检测算法,利用相同人脸在不同角度、姿态的高内聚性,不同人脸的低耦合性,使用卷积神经网络所训练出来的人脸检测模型,在LFW人脸图像数据集上准确度达到99.63%,比传统方法的准确度提升了将近30%,效果非常好。
使用FaceNet检测人脸,安装方式如下：
a. 到FaceNet的github上将源代码和相应的模型下载下来（https://github.com/davidsandberg/facenet）
b. 将要用到的python文件导入到本地的 facenet 库中,如下图所示：
代码如下： with tf.Graph().as_default(): sess = tf.Session() with sess.as_default(): pnet, rnet, onet = facenet.detect_face_fromfacenet.create_mtcnn(sess, './facenet/model_check_point/') minsize = 20 threshold = [0.6, 0.7, 0.7] factor = 0.709 bounding_boxes, _ = facenet.detect_face_fromfacenet.detect_face(img, minsize, pnet, rnet, onet, threshold, factor) img_faces = [] for face_position in bounding_boxes: face_position = face_position.astype(int) x = face_position[0] y = face_position[1] h = face_position[3] - face_position[1] w = face_position[2] - face_position[0] img_faces.append([x, y, w, h])

3、预处理
在做完图像的人脸检测后,得到了人脸所在的位置和大小,但由于受到各种条件的限制和随机干扰,需要根据实际采集的图像质量情况进行预处理,以提升图像的质量。主要的预处理有：
（1）调整尺寸： 根据网络传输带宽、电脑处理性能等相关的要求,对检测的人脸图像进行尺寸调整；
（2）直方图均衡化： 根据实际情况,对图像作直方图均衡,避免因光线问题,导致人脸上出现明显阴影的情况,从而影响了识别的准确率；
（3）噪声过滤： 通过使用中值滤波器、高斯滤波器等对图像进行噪声过滤,以提升图像质量；
（4）锐化： 由于摄像头对焦的问题,导致某些采集的照片出现模糊,通过锐化操作,提升图像的清晰度；
（5）光线补偿： 对于一些光线不足的图像进行光线补偿,提升照片的亮度,便于后续更加准确地提取特征。
4、特征提取
人脸是由眼睛、鼻子、嘴、下巴等局部构成,这些局部之间的结构关系,便是作为人脸的重要特征。人脸特征的提取,是对人脸进行特征建模的过程。
下面介绍提取人脸特征的几种方法：
（1）使用Dlib提取人脸特征（68维）
使用Dlib可提取人脸的68个特征点,这些特征点描述了眉毛、眼睛、鼻子、嘴巴,以及整个脸部的轮廓,如下图所示：

使用Dlib提取人脸特征的代码如下： # 1、dlib 提取人脸特征 # opencv 无法直接提取人脸特征,在这里设置 opencv 也采用 dlib 的特征提取方式 # 下载模型：http://dlib.net/files/ # 下载文件：shape_predictor_68_face_landmarks.dat.bz2 # 解压文件,得到 shape_predictor_68_face_landmarks.dat 文件 # 获取人脸检测器 predictor = dlib.shape_predictor('./dlib_model/shape_predictor_68_face_landmarks.dat') for index,face in enumerate(dets): face_feature = predictor(face_img,face)
（2）使用face_recognition提取人脸特征（128维）
face_recognition提取的人脸特征比Dlib更加细致,达到128个点,同样也是描述了眉毛、眼睛、鼻子、嘴巴等局部的关系。
使用face_recognition提取人脸特征的代码如下： # 2、face_recognition 提取人脸特征 face_feature = face_recognition.face_encodings(face_img)
（3）使用FaceNet提取人脸特征（128维）
使用FaceNet提取的人脸特征同样也有128维,代码如下： with tf.Graph().as_default(): sess = tf.Session() with sess.as_default(): batch_size=None image_size=160 images_placeholder = tf.placeholder(tf.float32, shape=(batch_size,image_size,image_size, 3), name='input') phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') model_checkpoint_path = './facenet/model_check_point/' input_map = {'input': images_placeholder, 'phase_train': phase_train_placeholder} model_exp = os.path.expanduser(model_checkpoint_path) meta_file, ckpt_file = get_model_filenames(model_exp) saver = tf.train.import_meta_graph(os.path.join(model_exp, meta_file), input_map=input_map) saver.restore(sess, os.path.join(model_exp, ckpt_file)) face_img = cv2.resize(face_img, (image_size, image_size), interpolation=cv2.INTER_CUBIC) data = np.stack([face_img]) embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0") feed_dict = {images_placeholder: data, phase_train_placeholder: False} face_feature = sess.run(embeddings, feed_dict=feed_dict)

5、匹配识别
在提取好人脸特征后,便是要用于识别这个人是谁。
将提取的人脸特征与数据库中存储的人脸特征数据进行检索匹配,当匹配的相似度超过一定的阈值后,便将匹配结果输出。
一般常用以下方式进行匹配：
（1）基于距离判断（欧氏距离）
将提取出来的人脸特征（68维或128维）,逐个与数据库中的人脸特征计算距离,一般使用欧氏距离,然后取最小的距离,当超过阈值时便输出识别结果。
这种方式简单易用,但却经常会误判,这是由于人的表情很丰富,数据库中并不一定会把所有表情都存储起来。
基于欧氏距离的人脸识别代码如下： # 1、欧氏距离 min_dis=99999 min_idx=-1 for i in range(len(features)): dis=np.sqrt(np.sum(np.square(face_feature-features[i]))) if dis（2）基于分类算法（KNN）
人脸特征的匹配本质上也是一个分类过程,即将属于同一个人的分类出来。采用K近邻（KNN）算法进行分类,这是数据挖掘中最简单的方法之一。所谓K近邻,就是K个最近邻居,就是说每个样本都可以用它最接近的K个邻居来代表。因此,KNN算法的核心思想是如果一个样本的K个最相邻的样本中的大多数属于某一个类别,则该样本也属于这个类别。
基于KNN的人脸识别代码如下： # 2、KNN knn = neighbors.KNeighborsClassifier(n_neighbors=2) knn.fit(features, labels) name = knn.predict([face_feature]) name = name[0]
通过以上步骤,我们了解了几种常见的人脸检测、识别算法,并掌握了一个完整的人脸识别程序的编写过程。


关注本人公众号“大数据与人工智能Lab”（BigdataAILab）,然后回复“ 代码 ”关键字可获取 完整源代码 。


推荐相关阅读 【AI实战】快速掌握TensorFlow（一）：基本操作 【AI实战】快速掌握TensorFlow（二）：计算图、会话 【AI实战】快速掌握TensorFlow（三）：激励函数 【AI实战】快速掌握TensorFlow（四）：损失函数 【AI实战】搭建基础环境 【AI实战】训练第一个模型 【AI实战】编写人脸识别程序 【AI实战】动手训练目标检测模型（SSD篇） 【AI实战】动手训练目标检测模型（YOLO篇） 【精华整理】CNN进化史 大话卷积神经网络（CNN） 大话循环神经网络（RNN） 大话深度残差网络（DRN） 大话深度信念网络（DBN） 大话CNN经典模型：LeNet 大话CNN经典模型：AlexNet 大话CNN经典模型：VGGNet 大话CNN经典模型：GoogLeNet 大话目标检测经典模型：RCNN、Fast RCNN、Faster RCNN 大话目标检测经典模型：Mask R-CNN 27种深度学习经典模型 浅说“迁移学习” 什么是“强化学习” AlphaGo算法原理浅析 大数据究竟有多少个V Apache Hadoop 2.8 完全分布式集群搭建超详细教程 Apache Hive 2.1.1 安装配置超详细教程 Apache HBase 1.2.6 完全分布式集群搭建超详细教程 离线安装Cloudera Manager 5和CDH5（最新版5.13.0）超详细教程

「深度学习福利」大神带你进阶工程师,立即查看>>>
决策树（decision tree）(三)——连续值处理
**注：本博客为周志华《机器学习》读书笔记,虽然有一些自己的理解,但是其中仍然有大量文字摘自周老师的《机器学习》书。
决策树系列博客： 决策树（decision tree）(一)——构造决策树方法 决策树（decision tree）(二)——剪枝 决策树（decision tree）(三)——连续值处理 决策树（decision tree）（四）缺失值处理
前面两篇博客分别介绍了如何构造决策树（根据信息增益,信息增益率,基尼指数等）和如何对决策树进行剪枝（预剪枝和后剪枝）,但是前面两篇博客主要都是基于离散变量的,然而我们现实的机器学习任务中会遇到连续属性,这篇博客主要介绍决策树如何处理连续值。
| 连续值处理
因为连续属性的可取值数目不再有限,因此不能像前面处理离散属性枚举离散属性取值来对结点进行划分。因此需要连续属性离散化,常用的离散化策略是二分法,这个技术也是C4.5中采用的策略。下面来具体介绍下,如何采用二分法对连续属性离散化：


下面举个具体的例子,来看看到底是怎样划分的。给定数据集如下（数据集来自周志华《机器学习》,我已经把数据集放到github上了,地址为： 西瓜数据集3.0 ）：
对于数据集中的属性“密度”,决策树开始学习时,根节点包含的17个训练样本在该属性上取值均不同。我们先把“密度”这些值从小到大排序：
根据上面计算 的公式,可得：
下面开始计算 t 取不同值时的信息增益：
对属性“含糖率”,同样的计算,能够计算出：
再由第一篇博客中 决策树（一） 计算得到的各属性的信息增益值：
比较能够知道纹理的信息增益值最大,因此,“纹理”被选作根节点划分属性,下面只要重复上述过程递归的进行,就能构造出一颗决策树：
** 有一点需要注意的是：与离散属性不同,若当前结点划分属性为连续属性,该属性还可作为其后代结点的划分属性。**如下图所示的一颗决策树,“含糖率”这个属性在根节点用了一次,后代结点也用了一次,只是两次划分点取值不同。

以上就是决策树如何处理连续值的内容,关于如何处理缺失值,因为我会写的比较详细,所以如果和连续值放在一起,会显得篇幅过长,因此放在下一篇博客中单独介绍。

「深度学习福利」大神带你进阶工程师,立即查看>>> 前言：做NLP工程时少不了利用各种现成的工具包来对文字进行处理,学习工作这么久,接触使用了不少nlp工具包,NLP中大多是以Python语言为主,因此大部分工具是Python的,少部分的是Java的以及C++的,主要功能无非实现校正,分词,词性标注,句法分析,句法依存等主流功能,具体使用方法见各官网以及博客,简单列举如下：
博主用过的： NLTK：Python的,安装方便,处理英文功能强大,中文也可,处于领先地位,语料库丰富,下载方便,可以实现统计,分词,词性标注,句法分析（这块好像有点弱）,做NLP不知道nltk?你是火星的nlp？ jieba：python的,是最常用的中文分词工具,支持多精度分词,安装使用十分方便。 ltp：哈工大的,业界很出名的一套处理中文系统,好像是python的,忘记了,反正python可以使用,不过安装可能报一个缺少微软的一个vc++东西错,忘记怎么解决的了,有机会再补充,可以实现分词,词性标注,命名实体识别,句法分析,依存关系等功能。 stanford NLP：这个是java的,不过Python可以安装使用,稍微麻烦一点,需要安装jdk,下载一些jar文件在本地,然后Python调用给jdk解析,有很多博客讲解安装的,就不细说了,可以实现分词,标准,识别,句法分析树等,可以处理中文 spaCy：这个功能比较强大,实现英语分词,词性还原,标注,识别,句法分析等,Python的,安装简单实用方便。 hanlp:用过这个的分词,其他功能没用过 bonsonlp:这个是一个专门做NLP的公司开发的收费平台,可以去官网体验一下,也有多个精度的分词,体验感觉还不错。
以上是nlp工具平台,下面是具有针对性的工具（都是python的）： word2vec:某大公司（我有些混淆了）开发的,利用已有语料库和深度学习进行训练,得到可以带有语意含义的词向量,效果不错,网络上有利用搜狗语料训练的博客,语料搜狗免费提供。得到词向量用处就大了,关键得训练的好。 gloven:好像是另一大公司针对上面公司的word2vec开发的,效果也相差不大,可以自己训练,亦可以下载该公司提供训练好的词向量,好像叫gloven100d什么的。 Gensim:是一个大型的python库,博主用它实现word2vec训练,其他功能没试过,好像功能挺强大的。 fasttext:脱胎于word2vec的算法的一个文本快速分类包,速度快,使用简单。 infersent:训练后,可以实现提取文本的关键词,但是博主多次怀疑是不是通过统计词频来识别的,哈哈。 grammer check：这个是用来检测英语语法错误的,这么说,检测出来的一定是有错的,检测不出来的不一定没错,可以用来过滤一部分数据。
听过没用过的： ICTCLAS：中科院的,也挺好 FudanNLP：复旦大学的 OpenNLP 庖丁解牛中文分词 盘古分词中文分词
下面几个博主也没用过,就放着了,大家可以自己去查查。 NaNLTK Apache OpenNLP Gate NLP library language tool Pattern TextBlob PyNLPI Polyglot MontyLingua BLLIP Parser Quepy MBSP SnowNLP thulac pynlpir
注：不管用什么工具进行分词,标注,识别,都会有误差,并且领域性越强,数据集越小,误差越明显,一方面可以多个工具结合使用,不同工具算法或语料不同,分词标注结果也不同,结合使用会有一定效果,再者自己添加自己领域内的词表补充完善,人工智能即先人工再智能。

「深度学习福利」大神带你进阶工程师,立即查看>>>
在上篇文章中,我们已经把AI的基础环境搭建好了（见文章： Ubuntu + conda + tensorflow + GPU + pycharm搭建AI基础环境 ）,接下来将基于tensorflow训练第一个AI模型： MNIST手写数字识别模型 。
MNIST是一个经典的手写数字数据集,来自美国国家标准与技术研究所,由不同人手写的0至9的数字构成,由60000个训练样本集和10000个测试样本集构成,每个样本的尺寸为28x28,以二进制格式存储,如下图所示：

MNIST手写数字识别模型的主要任务是： 输入一张手写数字的图像,然后识别图像中手写的是哪个数字。
该模型的目标明确、任务简单,数据集规范、统一,数据量大小适中,在普通的PC电脑上都能训练和识别,堪称是深度学习领域的“Hello World!”,学习AI的入门必备模型。
0、AI建模主要步骤
在构建AI模型时,一般有以下主要步骤：准备数据、数据预处理、划分数据集、配置模型、训练模型、评估优化、模型应用,如下图所示：

下面将按照主要步骤进行介绍。
【注意】 由于MNIST数据集太经典了,很多深度学习书籍在介绍该入门模型案例时,基本上就是直接下载获取数据,然后就进行模型训练,最后得出一个准确率出来。但这样的入门案例学习后,当要拿自己的数据来训练模型,却往往不知该如何处理数据、如何训练、如何应用。在本文,将分两种情况进行介绍：（1）使用MNIST数据（本案例）,（2）使用自己的数据。
下面将针对模型训练的各个主要环节进行介绍,便于读者快速迁移去训练自己的数据模型。
1、准确数据
准备数据是训练模型的第一步,基础数据可以是网上公开的数据集,也可以是自己的数据集。视觉、语音、语言等各种类型的数据在网上都能找到相应的数据集。
（1）使用MNIST数据（本案例）
MNIST数据集由于非常经典,已集成在tensorflow里面,可以直接加载使用,也可以从MNIST的官网上（http://yann.lecun.com/exdb/mnist/） 直接下载数据集,代码如下： from tensorflow.examples.tutorials.mnist import input_data # 数据集路径 data_dir='/home/roger/data/work/tensorflow/data/mnist' # 自动下载 MNIST 数据集 mnist = input_data.read_data_sets(data_dir, one_hot=True) # 如果自动下载失败,则手工从官网上下载 MNIST 数据集,然后进行加载 # 下载地址 http://yann.lecun.com/exdb/mnist/ #mnist=input_data.read_data_sets(data_dir,one_hot=True)
集成或下载的MNIST数据集已经是打好标签了,直接使用就行。
（2）使用自己的数据
如果是使用自己的数据集,在准备数据时的重要工作是“标注数据”,也就是对数据进行打标签,主要的标注方式有：
① 整个文件打标签。例如MNIST数据集,每个图像只有1个数字,可以从0至9建10个文件夹,里面放相应数字的图像；也可以定义一个规则对图像进行命名,如按标签+序号命名；还可以在数据库里面创建一张对应表,存储文件名与标签之间的关联关系。如下图：

② 圈定区域打标签。例如ImageNet的物体识别数据集,由于每张图片上有各种物体,这些物体位于不同位置,因此需要圈定某个区域进行标注,目前比较流行的是VOC2007、VOC2012数据格式,这是使用xml文件保存图片中某个物体的名称（name）和位置信息（xmin,ymin,xmax,ymax）。
如果图片很多,一张一张去计算位置信息,然后编写xml文件,实在是太耗时耗力了。所幸,有一位大神开源了一个数据标注工具labelImg（https://github.com/tzutalin/labelImg）,只要在界面上画框标注,就能自动生成VOC格式的xml文件了,非常方便,如下图所示：

③ 数据截段打标签。针对语音识别、文字识别等,有些是将数据截成一段一段的语音或句子,然后在另外的文件中记录对应的标签信息。
2、数据预处理
在准备好基础数据之后,需要根据模型需要对基础数据进行相应的预处理。
（1）使用MNIST数据（本案例）
由于MNIST数据集的尺寸统一,只有黑白两种像素,无须再进行额外的预处理,直接拿来建模型就行。
（2）使用自己的数据
而如果是要训练自己的数据,根据模型需要一般要进行以下预处理：

a. 统一格式： 即统一基础数据的格式,例如图像数据集,则全部统一为jpg格式；语音数据集,则全部统一为wav格式；文字数据集,则全部统一为UTF-8的纯文本格式等,方便模型的处理；
b. 调整尺寸： 根据模型的输入要求,将样本数据全部调整为统一尺寸。例如LeNet模型是32x32,AlexNet是224x224,VGG是224x224等；
c. 灰度化： 根据模型需要,有些要求输入灰度图像,有些要求输入RGB彩色图像；
d. 去噪平滑： 为提升输入图像的质量,对图像进行去噪平滑处理,可使用中值滤波器、高斯滤波器等进行图像的去噪处理。如果训练数据集的图像质量很好了,则无须作去噪处理；
e. 其它处理： 根据模型需要进行直方图均衡化、二值化、腐蚀、膨胀等相关的处理；
f. 样本增强： 有一种观点认为神经网络是靠数据喂出来的,如果能够增加训练数据的样本量,提供海量数据进行训练,则能够有效提升算法的质量。常见的样本增强方式有：水平翻转图像、随机裁剪、平移变换,颜色、光照变换等,如下图所示：
3、划分数据集
在训练模型之前,需要将样本数据划分为训练集、测试集,有些情况下还会划分为训练集、测试集、验证集。
（1）使用MNIST数据（本案例）
本案例要训练模型的MNIST数据集,已经提供了训练集、测试集,代码如下： # 提取训练集、测试集 train_xdata = mnist.train.images test_xdata = mnist.test.images # 提取标签数据 train_labels = mnist.train.labels test_labels = mnist.test.labels
（2）使用自己的数据
如果是要划分自己的数据集,可使用scikit-learn工具进行划分,代码如下： from sklearn.cross_validation import train_test_split # 随机选取75%的数据作为训练样本,其余25%的数据作为测试样本 # X_data：数据集 # y_labels：数据集对应的标签 X_train,X_test,y_train,y_test=train_test_split(X_data,y_labels,test_size=0.25,random_state=33)
4、配置模型
接下来是选择模型、配置模型参数,建议先阅读深度学习经典模型的文章（见文章： 大话卷积神经网络模型 ）,便于快速掌握深度学习模型的相关知识。
（1）选择模型
本案例将采用LeNet模型来训练MNIST手写数字模型,LeNet是一个经典卷积神经网络模型,结构简单,针对MNIST这种简单的数据集可达到比较好的效果,LeNet模型的原理介绍请见文章（ 大话CNN经典模型：LeNet ）,网络结构图如下：

（2）设置参数
在训练模型时,一般要设置的参数有： step_cnt=10000 # 训练模型的迭代步数 batch_size = 100 # 每次迭代批量取样本数据的量 learning_rate = 0.001 # 学习率
除此之外还有卷积层权重和偏置、池化层权重、全联接层权重和偏置、优化函数等等,根据模型需要进行设置。
5、训练模型
接下来便是根据选择好的模型,构建网络,然后开始训练。
（1）构建模型
本案例按照LeNet的网络模型结构,构建网络模型,网络结果如下

代码如下： # 训练数据,占位符 x = tf.placeholder("float", shape=[None, 784]) # 训练的标签数据,占位符 y_ = tf.placeholder("float", shape=[None, 10]) # 将样本数据转为28x28 x_image = tf.reshape(x, [-1, 28, 28, 1]) # 保留概率,用于 dropout 层 keep_prob = tf.placeholder(tf.float32) # 第一层：卷积层 # 卷积核尺寸为5x5,通道数为1,深度为32,移动步长为1,采用ReLU激励函数 conv1_weights = tf.get_variable("conv1_weights", [5, 5, 1, 32], initializer=tf.truncated_normal_initializer(stddev=0.1)) conv1_biases = tf.get_variable("conv1_biases", [32], initializer=tf.constant_initializer(0.0)) conv1 = tf.nn.conv2d(x_image, conv1_weights, strides=[1, 1, 1, 1], padding='SAME') relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_biases)) # 第二层：最大池化层 # 池化核的尺寸为2x2,移动步长为2,使用全0填充 pool1 = tf.nn.max_pool(relu1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') # 第三层：卷积层 # 卷积核尺寸为5x5,通道数为32,深度为64,移动步长为1,采用ReLU激励函数 conv2_weights = tf.get_variable("conv2_weights", [5, 5, 32, 64], initializer=tf.truncated_normal_initializer(stddev=0.1)) conv2_biases = tf.get_variable("conv2_biases", [64], initializer=tf.constant_initializer(0.0)) conv2 = tf.nn.conv2d(pool1, conv2_weights, strides=[1, 1, 1, 1], padding='SAME') relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_biases)) # 第四层：最大池化层 # 池化核尺寸为2x2, 移动步长为2,使用全0填充 pool2 = tf.nn.max_pool(relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') # 第五层：全连接层 fc1_weights = tf.get_variable("fc1_weights", [7 * 7 * 64, 1024], initializer=tf.truncated_normal_initializer(stddev=0.1)) fc1_baises = tf.get_variable("fc1_baises", [1024], initializer=tf.constant_initializer(0.1)) pool2_vector = tf.reshape(pool2, [-1, 7 * 7 * 64]) fc1 = tf.nn.relu(tf.matmul(pool2_vector, fc1_weights) + fc1_baises) # Dropout层（即按keep_prob的概率保留数据,其它丢弃）,以防止过拟合 fc1_dropout = tf.nn.dropout(fc1, keep_prob) # 第六层：全连接层 fc2_weights = tf.get_variable("fc2_weights", [1024, 10], initializer=tf.truncated_normal_initializer(stddev=0.1)) # 神经元节点数1024, 分类节点10 fc2_biases = tf.get_variable("fc2_biases", [10], initializer=tf.constant_initializer(0.1)) fc2 = tf.matmul(fc1_dropout, fc2_weights) + fc2_biases # 第七层：输出层 y_conv = tf.nn.softmax(fc2)
（2）训练模型
在训练模型时,需要选择优化器,也就是说要告诉模型以什么策略来提升模型的准确率,一般是选择交叉熵损失函数,然后使用优化器在反向传播时最小化损失函数,从而使模型的质量在不断迭代中逐步提升。
代码如下： # 定义交叉熵损失函数 # y_ 为真实标签 cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_conv), reduction_indices=[1])) # 选择优化器,使优化器最小化损失函数 train_step = tf.train.AdamOptimizer(learning_rate).minimize(cross_entropy) # 返回模型预测的最大概率的结果,并与真实值作比较 correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) # 用平均值来统计测试准确率 accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # 训练模型 saver=tf.train.Saver() with tf.Session() as sess: tf.global_variables_initializer().run() for step in range(step_cnt): batch = mnist.train.next_batch(batch_size) if step % 100 == 0: # 每迭代100步进行一次评估,输出结果,保存模型,便于及时了解模型训练进展 train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1], keep_prob: 1.0}) print("step %d, training accuracy %g" % (step, train_accuracy)) saver.save(sess,model_dir+'/my_mnist_model.ctpk',global_step=step) train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.8}) # 使用测试数据测试准确率 print("test accuracy %g" % accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
训练的结果如下,由于MNIST数据集比较简单,模型训练很快就达到99%的准确率,如下图所示：

模型训练后保存的结果如下图所示：
6、评估优化
在使用训练数据完成模型的训练之后,再使用测试数据进行测试,了解模型的泛化能力,代码如下 # 使用测试数据测试准确率 test_acc=accuracy.eval(feed_dict={x: test_xdata, y_: test_labels, keep_prob: 1.0}) print("test accuracy %g" %test_acc)
模型测试结果如下：

7、模型应用
模型训练完成后,将模型保存起来,当要实际应用时,则通过加载模型,输入图像进行应用。代码如下： # 加载 MNIST 模型 saver = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, tf.train.latest_checkpoint(model_dir)) # 随机提取 MNIST 测试集的一个样本数据和标签 test_len=len(mnist.test.images) test_idx=random.randint(0,test_len-1) x_image=mnist.test.images[test_idx] y=np.argmax(mnist.test.labels[test_idx]) # 跑模型进行识别 y_conv = tf.argmax(y_conv,1) pred=sess.run(y_conv,feed_dict={x:[x_image], keep_prob: 1.0}) print('正确：',y,',预测：',pred[0])
使用模型进行测试的结果如下图：
至此,一个完整的模型训练和应用的过程就介绍完了。
接下来还会有更多AI实战的精彩内容,敬请期待！

获取完整源代码
想要阅读本案例的 完整代码,请关注本人公众号“大数据与人工智能Lab”（BigdataAILab）,然后回复“ 代码 ”关键字可查看 完整源代码 。


推荐相关阅读 【AI实战】快速掌握TensorFlow（一）：基本操作 【AI实战】快速掌握TensorFlow（二）：计算图、会话 【AI实战】快速掌握TensorFlow（三）：激励函数 【AI实战】快速掌握TensorFlow（四）：损失函数 【AI实战】搭建基础环境 【AI实战】训练第一个模型 【AI实战】编写人脸识别程序 【AI实战】动手训练目标检测模型（SSD篇） 【AI实战】动手训练目标检测模型（YOLO篇） 【精华整理】CNN进化史 大话卷积神经网络（CNN） 大话循环神经网络（RNN） 大话深度残差网络（DRN） 大话深度信念网络（DBN） 大话CNN经典模型：LeNet 大话CNN经典模型：AlexNet 大话CNN经典模型：VGGNet 大话CNN经典模型：GoogLeNet 大话目标检测经典模型：RCNN、Fast RCNN、Faster RCNN 大话目标检测经典模型：Mask R-CNN 27种深度学习经典模型 浅说“迁移学习” 什么是“强化学习” AlphaGo算法原理浅析 大数据究竟有多少个V Apache Hadoop 2.8 完全分布式集群搭建超详细教程 Apache Hive 2.1.1 安装配置超详细教程 Apache HBase 1.2.6 完全分布式集群搭建超详细教程 离线安装Cloudera Manager 5和CDH5（最新版5.13.0）超详细教程
关注本人公众号“大数据与人工智能Lab”（BigdataAILab）,获取更多信息 。

「深度学习福利」大神带你进阶工程师,立即查看>>>
人工智能的出现争议不仅仅是在编程领域,在别的领域也已经出现了很多讨论,包括很多工厂现在也在慢慢引入一些机器人,去做一些重复性很强,工作强度很大的工作,类似这种在人工智能出现之前已经有很多人去做了,这是科技进步的结果。
人工智能功能的实现很大一部分功能是程序员来实现,想让机器人完全取代程序员从理论上讲可能性不大,其实很多人在谈人工智能对人类产生的影响,其实有很多是内心产生的一种恐惧,人类社会从来都是适者生存,不想着进步带来的只能是恐惧。
可以可以想象的是工序比较简单的程序逻辑,人工智能会取代一部分,绝大部分还是需要靠人力完成,再厉害的人工智能想要完全吃透人类的组合思维,不是说做不到,代价太高。前一阵子阿尔法狗对阵人类棋手几乎很轻松的赢了比赛,与其说败给阿尔法狗,倒不如说败给了金钱,棋圣聂卫平还想着把阿尔法狗引入进来平时练习棋来用,每天的耗资上百万,根本不是常人玩的,完全的逻辑堆积运算,靠的是服务器堆,这只是围棋而已,换成程序员的思维要比这个组合以及种类复杂度高的多,所以现在能够运用的人工智能也仅仅是优先罗列的办法,距离真正的人工智能还是差得远。
前阵子和一个做人工智能的同事讨论,他们公司的ai机器人在外边宣传的多厉害,结果这哥们说了句,机器人里面就是装了个ipad,其余的就是简单组合下,现在绝大部分的人工智能产品夸张多些,宣传造势的多一些。就程序员本身而言,人工智能不但不会让程序员下岗还会增强程序员的重要性,绝大部分功能还是需要程序员来维护,但是对于程序员的要求要比传统的程序员要高一些,人工智能是几十年积累的大汇总,要集成度有集成度,要深度有深度。

「深度学习福利」大神带你进阶工程师,立即查看>>>
为方便日常的深度学习模型开发与测试,在自己笔记本上搭建一个深度学习的基础环境,便于学习AI使用。本人使用的笔记本配置是CPU为8代i5,显卡为GTX1060,内存为8G,基本上可满足日常的AI研究与学习。下面将介绍基础环境的搭建配置过程：
1、安装Ubuntu 18.04


（1）安装操作系统
从Ubuntu官网上下载最新的Ubuntu 18.04 LTS版本的IOS文件,然后使用Image Writer等工具,将IOS文件写入到U盘里面。
重启电脑,在BIOS里面设置第一启动顺序为U盘,保存启动,进入到Ubuntu操作系统的安装界面,按照操作指引一步一步进行安装,安装过程比较简单,在此就不再赘述。
注意：由于本人笔记本上的内存并不大（只有8G）,为了满足后续的模型训练需要,在安装操作系统时,将交换区设置得大一些,例如8G或16G,以防模型训练时读取大量样本导致内存溢出。当然,能加内存条那就更好,土豪请随意。
（2）安装显卡驱动
安装Ubuntu后默认安装的是开源版本的显卡驱动,为了后续能够在使用tensorflow-gpu时能更好地发挥GPU的性能,推荐安装NVIDIA官方版本的驱动。
在Ubuntu里面,打开“软件和更新”,点击里面的“附加驱动”标签页,选择使用NVIDIA driver,然后点击“应用更改”进行官方驱动的安装,安装后重启电脑即可。

重启电脑后,只要在电脑的设备信息里面看到“图形”是显示了GTX 1060,则说明NVIDIA官方显卡驱动安装成功了。

【注意】 在安装NVIDIA的官方驱动时,最初是在官网上下载Cuda、Cudnn安装文件手动进行安装,安装成功了,但却无法加载驱动。后来通过在Ubuntu的“软件和更新”安装官方驱动,才顺利解决,而且安装也方便。
2、安装Anaconda
由于后续在使用tensorflow建模时主要使用Python语言,因此,在这里选用了当前非常流行的Python发行版本：Anaconda。Anaconda集成了大量的科学计算包,能根据需要自动下载安装软件包和相应的依赖包（p.s.这也是比pip先进之处,pip无法管理依赖包的问题）。另外,使用Anaconda还能创建虚拟环境,这样就能很方便地在同个电脑上使用Python 2.x、Python 3.x,tensorflow-cpu、tensorflow-gpu,相互之间不受影响,非常方便。


（1）下载

从Anaconda官网（https://www.continuum.io/downloads）上下载安装包,选择Linux系统,安装基于Python 3.6版本
（2）安装

对下载的文件授予可执行权限,然后进行安装 bash Anaconda3-5.2.0-Linux-x86_64.sh
当询问是否把Anaconda的bin添加到用户的环境变量中,选择yes
（3）创建虚拟环境
使用conda create命令创建虚拟环境到指定路径,并指定Python版本,同时可以将需要一起安装的包也一起指定。下面创建一个名为tensorflow的虚拟环境,指定使用Python 3.6版本,并在虚拟环境中安装numpy、scipy、matplotlib、jupyter等软件包,命令如下： conda create –n tensorflow python=3.6 numpy scipy matplotlib jupyter
其中-n指定虚拟环境的名称
默认安装的路径位于anaconda安装目录下的envs文件夹里面,也可以使用—prefix参数来重新指定虚拟环境路径
如果要创建第二个虚拟环境,只需使用不同的名称即可,如果创建一个名为tensorflow2,指定使用Python 2.7版本,则命令如下： conda create –n tensorflow2 python=2.7
如果要查看有哪些虚拟环境,则执行以下命令： conda info -envis
【注意】 如果在创建conda虚拟环境时没有指定python的版本,则默认是使用anaconda安装目录下bin中的python版本。为了实现虚拟环境的隔离,必须指定python版本
（4）配置conda国内镜像源
为了提升conda的安装软件包时的下载速度,建议对conda配置国内的镜像源（清华大学conda镜像源）,配置方式如下： conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/ conda config --set show_channel_urls yes
如果要切回默认源,则执行 conda config –remove-key channels
【注意】 网上很多配置conda国内镜像源的教程都只写着只配置清华大学conda的free镜像（https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/）,但该源的很多软件包并不是最新版本,为了能更新最新版本,再指定一个清华大学conda的main镜像（https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/）,这样就能安装、更新最新版本的软件了。
（5）激活虚拟环境
创建好conda虚拟环境后,在使用之前必须先进行激活。下面激活刚创建的tensorflow虚拟环境,命令如下： conda source activate tensorflow
如果要注销退出当前的虚拟环境,则执行命令： conda source deactivate tensorflow
非常方便

3、安装tensorflow-gpu

为了提升AI模型的训练效率,安装使用tensorflow-gpu进行模型训练。
激活进入刚才创建的tensorflow的conda虚拟环境 conda source activate tensorflow
然后使用以下命令安装tensorflow-gpu conda install tensorflow-gpu
conda将会检测tensorflow-gpu的最新版本以及相关的依赖包,包括调用NVIDIA显卡所需要的Cuda、Cudnn等依赖环境,都会自动按顺序进行安装,非常方便吧。
如果需要升级tensorflow-gpu的版本,则执行以下命令进行更新 conda upgrade tensorflow-gpu
注意：并不是所有软件包都能直接安装,有一些需要指定安装源,例如做AI中经常会用到的OpenCV便是无法直接安装的,需要指定安装源,命令如下： conda install --channel https://conda.anaconda.org/menpo opencv3

4、安装PyCharm

PyCharm是一个优秀的Python开发IDE环境,特别是还提供了社区版可以免费使用,业界良心啊！
（1）安装PyCharm
在Ubuntu里面安装PyCharm非常简单,在Ubuntu软件商城里面搜索“pycharm”,然后选择社区版“PyCharm CE”进行安装即可,非常方便。


（2）在PyCharm中使用conda虚拟环境
为了能够在PyCharm中使用我们自己创建的conda虚拟环境,需要进行下配置。在Pycharm的Files>>settings>>Project Interpreter>>Add local 里面添加刚才创建的conda虚拟环境的目录下所在的Python 3.6程序,应用之后就可以使用我们自己使用的虚拟环境了,如下图所示：
至此,“AI实战”的基础环境搭建就已全部配置完成了。
后面将陆续推出更多AI实战内容,敬请留意。

推荐相关阅读 【AI实战】快速掌握TensorFlow（一）：基本操作 【AI实战】快速掌握TensorFlow（二）：计算图、会话 【AI实战】快速掌握TensorFlow（三）：激励函数 【AI实战】快速掌握TensorFlow（四）：损失函数 【AI实战】搭建基础环境 【AI实战】训练第一个模型 【AI实战】编写人脸识别程序 【AI实战】动手训练目标检测模型（SSD篇） 【AI实战】动手训练目标检测模型（YOLO篇） 【精华整理】CNN进化史 大话卷积神经网络（CNN） 大话循环神经网络（RNN） 大话深度残差网络（DRN） 大话深度信念网络（DBN） 大话CNN经典模型：LeNet 大话CNN经典模型：AlexNet 大话CNN经典模型：VGGNet 大话CNN经典模型：GoogLeNet 大话目标检测经典模型：RCNN、Fast RCNN、Faster RCNN 大话目标检测经典模型：Mask R-CNN 27种深度学习经典模型 浅说“迁移学习” 什么是“强化学习” AlphaGo算法原理浅析 大数据究竟有多少个V Apache Hadoop 2.8 完全分布式集群搭建超详细教程 Apache Hive 2.1.1 安装配置超详细教程 Apache HBase 1.2.6 完全分布式集群搭建超详细教程 离线安装Cloudera Manager 5和CDH5（最新版5.13.0）超详细教程

欢迎关注本人的微信公众号“大数据与人工智能Lab”（BigdataAILab）,获取更多信息

「深度学习福利」大神带你进阶工程师,立即查看>>>
深度学习发展迅速,每天都会冒出不少新的神经网络架构,对于从事AI的专业人士而言,要全面追踪、了解这些新的架构非常费力。
ASIMOV Institute绘制当前所流行的27张神经网络节点图,方便查阅和收藏,如下：
欢迎关注本人的微信公众号“大数据与人工智能Lab”（BigdataAILab）,获取更多信息

「深度学习福利」大神带你进阶工程师,立即查看>>>
2017年
12月20日
国家会议中心
云栖大会·北京峰会
年度最后一场技术大狂欢
我有几张阿里云幸运券分享给你,用券购买或者升级阿里云相应产品会有特惠惊喜哦！把想要买的产品的幸运券都领走吧！快下手,马上就要抢光了。

「深度学习福利」大神带你进阶工程师,立即查看>>>
【卷首语】
　　先有产品还是先有新闻稿？
　　在绝大多数人看来,这个问题的标准答案是再明显不过的：当然是先有产品！在通常情况下, 新闻稿作为产品的官方诠释和宣传材料,必然是在产品开发完成、交付上市之后才能开始撰写,但在“逆向工作法（Working Backwards）”的支持者们看来,先有产品再有新闻稿的顺序,“可以改一改”。
　　亚马逊CTO Werner Vogels就是“逆向工作法”的支持者之一,他与很多支持“先有新闻稿再有产品”的人一样,认为新的工作顺序应当是：首先有新闻稿,以简明扼要的方式描述将要开发的产品的功能、特点、优势和作用,以及“为什么它会存在和应当被开发”,找到产品明确的重点和“开发终点”,以此确定将为什么样的未来,交付什么样的产品。
　　换句话说：它该是什么样子,世界需要它是什么样子,未来会是什么样子,才应该做什么样子。
　　“逆向工作法”的实质就是一种“终局思维”,或者说是“未来思维”：在这种思维方式下,产品的设计者跳脱当前现实需求和短期思维的桎梏,从产品的“终局”（它未来应有的功能和形态）出发,设计出更加满足用户需求的产品。
　　事实上,不止是产品,在整个产业发展上,“未来思维”都是一个至关重要,甚至决定成败的能力：从整个产业的未来趋势、发展方向,乃至（阶段性的）“产业终局”入手,推倒出当下现实中应当开展的工作、应付的努力,依靠“未来思维”突破各种所谓的“客观因素的限制”,做出具有想象力的、正确的,而不是“当下合适”或是“看着还不错”的决定,最终设计出符合未来和终局的业务策略和商业决策。

「深度学习福利」大神带你进阶工程师,立即查看>>>
程序员爱脱发,是不争的事实,经常面对电脑,工作压力大,都会导致脱发的产生。正所谓“聪明绝顶”,越厉害的程序员,谢顶的可能性就越大。那么,我们看看世界上顶级的程序员们,看看是否能从中找到规律。

这位大牛,很多人都认识,C语言之父——丹尼斯·里奇。里奇的C语言,养活了世界上成千上万的程序员,可能是对人类做出的贡献太大了,2011年,在乔布斯去世一个礼拜后,上帝带走了他。
里奇的脱发等级在2级到3级之间,发际线比较高,额头也比较大,但头顶部位还是比较浓密的。C语言算不上特别难,看来齐大爷保养的也是非常的棒。
多少程序员要感谢里奇赏了你们饭碗了。

在TIOBE编程语言排行榜上,有这么一门语言,霸占排行榜榜首多年,这门计算机语言,就是Java,詹姆斯·高斯林在1990和他人一起创造了Java,因此他被称为Java之父。
高斯林的脱发等级已经达到了6级,前额部位基本脱落,头顶部位向后扩散,中间仅剩下隔离狭窄的毛发带了。不得不说高斯林是劳心劳力的,Java多么伟大的语言,想要搞定它,还真得多费工夫。

作为Java的兄弟语言,C++同样非常热门,开发游戏、科学计算、网络软件、分布式应用等等,都离不开C++语言。上图就是C++的发明者——本贾尼·斯特劳斯特卢普。
令人惊奇的是,本贾尼的脱发等级,也达到了6级左右。另外,本贾尼的发型和高斯林好像,不愧是兄弟语言。这两位技术大牛,养活的程序员,占了技术界的半壁江山,都是助祖师爷级别的人物啊。

PHP之父——拉斯马斯·勒德尔夫,在1995年,他公布了PHP1.0版本,成功吸粉无数,如今,越来越多的网站使用PHP语言,而在中国,绝大部分网站都采用了这一门语言,作为后端开发语言。
勒德尔夫的脱发等级达到了4级,算不上特别,但他还“年轻”,至今50岁左右,还很有发展前途。PHP,作为较为简单的计算机入门语言,养活了无数的转行者。当然,这也导致了基层程序员过多的尴尬。

这家伙是程序员吗？是的,人工智能所使用的编程语言,就是他发明的。Python作为一门非常接近自然语言的计算机语言,受到了广大编程爱好者的喜欢。Python是发展潜力最大的语言,没有之一。
吉多·范罗苏姆作为Python的创始人,脱发等级很低,除了发际线高点之外,毫无缺点。难道这是Python很简单的缘故？要养生,还得靠Python？当然不是,也许人家就没有秃顶的基因呢？
相比于专职于技术领域的大牛们,有相当多的程序员,转行成为了产品经理,或者CEO,那么他们的秃顶等级如何呢？

脸书创始人扎克伯格,在2004年结用了一个星期左右的时间,创建了Facebook,到最后基本已经脱离了技术岗位,成了彻彻底底的CEO。从含发量上看,扎克伯格好像还是发际线高一些,没多大变化。

我们再来看看国内,马化腾应该可以说是技术界的成功代表之一,早些年写了QQ,后来专职于在公司里,经常扮演者产品经理的角色,还是中年人的老毛病,除了发际线高些,没多大的区别。
于是,得出一个结论：要么你就学Python,要么干脆转行得了,否则你的头发……
以上结论,仅想博君一笑,请勿对号入座,程序员和秃顶,并没有绝对的关系,现实是,很多程序员不仅用哟偶乌黑浓密的头发,而且颜值也高。
>>>>阅读全文

「深度学习福利」大神带你进阶工程师,立即查看>>>
转自： 第一次参加Kaggle拿银总结
作者： ScarletPan
我的比赛代码已经放到github --> Kaggle-Rental-Listing-Inquireies
在这篇博客开始之前,我必须感谢导师给我提供服务器资源, @Fenix Lin学长从他自身经验出发耐心地为我解答一些困惑,素未谋面的 @Wille 学长的一篇非常优秀的博文如何在 Kaggle 首战中进入前 10% 帮助入门,以及广大Kaggler的无私分享,我确实在Kaggle举行的这场 Rental Listing Inquiries 比赛中收益良多,获得了不少知识。作为第一次参加比赛,获得了Top 5%的成绩已经让我非常满意了。
这篇文章的目的是介绍自己第一次参加Kaggle的心历路程,总结遇到的问题和解决思路,为自己以后参赛做准备。同时这篇文章也可以作为一个初学者的入门Kaggle的参考,如果想要在入门kaggle的时候拿到一个好的名次,可以参考我的一些方法实践。本文可以随意转载,但务必注明出处和作者, 并且发邮件myscarlet@sina.com通知与我。
初识Kaggle
什么是Kaggle
从刚接触machine learning的时候就有在学长口中、博文中、社区中听到过它的名字,当初我对它的理解还比较浮浅,只是知道是一个数据比赛的平台,有很多公开的数据集,比如大二寒假做的第一个ML练手项目就是一个用word2vec进行情感分析的Tutorial级比赛 Bag of Words Meets Bags of Popcorn ,并且写了一个 Research report 。这过程中只用到了教程和数据集。
后来重新接触Kaggle才发现,它的价值所在是各种高质量的比赛,以及每场比赛下面的社区讨论（包括比赛中的分享、答疑,和比赛后的top solution分享）,因此如果想要获得关于数据挖掘,机器学习实战经验的话,打一场kaggle比赛绝对是一个高回报的工作。
因为还是学生,不知道kaggle比赛究竟是否会为自己求职工作有举足轻重的影响,但是单从Kaggle被google收购一点来看,它会在行业内一点点提升影响力的。
比赛组织
一场比赛通常持续2～3个月,在比赛的简介中会有规则、评价指标（比如这场比赛为mlogloss）,时间轴等信息。另外还有数据区、Kernel区（一些Kagglers在kaggle上成功运行的ipython notebook或者代码）,Discussion（讨论区）,LeaderBoard（LB,分为公开的用户提交可以显示结果的榜单,和非公开的比赛结束后确定最终排名的榜单）,当然还有提交区（一般为一定格式的csv文件提交）。
另外就是奖牌问题,一般来讲在1000+量级的比赛中,top 10+ 0.2%为金牌,5%为银牌,10%为铜牌, 这里 有更具体的奖牌发放方式。
讨论区
个人认为,如果想在入门Kaggle阶段就获得一个好的成绩的话,关注discussion是非常重要的,会有很多人分享自己的思路、困惑甚至代码和结果。有时候,一场比赛中比较关键的feature可能就是从讨论区中获得的,比如 Two Sigma Connect: Rental Listing Inquiries 这场比赛的最后几天,我以为自己特征提取得已经差不多了,没有任何idea了的时候,一个来自讨论区magic feature从天而降,从而使得榜单大变,一夜之间我的排名从70多掉到了120多。
数据探索和可视化（EDA）
首先拿到一个比赛题目,你需要下决心是否参加这个比赛,对我个人而言最重要的无非两点 1. 是不是有rank point,也就是奖牌, 2. 数据集是否令我满意。 因此对数据的探索首先需要你从Kaggle网站上查看数据的简介,并把数据下载下来。比如Rental Listing Inquiries包含了80G的图片数据,和几份json文件。
我们将下载下来的train.csv用python pandas 打开,取少量样本进行观测

1 import pandas as pd
2 train = pd.read_json("input/train.json")
3 train.sample(2)
抛开图片数据不谈,我们可以看到给定的数据里包含多种多样的feature： 数值型feature bathrooms bedrooms price 高势集类别（High Categorical）型feature building_id display_address manager_id street_address 时间型feature created 地理位置型feature longitude latitude 文本feature description 稀疏特征集feature features id型feature listing_id index
我们看到有这么多不同的feature,一看几乎每个feature都有深度挖掘的价值,何况还有80G的图片feature,无疑是让人兴奋的,因此我选择了这个比赛,因为它的数据集的确让我舒心。
另外一定要搞明白的一件事是这场比赛是一个预测比赛还是分类比赛,我们能看到最重要预测的是用户的interest_level,分为low,medium,high三级,很显然是个分类问题了。
接下来的是就是对数据进行可视化探索了,我因为是初期参赛的,所以自己做了一份可视化方案,从中可以发现很多有趣的分布、outlier等。在这里推荐三份在比赛中分享出来的比较好的EDA： Simple Exploration Notebook Two Sigma RentHop EDA Data Exploration Two Sigma Renthop
提取基础特征+模型训练
有了之前数据探索的基础,我们很快能提取到一些基础的feature,比如数值型feature进行简单的加减乘除,类别型feature用id顺序编码,稀疏特征集用one-hot编码,时间特征生成年、月、日等。将一些基础的特征转换成相应的输入input_X矩阵后,再将label也转换成数值形式：

1 target_num_map = {'high':0, 'medium':1, 'low':2}
2 ​
3 y = data["interest_level"].apply(lambda x: target_num_map[x])
懂机器学习的人都知道,有了这些(X,y)对,我们就可以进行模型训练了。
我们用cross-validation（CV）的成绩来判断我们本地的实验结果,也就是将（X,y）训练集拆分成训练和验证集,训练相应分类器对训练集拟合,再在验证集上进行loss的计算来评估模型的好坏。
常见的分类器有Logistic Classifier,SVM, NN softmax,Random Forest等。但是在kaggle上用的比较多的还是一些封装好的库,如sklearn里的各种分类器,大名鼎鼎的xgboost,最近崭露头角的lightgbm等。
早就听闻xgboost的好用,我就直接在电脑上pip了xgboost,作为我接下来一两个月以来的核心分类器。将原先的（X,y）对中的训练部分输入xgboost进行fit,然后用验证部分predict计算mlogloss。
至此为止,比赛初期的第一个模型就已经训练好了。
跑出一个能提交的结果
训练完一个比较好的模型之后,就可以对测试集进行预测了,首先将训练集（X,y）对输入xgboost中重新训练,然后对测试集也像对训练集一样进行特征处理,预测出来的结果按照比赛指定的格式保存到文件（在这里还是建议用pandas）,即可提交。
第一次提交意味着你正式进入比赛,提交的结果会在Leader Board上显示你当前的排名,当然这个排名只起到参考作用,因为你提交上去的大部分结果kaggle都没有进行评估。
特征工程（FE）
在一系列的初始操作以后,你就要踏上FE的漫漫长征了。本人断断续续在数据清洗、特征提取上做了约两个多月,在比赛最后一段时间模型融合完毕后还在继续地寻找、测试新的特征。后期评论区中magic feature的出现,让每个人的预测结果好了0.01～0.02个点。不得不说,特征工程才是Kaggle比赛获胜的关键所在,因此初学者耗费大量精力在这上面是没错的。而本博文也是重点想讲一下自己发现新特征的一些心历路程。
在对一些基础的特征进行生成之后,我开始了漫长地测试特征的长征路,测试的思路我后来发现并不是很好,因为是通过新增加一个或几个feature,如果cv分数上去了,就增加这个feature,如果cv分数没有上去,就舍弃这个feature,也就是相当于贪心验证。这样做的弊处在于,如果之前被舍弃的feature和之后被舍弃的feature联合在一起才会有正面影响,就相当于你错过了两个比较好的feature。因此特征的选择和联合显得非常关键。
在比赛阶段,花费大量力气去创建一个feature,到头来却选择放弃这个feature的事情很常见,我后期的特征有很多是新添加的,旧有的一些特征并没有保留。接下来就让我总结一下这场比赛中有哪些“好”的feature,为以后的比赛提供灵感和经验。 数值型feature的简单加减乘除
这个乍一看仿佛没有道理可言,但是事实上却能挖掘出几个feature之间的内在联系,比如这场比赛中提供了bathrooms和bedrooms的数量,以及价格price,合租用户可能会更关心每个卧室的价格,即bathrooms / price,也会关心是不是每个房间都会有一个卫生间bathrooms / price ,这些数值型feature之间通过算数的手段建立了联系,从而挖掘出了feature内部的一些价值,分数也就相应地上去了。 高势集类别（High Categorical）进行经验贝叶斯转换成数值feature
什么是High Categorical的特征呢？一个简单的例子就是邮编,有100个城市就会有好几百个邮编,有些房子坐落在同一个邮编下面。很显然随着邮编的数量增多,如果用简单的one-hot编码显然效果不太好,因此有人就用一些统计学思想（经验贝叶斯）将这些类别数据进行一个map,得到的结果是数值数据。在这场比赛中有人分享了一篇paper里面就提到了具体的算法。详细就不仔细讲了,用了这个encoding之后,的确效果提升了很多。那么这场比赛中哪些数据可以进行这样的encoding呢,只要满足下面几点：1. 会重复,2. 根据相同的值分组会分出超过一定数量（比如100）的组。也就是说building_id, manager_id, street_address, display_address都能进行这样的encoding,而取舍就由最后的实验来决定了。 时间特征
针对于时间数据来讲,提取年、月、日、星期等可能还是不够的,有另外一些points可以去思考,用户的兴趣跟发布时间的久远是否有关系？可以构造如下的feature来进行测试：

1 data["latest"] = (data["created"]- data["created"].min())
2 ​
3 data["passed"] = (data["created"].max()- data["created"])
可以看到latest指的是从有数据开始到该房创建为止一共过去了多少时间,而passed则是该房记录创建为止到最后有记录的时候一共过去了多少时间。
另外针对于时间特征还可以用可视化的方式来与其他特征建立联系,比如我们观察listing_id与时间变化到底有怎样的联系,能够绘制出如下的图来：
可能简单的相除就能获得很好的结果 地理位置特征
想到地理位置,就会想到聚类,一个简单的方式将每个房子划分到同一块区域中去；除了聚类以外,算出几个中心点坐标,计算曼哈顿距离或者欧式距离可能都会有神奇的效果。 文本特征
实话说自己是看中这次比赛中有文本数据才参加的,因此在文本挖掘中做了很大的努力,比如提取关键词、情感分析、word embedding聚类之类都尝试过,但效果都不是很好, 对于文本的特征的建议还是去找出一些除了停用词以外的高频词汇,寻找与这个房屋分类问题的具体联系。 图片特征
除了最后爆料出来的magic feature(后文会提到)以外,我只用了一个房子有几个照片这个信息。讨论区中都说对于图片特征用CNN提取、简单特征提取之类的效果都不是很好。 稀疏特征集
其实就相当于一系列标签,不同标签的个数也是挺多的,本次比赛我只是简单地采用了counterEncoding的方式进行one-hot编码。值得一提的是,有些标签是可以合并的,比如cat allowed 和 dog allowed可以合并成为 pet allowed,我在这场比赛中手工地合并了一些feature数据,最终结果略微有所提升。 特征重要程度（feature importance）
在树结构的分类器比如randomforest、xgboost中最后能够对每个特征在分类上面的重要程度进行一个评估。这时候如果已经选定了一些feature进行训练了之后,查看feature importance的反馈是非常重要的,比如本场比赛制胜的关键是运用manager_id这个feature,而它的feature importance反馈结果也是非常高。通过对重要特征的重新再提取特征,能够发现很多有意思的新特征,这才是用FE打好一场比赛的关键所在。
下面列出了一些比赛结束后获胜者分享的idea,这大概是我这场比赛中获益最大的一块地方了。 Top #1 solution @plantsgo
主要是针对manager_id生成了非常多的feature。如根据不同时间出现的manager_id判断一个manager是否活跃（manager与time进行group,manager掌管有几个不同的房子（manager与building_id进行group）、平均每天处理多少房子（比值）、活动范围（同个manager掌管的房子的最大最小经纬度group）,经理的开价程度（选择bedroom和bathroom作为房子型号指标,把相同房型的均价来衡量经理对于所有房子的开价程度）,对经纬度进行聚类再计算每个区域中有多少个manager竞争、一个manager同时经营几个区域、在同个区域中manager的开价水平等。从Top 1选手分享的代码来看,其对于manager的各种处理的确是让人大开眼界。 Top #2 solution @Faron
从更为经验老道的选手给出了一些特征提取建议。其中有一类被作者称为"Likelihood Features",他对High Cardinal Categorical的特征用了一些额外的条件概率来计算其似然值,如p(y|manager_id, bathrooms)等,并且进行了点积操作来计算出一个合适的encoding值（类似于先前讨论区中出现的manager_skills,同时为了防止过拟合对这些似然估计出来的feature创建了2层嵌套。另外还有一种对我启发比较大的feature是对description出现频率最高的15k单词进行一个one-hot深度xgboost训练,将这个训练出来模型的预测结果作为description的encoding。 Top #3 solution @Little Boat
其FE的第一部分给出了group的一套方案,类似于我自己FE中的group方法。第二部分使用了magic feature相关的feature,方法与第一部分类似
Top #9 solution @James Trotman
没有细说,但是列出了一个feature name的详单,希望以后没有idea的时候能从中找到一些insight Top #11 solution @KazAnova
KazAnova无疑是这场比赛中的明星选手,他分享了对初学者模型融合比较关键的Stack-Net,以及对最后榜单变动起到决定性作用的magic feature。几乎所有在榜上的Kagglers都要向他致敬。同时在FE这一块,他注意到了数据集中存在很多类似的数据（仅仅在价格上有区别）,因此他建立了不同的group,并在这些group间创建了很多aggregated features,比如最高的price,平均price等 Top #12 solution @b.e.s
用到了基于高势集类别数据的group的一些统计量。 Top #13 solution @qianqian
也是用了很多基于manager_id group的统计feature。
模型调参（Grid Search）
模型调参的话,能够在FE完之后为你提升0.001～0.002分数,因此如何为我们的分类器,比如xgboost选择好正确的参数是非常关键的。
比较常用的是进行Grid Search,从你的输入组合中暴力地搜索cv结果最优的组合。我一般会设定一个learning rate,然后尝试不同的参数组合,取最优值,因为训search的代价比较高,最好选择一定范围,比如你事先cv的时候知道estimater会在700～1000的范围内,那就不要search这个范围以外的值了。
模型融合
如果你没有idea了的话,就模型融合吧！模型融合是能够快速提高比赛成绩的捷径,现在的比赛几乎没有人不用到这个技巧,通常获胜者会对很多很多模型进行融合,并且会选择不同的模型融合的方式。这里有一篇非常好的模型融合解析 博文 ,相信每个看过它的人都会对模型融合有一个清楚的了解
本次比赛中我使用了两种模型融合方式,一种是Averaging,一种是Stacking。
先来说说Stacking,因为这场比赛一名贡献比较大的选手分享了一个叫StackNet的库,作为新手我就直接用了。首先我用我的xgboost cv集交叉预测出结果作为feature的一部分放到train data中,再对test data进行预测的结果作为feature的一部分放到test data中,再在第二层上选择了Logistic Classifer,GradientBoostingClassifer,AdaBoostClassifer,NNSoft-maxClassfier,RandomForestClassifer等进行交叉预测,第三层选取了一个randomForest作为最后的结果训练和预测。Stacking主要增多了模型的diversity,使我的成绩上升了至少0.003的量级。
然后是Averaging,之前提到过Stacking需要交叉预测,我就选取了10组随机种子分别对训练集进行10-kfold交叉预测取平均,以及每个flod训练预测的时候我都对我的xgboost选取5个随机种子取平均。也就是说,在第一层Stacking的CV集交叉预测时我总共训练了500个模型进行平均。分数的提升大约在0.002左右。
直到比赛结束看了排名靠前的选手的模型融合后,才发现自己对于模型融合只是做了一点微小的工作,提升空间还非常大。详情可以看FE部分分享的solution链接。
Tricks
在这场比赛中有一名在一开始的两个月一直遥遥领先的选手爆出这个比赛有个magic feature,大家陷入了疯狂找这个feature的过程中,直到那位分享了StackNet的选手分享出了这个magic feature：80G图片数据每个文件夹的创建时间,于是榜单大变,我一觉醒来后发现自己掉了很多就发现到了不对劲,便迅速加入到这个magic feature疯狂屠榜的大军中,从这里可以看见,一个信息量巨大的feature如果被发现的话,对比赛成绩会带来多么大的影响。
有一些group的feature能够起到非常重要的作用,详细见我比赛后发表的一个小样例 discussion topic 。但是一定要防止过拟合。
总结
这篇博文还有一些关键的点没有涉及到,比如数据的清洗,有些数据在记录中似乎是不同的,但是意思是一样的,就应该归位同一个类别,还有就是清除一些outlier等。
对这个比赛的top solution总结得还是没到位,基本没有coding实现他们的idea过。由于课程压力比较大,等到时候空了的时候再好好整理。
另外还有就是需要持之以恒地打这个比赛,因为你以为你idea都没有了,模型调参、融合完毕了的时候,可能大家都找出了另一个"magic feature",轻松地把你挤出奖牌的范围内了。
最后,Kaggle is fun!

「深度学习福利」大神带你进阶工程师,立即查看>>>
1 特征工程是什么？
2 数据预处理
　　2.1 无量纲化
　　　　2.1.1 标准化
　　　　2.1.2 区间缩放法
　　　　2.1.3 标准化与归一化的区别
　　2.2 对定量特征二值化
　　2.3 对定性特征哑编码
　　2.4 缺失值计算
　　2.5 数据变换
　　2.6 回顾
3 特征选择
　　3.1 Filter
　　　　3.1.1 方差选择法
　　　　3.1.2 相关系数法
　　　　3.1.3 卡方检验
　　　　3.1.4 互信息法
　　3.2 Wrapper
　　　　3.2.1 递归特征消除法
　　3.3 Embedded
　　　　3.3.1 基于惩罚项的特征选择法
　　　　3.3.2 基于树模型的特征选择法
　　3.4 回顾
4 降维
　　4.1 主成分分析法（PCA）
　　4.2 线性判别分析法（LDA）
　　4.3 回顾
5 总结
6 参考资料
1 特征工程是什么？
　　有这么一句话在业界广泛流传：数据和特征决定了机器学习的上限,而模型和算法只是逼近这个上限而已。那特征工程到底是什么呢？顾名思义,其本质是一项工程活动,目的是最大限度地从原始数据中提取特征以供算法和模型使用。通过总结和归纳,人们认为特征工程包括以下方面：
　　特征处理是特征工程的核心部分,sklearn提供了较为完整的特征处理方法,包括数据预处理,特征选择,降维等。首次接触到sklearn,通常会被其丰富且方便的算法模型库吸引,但是这里介绍的特征处理库也十分强大！
　　本文中使用sklearn中的 IRIS（鸢尾花）数据集 来对特征处理功能进行说明。IRIS数据集由Fisher在1936年整理,包含4个特征（Sepal.Length（花萼长度）、Sepal.Width（花萼宽度）、Petal.Length（花瓣长度）、Petal.Width（花瓣宽度））,特征值都为正浮点数,单位为厘米。目标值为鸢尾花的分类（Iris Setosa（山鸢尾）、Iris Versicolour（杂色鸢尾）,Iris Virginica（维吉尼亚鸢尾））。导入IRIS数据集的代码如下：
1 from sklearn.datasets import load_iris 2 3 #导入IRIS数据集 4 iris = load_iris() 5 6 #特征矩阵 7 iris.data 8 9 #目标向量 10 iris.target
2 数据预处理
　　通过特征提取,我们能得到未经处理的特征,这时的特征可能有以下问题： 不属于同一量纲：即特征的规格不一样,不能够放在一起比较。无量纲化可以解决这一问题。 信息冗余：对于某些定量特征,其包含的有效信息为区间划分,例如学习成绩,假若只关心“及格”或不“及格”,那么需要将定量的考分,转换成“1”和“0”表示及格和未及格。二值化可以解决这一问题。 定性特征不能直接使用：某些机器学习算法和模型只能接受定量特征的输入,那么需要将定性特征转换为定量特征。最简单的方式是为每一种定性值指定一个定量值,但是这种方式过于灵活,增加了调参的工作。 通常使用哑编码的方式将定性特征转换为定量特征 ：假设有N种定性值,则将这一个特征扩展为N种特征,当原始特征值为第i种定性值时,第i个扩展特征赋值为1,其他扩展特征赋值为0。哑编码的方式相比直接指定的方式,不用增加调参的工作,对于线性模型来说,使用哑编码后的特征可达到非线性的效果。 存在缺失值：缺失值需要补充。 信息利用率低：不同的机器学习算法和模型对数据中信息的利用是不同的,之前提到在线性模型中,使用对定性特征哑编码可以达到非线性的效果。类似地,对定量变量多项式化,或者进行其他的转换,都能达到非线性的效果。
　　我们使用sklearn中的preproccessing库来进行数据预处理,可以覆盖以上问题的解决方案。
2.1 无量纲化
　　无量纲化使不同规格的数据转换到同一规格。常见的无量纲化方法有标准化和区间缩放法。标准化的前提是特征值服从正态分布,标准化后,其转换成标准正态分布。区间缩放法利用了边界值信息,将特征的取值区间缩放到某个特点的范围,例如[0, 1]等。
2.1.1 标准化
　　标准化需要计算特征的均值和标准差,公式表达为：
　　使用preproccessing库的StandardScaler类对数据进行标准化的代码如下： 1 from sklearn.preprocessing import StandardScaler 2 3 #标准化,返回值为标准化后的数据 4 StandardScaler().fit_transform(iris.data)
2.1.2 区间缩放法
　　区间缩放法的思路有多种,常见的一种为利用两个最值进行缩放,公式表达为：
　　使用preproccessing库的MinMaxScaler类对数据进行区间缩放的代码如下： 1 from sklearn.preprocessing import MinMaxScaler 2 3 #区间缩放,返回值为缩放到[0, 1]区间的数据 4 MinMaxScaler().fit_transform(iris.data)
2.1.3 标准化与归一化的区别
　　简单来说,标准化是依照特征矩阵的列处理数据,其通过求z-score的方法,将样本的特征值转换到同一量纲下。归一化是依照特征矩阵的行处理数据,其目的在于样本向量在点乘运算或其他核函数计算相似性时,拥有统一的标准,也就是说都转化为“单位向量”。规则为l2的归一化公式如下：
　　使用preproccessing库的Normalizer类对数据进行归一化的代码如下： 1 from sklearn.preprocessing import Normalizer 2 3 #归一化,返回值为归一化后的数据 4 Normalizer().fit_transform(iris.data)
2.2 对定量特征二值化
　　定量特征二值化的核心在于设定一个阈值,大于阈值的赋值为1,小于等于阈值的赋值为0,公式表达如下：
　　使用preproccessing库的Binarizer类对数据进行二值化的代码如下： 1 from sklearn.preprocessing import Binarizer 2 3 #二值化,阈值设置为3,返回值为二值化后的数据 4 Binarizer(threshold=3).fit_transform(iris.data)
2.3 对定性特征哑编码
　　由于IRIS数据集的特征皆为定量特征,故使用其目标值进行哑编码（实际上是不需要的）。使用preproccessing库的OneHotEncoder类对数据进行哑编码的代码如下： 1 from sklearn.preprocessing import OneHotEncoder 2 3 #哑编码,对IRIS数据集的目标值,返回值为哑编码后的数据 4 OneHotEncoder().fit_transform(iris.target.reshape((-1,1)))
2.4 缺失值计算
　　由于IRIS数据集没有缺失值,故对数据集新增一个样本,4个特征均赋值为NaN,表示数据缺失。使用preproccessing库的Imputer类对数据进行缺失值计算的代码如下：
1 from numpy import vstack, array, nan 2 from sklearn.preprocessing import Imputer 3 4 #缺失值计算,返回值为计算缺失值后的数据 5 #参数missing_value为缺失值的表示形式,默认为NaN 6 #参数strategy为缺失值填充方式,默认为mean（均值） 7 Imputer().fit_transform(vstack((array([nan, nan, nan, nan]), iris.data)))
2.5 数据变换
　　常见的数据变换有基于多项式的、基于指数函数的、基于对数函数的。4个特征,度为2的多项式转换公式如下：
　　使用preproccessing库的PolynomialFeatures类对数据进行多项式转换的代码如下： 1 from sklearn.preprocessing import PolynomialFeatures 2 3 #多项式转换 4 #参数degree为度,默认值为2 5 PolynomialFeatures().fit_transform(iris.data)
　　基于单变元函数的数据变换可以使用一个统一的方式完成,使用preproccessing库的FunctionTransformer对数据进行对数函数转换的代码如下： 1 from numpy import log1p 2 from sklearn.preprocessing import FunctionTransformer 3 4 #自定义转换函数为对数函数的数据变换 5 #第一个参数是单变元函数 6 FunctionTransformer(log1p).fit_transform(iris.data)
2.6 回顾

类	功能	说明
StandardScaler	无量纲化	标准化,基于特征矩阵的列,将特征值转换至服从标准正态分布
MinMaxScaler	无量纲化	区间缩放,基于最大最小值,将特征值转换到[0, 1]区间上
Normalizer	归一化	基于特征矩阵的行,将样本向量转换为“单位向量”
Binarizer	二值化	基于给定阈值,将定量特征按阈值划分
OneHotEncoder	哑编码	将定性数据编码为定量数据
Imputer	缺失值计算	计算缺失值,缺失值可填充为均值等 PolynomialFeatures	FunctionTransformer 多项式数据转换	自定义单元数据转换 多项式数据转换	使用单变元的函数来转换数据

3 特征选择
　　当数据预处理完成后,我们需要选择有意义的特征输入机器学习的算法和模型进行训练。通常来说,从两个方面考虑来选择特征： 特征是否发散：如果一个特征不发散,例如方差接近于0,也就是说样本在这个特征上基本上没有差异,这个特征对于样本的区分并没有什么用。 特征与目标的相关性：这点比较显见,与目标相关性高的特征,应当优选选择。除方差法外,本文介绍的其他方法均从相关性考虑。
　　根据特征选择的形式又可以将特征选择方法分为3种： Filter：过滤法,按照发散性或者相关性对各个特征进行评分,设定阈值或者待选择阈值的个数,选择特征。 Wrapper：包装法,根据目标函数（通常是预测效果评分）,每次选择若干特征,或者排除若干特征。 Embedded：嵌入法,先使用某些机器学习的算法和模型进行训练,得到各个特征的权值系数,根据系数从大到小选择特征。类似于Filter方法,但是是通过训练来确定特征的优劣。
　　我们使用sklearn中的feature_selection库来进行特征选择。
3.1 Filter
3.1.1 方差选择法
　　使用方差选择法,先要计算各个特征的方差,然后根据阈值,选择方差大于阈值的特征。使用feature_selection库的VarianceThreshold类来选择特征的代码如下： 1 from sklearn.feature_selection import VarianceThreshold 2 3 #方差选择法,返回值为特征选择后的数据 4 #参数threshold为方差的阈值 5 VarianceThreshold(threshold=3).fit_transform(iris.data)
3.1.2 相关系数法
　　使用相关系数法,先要计算各个特征对目标值的相关系数以及相关系数的P值。用feature_selection库的SelectKBest类结合相关系数来选择特征的代码如下：
1 from sklearn.feature_selection import SelectKBest 2 from scipy.stats import pearsonr 3 4 #选择K个最好的特征,返回选择特征后的数据 5 #第一个参数为计算评估特征是否好的函数,该函数输入特征矩阵和目标向量,输出二元组（评分,P值）的数组,数组第i项为第i个特征的评分和P值。在此定义为计算相关系数 6 #参数k为选择的特征个数 7 SelectKBest(lambda X, Y: array(map(lambda x:pearsonr(x, Y), X.T)).T, k=2).fit_transform(iris.data, iris.target)
3.1.3 卡方检验
　　经典的卡方检验是检验定性自变量对定性因变量的相关性。假设自变量有N种取值,因变量有M种取值,考虑自变量等于i且因变量等于j的样本频数的观察值与期望的差距,构建统计量：
　　 这个统计量的含义简而言之就是自变量对因变量的相关性 。用feature_selection库的SelectKBest类结合卡方检验来选择特征的代码如下： 1 from sklearn.feature_selection import SelectKBest 2 from sklearn.feature_selection import chi2 3 4 #选择K个最好的特征,返回选择特征后的数据 5 SelectKBest(chi2, k=2).fit_transform(iris.data, iris.target)
3.1.4 互信息法
　　经典的互信息也是评价定性自变量对定性因变量的相关性的,互信息计算公式如下：
　　为了处理定量数据,最大信息系数法被提出,使用feature_selection库的SelectKBest类结合最大信息系数法来选择特征的代码如下：
1 from sklearn.feature_selection import SelectKBest 2 from minepy import MINE 3 4 #由于MINE的设计不是函数式的,定义mic方法将其为函数式的,返回一个二元组,二元组的第2项设置成固定的P值0.5 5 def mic(x, y): 6 m = MINE() 7 m.compute_score(x, y) 8 return (m.mic(), 0.5) 9 10 #选择K个最好的特征,返回特征选择后的数据 11 SelectKBest(lambda X, Y: array(map(lambda x:mic(x, Y), X.T)).T, k=2).fit_transform(iris.data, iris.target)
3.2 Wrapper
3.2.1 递归特征消除法
　　递归消除特征法使用一个基模型来进行多轮训练,每轮训练后,消除若干权值系数的特征,再基于新的特征集进行下一轮训练。使用feature_selection库的RFE类来选择特征的代码如下：
1 from sklearn.feature_selection import RFE 2 from sklearn.linear_model import LogisticRegression 3 4 #递归特征消除法,返回特征选择后的数据 5 #参数estimator为基模型 6 #参数n_features_to_select为选择的特征个数 7 RFE(estimator=LogisticRegression(), n_features_to_select=2).fit_transform(iris.data, iris.target)
3.3 Embedded
3.3.1 基于惩罚项的特征选择法
　　使用带惩罚项的基模型,除了筛选出特征外,同时也进行了降维。使用feature_selection库的SelectFromModel类结合带L1惩罚项的逻辑回归模型,来选择特征的代码如下： 1 from sklearn.feature_selection import SelectFromModel 2 from sklearn.linear_model import LogisticRegression 3 4 #带L1惩罚项的逻辑回归作为基模型的特征选择 5 SelectFromModel(LogisticRegression(penalty="l1", C=0.1)).fit_transform(iris.data, iris.target)
　　 L1惩罚项降维的原理在于保留多个对目标值具有同等相关性的特征中的一个 ,所以没选到的特征不代表不重要。故,可结合L2惩罚项来优化。具体操作为：若一个特征在L1中的权值为1,选择在L2中权值差别不大且在L1中权值为0的特征构成同类集合,将这一集合中的特征平分L1中的权值,故需要构建一个新的逻辑回归模型：
View Code
　　使用feature_selection库的SelectFromModel类结合带L1以及L2惩罚项的逻辑回归模型,来选择特征的代码如下： 1 from sklearn.feature_selection import SelectFromModel 2 3 #带L1和L2惩罚项的逻辑回归作为基模型的特征选择 4 #参数threshold为权值系数之差的阈值 5 SelectFromModel(LR(threshold=0.5, C=0.1)).fit_transform(iris.data, iris.target)
3.3.2 基于树模型的特征选择法
　　树模型中GBDT也可用来作为基模型进行特征选择,使用feature_selection库的SelectFromModel类结合GBDT模型,来选择特征的代码如下： 1 from sklearn.feature_selection import SelectFromModel 2 from sklearn.ensemble import GradientBoostingClassifier 3 4 #GBDT作为基模型的特征选择 5 SelectFromModel(GradientBoostingClassifier()).fit_transform(iris.data, iris.target)
3.4 回顾

类	所属方式	说明
VarianceThreshold	Filter	方差选择法
SelectKBest	Filter	可选关联系数、卡方校验、最大信息系数作为得分计算的方法 RFE	SelectFromModel Wrapper	Embedded 递归地训练基模型,将权值系数较小的特征从特征集合中消除	训练基模型,选择权值系数较高的特征

4 降维
　　当特征选择完成后,可以直接训练模型了,但是可能由于特征矩阵过大,导致计算量大,训练时间长的问题,因此降低特征矩阵维度也是必不可少的。常见的降维方法除了以上提到的基于L1惩罚项的模型以外,另外还有主成分分析法（PCA）和线性判别分析（LDA）,线性判别分析本身也是一个分类模型。PCA和LDA有很多的相似点,其本质是要将原始的样本映射到维度更低的样本空间中,但是PCA和LDA的映射目标不一样： PCA是为了让映射后的样本具有最大的发散性；而LDA是为了让映射后的样本有最好的分类性能 。所以说PCA是一种无监督的降维方法,而LDA是一种有监督的降维方法。
4.1 主成分分析法（PCA）
　　使用decomposition库的PCA类选择特征的代码如下： 1 from sklearn.decomposition import PCA 2 3 #主成分分析法,返回降维后的数据 4 #参数n_components为主成分数目 5 PCA(n_components=2).fit_transform(iris.data)
4.2 线性判别分析法（LDA）
　　使用lda库的LDA类选择特征的代码如下： 1 from sklearn.lda import LDA 2 3 #线性判别分析法,返回降维后的数据 4 #参数n_components为降维后的维数 5 LDA(n_components=2).fit_transform(iris.data, iris.target)
4.3 回顾

库	类	说明 decomposition	lda PCA	LDA 主成分分析法	线性判别分析法

5 总结
　　再让我们回归一下本文开始的特征工程的思维导图,我们可以使用sklearn完成几乎所有特征处理的工作,而且不管是数据预处理,还是特征选择,抑或降维,它们都是通过某个类的方法fit_transform完成的,fit_transform要不只带一个参数：特征矩阵,要不带两个参数：特征矩阵加目标向量。这些难道都是巧合吗？还是故意设计成这样？方法fit_transform中有fit这一单词,它和训练模型的fit方法有关联吗？接下来,我将在 《使用sklearn优雅地进行数据挖掘》 中阐述其中的奥妙！
6 参考资料 FAQ: What is dummy coding? IRIS（鸢尾花）数据集 卡方检验 干货：结合Scikit-learn介绍几种常用的特征选择方法 机器学习中,有哪些特征选择的工程方法？ 机器学习中的数学(4)-线性判别分析（LDA）, 主成分分析(PCA)

「深度学习福利」大神带你进阶工程师,立即查看>>>
作者：William Koehrsen
来源：Towards data science、机器之心
机器学习越来越多地从人工设计模型转向使用 H20、TPOT 和 auto-sklearn 等工具自动优化的工具。这些库以及随机搜索（参见《Random Search for Hyper-Parameter Optimization》）等方法旨在通过寻找匹配数据集的最优模型来简化模型选择和机器学习调优过程,而几乎不需要任何人工干预。然而,特征工程作为机器学习流程中可能最有价值的一个方面,几乎完全是人工的。
特征工程也被称为特征构造,是从现有数据中构造新的特征从而训练机器学习模型的过程。这一步可能比实际上使用的模型更重要,因为一个机器学习算法只能从我们给定的数据中学习,所以构造一个和任务相关的特征是至关重要的,参见优质论文《A Few Useful Things to Know about Machine Learning》。
通常,特征工程是一个冗长的人工过程,依赖于领域知识、直觉和数据操作。这个过程可能是极其枯燥的,同时最终得到的特征将会受到人的主观性和时间的限制。特征工程自动化旨在通过从数据集中自动构造候选特征,并从中选择最优特征用于训练来帮助数据科学家。
在本文中,我们将介绍一个使用 Feature Tools Python 库实现特征工程自动化的例子。我们将使用一个示例数据集来说明基本概念（继续关注之后使用真实世界数据的例子）。本文完整代码可在 Github 上找到。
特征工程基本概念
特征工程意味着从现有的数据中构造额外特征,这些特征通常分布在多张相关的表中。特征工程需要从数据中提取相关信息并将其存入单张表格中,然后被用来训练机器学习模型。
构造特征是一个非常耗时的过程,因为每个新的特征通常需要几步才能构造,特别是当使用多张表的信息时。我们可以将特征构造的操作分为两类：「转换」和「聚合」。以下通过几个例子来看看这些概念的实际应用。
通过从一或多列中构造新的特征,「转换」作用于单张表（在 Python 中,表是一个 Pandas DataFrame）。举个例子,若有如下的客户表：
我们可以通过查找 joined 列中的月份或是自然对数化 income 列的数据来构造新的特征。这些都是转换操作,因为它们只用到了一张表的信息。
另一方面,「聚合」是跨表实现的,并使用一对多的关联来对观测值分组,然后计算统计量。例如,若我们有另外一张包含客户贷款信息的表格,其中每个客户可能有多项贷款,我们便可以计算每个客户贷款的平均值、最大值和最小值等统计量。
这个过程包括根据不同客户对贷款表进行分组并计算聚合后的统计量,然后将结果整合到客户数据中。以下是我们在 Python 中使用 Pandas 库执行此操作。
importpandas aspd
# Group loans by client id and calculate mean, max, min ofloans
stats = loans.groupby( 'client_id')[ 'loan_amount'].agg([ 'mean', 'max', 'min'])
stats.columns = [ 'mean_loan_amount', 'max_loan_amount', 'min_loan_amount']
# Merge withthe clients dataframe
stats = clients.merge(stats, left_on = 'client_id', right_index=True, how = 'left')
stats.head( 10)
这些操作本身并不困难,但是如果有数百个变量分布在数十张表中,这个过程将无法通过人工完成。理想情况下,我们希望有一个解决方案能够在不同表间自动执行转换和聚合操作,并将结果整合到一张表中。尽管 Pandas 是一个很好的资源,但是仍然有许多数据操作需要我们人工完成！有关人工特征工程的更多信息,请查阅《Python Data Science Handbook》。
特征工具
幸运的是,Feature Tools 正是我们正在找寻的解决方案。这个开源的 Python 库可以从一组相关的表中自动构造特征。特征工具基于名为「深度特征合成」的方法（参见《Deep Feature Synthesis: Towards Automating Data Science Endeavors》）,这个方法的名字听起来比其本身更高大上（这个名字源于叠加了多重特征,而不是因为使用了深度学习方法！）。
深度特征合成叠加多个转换和聚合操作,这在特征工具的词库中被称为特征基元,以便通过分布在多张表内的数据来构造新的特征。与机器学习中的大多数方法一样,这是建立在简单概念基础之上的复杂方法。通过一次学习一个构造块,我们可以很好地理解这个强大的方法。
首先,让我们看一下示例数据。我们已经看到了上面的一些数据集,并且完整的表组如下所示： clients： 关于信用社客户的基本信息。每个客户只对应数据框中的一行。
loans： 向用户提供的贷款。每项贷款只对应数据框中的一行,但是客户可能有多项贷款。
payments：贷款还本的支付。每笔支付只对应一行,但是每项贷款可以有多笔支付。
如果我们有一个机器学习任务,例如预测客户未来是否会偿还一项贷款,我们希望将所有关于客户的信息整合到一张表中。这些表是相关的（通过 client_id 和 loan_id 变量）,并且我们可以通过一系列转换和聚合操作来人工实现这个过程。然而,我们很快就可以使用特征工具来自动实现这个过程。
实体和实体集
特征工具的前两个概念的是「实体」和「实体集」。一个实体就是一张表（或是 Pandas 中的一个 DataFrame（数据框））。一个实体集是一组表以及它们之间的关联。将一个实体集看成另一种 Python 数据结构,并带有自己的方法和属性。
我们可以通过以下操作在特征工具中创建一个空的实体集：
importfeaturetools asft
# Create newentityset
es = ft.EntitySet(id = 'clients')
现在我们需要整合两个实体。每个实体都必须带有一个索引,它是一个包含所有唯一元素的列。就是说,索引中的每个值只能在表中出现一次。在 clients 数据框中的索引是 client_id,因为每个客户在该数据框中只对应一行。我们使用以下语法将一个带有索引的实体添加一个实体集中：
# Create an entity fromthe client dataframe
# This dataframe already has an index and a time index
es = es.entity_from_dataframe(entity_id = 'clients', dataframe = clients,
index = 'client_id', time_index = 'joined')
loans 数据框还有另外一个唯一的索引,loan_id,同时将其添加到实体集的语法与 clients 一样。然而,payments 数据框不存在唯一索引。当我们把 payments 数据框添加到实体集中时,我们需要传入参数 make_index = True,同时指定索引的名字。另外,尽管特征工具能自动推断实体中每列的数据类型,但是我们可以通过将列数据类型的字典传递给参数 variable_types 来覆盖它。
# Create an entity fromthe payments dataframe
# This does not yet have a unique index
es = es.entity_from_dataframe(entity_id = 'payments',
dataframe = payments,
variable_types = { 'missed': ft.variable_types.Categorical},
make_index = True,
index = 'payment_id',
time_index = 'payment_date')
对于此数据框,尽管 missed 是一个整数,但是它不是一个数值变量,因为它只能取 2 个离散的数值,所以在特征工具中,将其看成一个分类变量。在将该数据框添加到实体集中后,我们检查整个实体集：
列的数据类型已根据我们指定的修正方案被正确推断出来。接下来,我们需要指定实体集中表是如何关联的。
表的关联
考虑两张表之间「关联」的最好方法是类比父子之间的关联。这是一种一对多的关联：每个父亲可以有多个儿子。对表来说,每个父亲对应一张父表中的一行,但是子表中可能有多行对应于同一张父表中的多个儿子。
例如,在我们的数据集中,clients 数据框是 loans 数据框的一张父表。每个客户只对应 clients 表中的一行,但是可能对应 loans 表中的多行。同样,loans 表是 payments 表的一张父表,因为每项贷款可以有多项支付。父亲通过共享变量与儿子相关联。当我们执行聚合操作的时候,我们根据父变量对子表进行分组,并计算每个父亲的儿子的统计量。
为了形式化特征工具中的关联规则,我们仅需指定连接两张表的变量。clients 表和 loans 表通过 client_id 变量连接,同时 loans 表和 payments 表通过 loan_id 变量连接。创建关联并将其添加到实体集中的语法如下所示：
# Relationship between clients and previous loans
r_client_previous = ft.Relationship(es[ 'clients'][ 'client_id'],
es[ 'loans'][ 'client_id'])
# Add the relationship to the entity set
es = es.add_relationship(r_client_previous)
# Relationship between previous loans and previous payments
r_payments = ft.Relationship(es[ 'loans'][ 'loan_id'],
es[ 'payments'][ 'loan_id'])
# Add the relationship to the entity set
es = es.add_relationship(r_payments)
es
该实体集现在包含三个实体（表）,以及将这些表连接在一起的关联规则。在添加实体和形式化关联规则之后,实体集就完整了并准备好从中构造新的特征。
特征基元
在我们深入了解深度特征合成之前,我们需要了解特征基元的概念。我们其实早就知道是什么了,只是我们刚刚用不同的名字来称呼它们！它们只是我们用来构造新特征的操作： 聚合：根据父与子（一对多）的关联完成的操作,也就是根据父亲分组并计算儿子的统计量。一个例子就是根据 client_id 对 loan 表分组并找到每个客户的最大贷款额。 转换：对一张表中一或多列完成的操作。一个例子就是取一张表中两列之间的差值或者取一列的绝对值。
在特征工具中单独使用这些基元或者叠加使用这些基元可以构造新的特征。以下是特征工具中一些特征基元的列表,也可以自定义特征基元。
特征基元
这些基元可以单独使用或是组合使用以构造新的特征。为了使用特定的基元构造新的特征,我们使用 ft.dfs 函数（代表深度特征合成）。我们传入 entityset 和 target_entity,这是我们想要在其中添加特征的表,被选参数 trans_primitives（转换）和 agg_primitives（聚合）。
publicclassMyActivityextendsAppCompatActivity{
@Override//override the function
protectedvoidonCreate( @Nullable Bundle savedInstanceState){
super.onCreate(savedInstanceState);
try{
OkhttpManager.getInstance().setTrustrCertificates(getAssets().open( "mycer.cer");
OkHttpClient mOkhttpClient= OkhttpManager.getInstance().build();
} catch(IOException e) {
e.printStackTrace();
}
}
返回的是包含每个客户新特征的数据框（因为我们定义客户为 target_entity）。比如我们有每个客户加入的月份,这是一个转换操作的特征基元：
我们也有许多聚合操作的基元,比如每个客户的平均支付总额：
尽管我们仅指定了一些特征基元,但是特征工具可以通过组合和叠加这些基元来构造新的特征。
完整的数据框包含 793 列的新特征！
深度特征合成
我们现在具备理解深度特征合成（dfs）的一切条件。事实上,我们已经在前面的函数调用中执行了 dfs！深度特征只是叠加多个基元构造的一个特征,而 dfs 只是构造这些特征的过程的名称。深度特征的深度是构造这个特征所需的基元数量。
例如,MEAN（payments.payment_amount）列是深度为 1 的特征,因为它是使用单个聚合操作构造的。LAST（loans（MEAN（payments.payment_amount））是一个深度为 2 的特征,它是由两个叠加的聚合操作构造的：MEAN 列之上的 LAST（最近的）列。这表示每个客户最近的贷款平均支付额。
我们可以叠加任意深度的特征,但在实践中,我从没有使用超过 2 个深度的特征。此外,这些特征很难解释,但是我鼓励任何对「深入」感兴趣的人。
我们不必人工指定特征基元,但可以让特征工具自动为我们选取特征。为此,我们使用相同的 ft.dfs 函数调用,但是不传入任何特征基元。
# Perform deep feature synthesis without specifying primitives
features, feature_names = ft.dfs(entityset=es, target_entity= 'clients',
max_depth = 2)
features.head()
特征工具构造了很多特征供我们使用。尽管这个过程确实能自动构造新的特征,但是它不会取代数据科学家,因为我们仍然需要弄清楚如何处理这些特征。例如,我们的目的是预测一位客户是否会偿还贷款,我们可以寻找与特定结果最相关的特征。此外,如果我们具有领域知识,我们可以用这些知识来选择指定的特征基元或候选特征的种子深度特征合成。
下一步
特征工程自动化解决了一个问题,但是带来了另一个问题：特征太多了。尽管在拟合一个模型之前很难说哪些特征是重要的,但很可能不是所有这些特征都与我们想要训练的模型的任务相关。此外,拥有太多特征（参见《Irrelevant Features and the Subset Selection Problem》）可能会导致模型性能不佳,因为较无益的特征会淹没那些更重要的特征。
特征过多问题以维度灾难著称。随着特征数量的上升（数据维度增长）,模型越来越难以学习特征与目标之间的映射关系。事实上,让模型表现良好所需的数据量与特征数量成指数关系。
维度灾难与特征降维（也叫特征选择,去除不相关特征的过程）相对。这可以采用多种形式：主成分分析（PCA）、SelectKBest、使用模型中特征的重要性或使用深度神经网络进行自编码。但是,特征降维是另一篇文章的不同主题。到目前为止,我们知道我们可以使用特征工具以最小的努力从许多表中构造大量的特征！
结论
与机器学习中的许多主题一样,使用特征工具进行特征工程自动化是一个基于简单想法的复杂概念。使用实体集、实体和关联的概念,特征工具可以执行深度特征合成操作来构造新的特征。深度特征合成可以依次叠加特征基元：「聚合」,它们在多张表间的一对多关联中起作用,以及「转换」,是应用于单张表中一或多列以从多张表中构造新的特征的函数。
在之后的文章中,我将介绍如何在现实世界的问题上使用这项技术,即在 Kaggle 上举办的房屋信用违约风险竞赛（https://www.kaggle.com/c/home-credit-default-risk）。请继续关注那则帖子,与此同时,阅读这则说明以开始竞赛（https://towardsdatascience.com/machine-learning-kaggle-competition-part-one-getting-started-32fb9ff47426）! 我希望你们可以使用特征工程自动化作为数据科学工作中的辅助工具。我们的模型与我们提供的数据一样好,并且特征工程自动化可以使特征构造的过程更高效。
有关特征工具更多的信息,包括高级用法,请查看在线文档（https://docs.featuretools.com/）。要了解在实践中如何使用特征工具,请阅读开源库的开发公司 Feature Labs 的工作（https://www.featurelabs.com/）。
原文链接：https://towardsdatascience.com/automated-feature-engineering-in-python-99baf11cc219 返回搜狐,查看更多 项目地址：https://docs.featuretools.com/ 代码地址：https://github.com/WillKoehrsen/automated-feature-engineering/blob/master/walk_through/Automated_Feature_Engineering.ipynb
声明：该文观点仅代表作者本人,搜狐号系信息发布平台,搜狐仅提供信息存储空间服务。

「深度学习福利」大神带你进阶工程师,立即查看>>>
【新智元导读】对于很多入坑机器学习的同学来说,数学可能是比较艰辛的部分。本文作者介绍了构建机器学习产品、或进行机器学习研究所需的数学背景,以及来自机器学习工程师、研究人员和教师的宝贵经验和建议,并提供了许多课程和书籍资源。
目前我们还不完全清楚开始学习机器学习需要怎样的数学水平,对于那些没有在学校学习过数学或统计学的人尤其如此。
这篇文章的目标是提出打造一款机器学习产品、或进行有关机器学习的学术研究所需要的数学背景。这些建议来自与机器学习工程师、研究人员和教育工作者的对话,以及笔者在机器学习研究和行业中的经验。
为了构建所需数学水平的先决条件,本文首先提出了不同的思维模式和策略,以便读者在传统课堂之外接触数学教育。然后,文章概述了不同类型的机器学习项目所需的具体背景,因这些学科的范围从高中水平的统计和微积分知识到概率图模型（PGM）的最新发展。在这最后,我希望读者能够对数学学习产生感觉,你需要在你的机器学习项目中有效利用这些知识,无论是什么项目！
首先,我承认对学习风格/框架/资源的学习,学习者的个人需求和目标可能是独一无二的。 欢迎各位在HN上提出自己的意见！
关于数学焦虑症的一些体会
事实证明,很多人,包括工程师在内,都对数学有着畏惧情绪。首先,我想谈谈关于“擅长数学”的话题。
实际上,擅长数学的人都会有很多实际运用数学的实践经验。结果,他们会觉得在数学上陷入困境是习以为常的事情。最近的研究显示,学习者的心态（而非先天能力）,是一个人学习数学能力的主要预测指标。
要清楚,要达到这种习以为常的良好状态需要时间和精力,但这肯定不是人天生就有的能力。本文其余部分将帮助读者确定所需的数学基础水平,并概述应如何建立这种水平的策略。
入门：数学和代码

「深度学习福利」大神带你进阶工程师,立即查看>>>
两家欧洲公司开发了世界上第一款室内无人机监视自动巡逻系统,可以实时转播录像,并在发现入侵者时发出警报。
无人机会在它所监测的建筑物的走廊和房间按照预定的巡逻路线进行巡逻。当它电力不足时,它就会自动降落在无线充电板上充电。一架安装在四轴飞行器上的监控摄像头可以实时拍摄并在发现任何潜在威胁的时候向人类守卫发出警告。
研发该系统的工程师声称,建筑业主可以用几架无人机替换数百台静态相机,节省成本,同时保证他们的财产安全。“无人机在监控应用中效果最好,而且成本更低,”西班牙通信和无人机技术开发商Avansig的首席执行官特里罗说。他是两家致力于开发新系统的公司之一。“你不需要安装这么多摄像头,这样就能降低成本。”
总部位于加泰罗尼亚的Avansig与总部位于柏林的无人机充电公司Skysense合作。
尽管这家西班牙公司为原型系统提供了无人机技术,但Skysense提供了其最新的无线无人机充电站。该公司表示,这项技术免除了移除电池,或者在每次断电时手动向无人机充电的麻烦。这就使得该系统在很大程度上可以让无人机独立于人类,因为不需要每隔几个小时就干涉它的电池。

「深度学习福利」大神带你进阶工程师,立即查看>>>
AI/DL在迅速发展
随着数据量的爆发式增长和计算能力的不断提升,以及在算法上的不断突破,人工智能（AI,Artificial Intelligence ）和其支持的深度学习（DL,Deep Learning）计算模型取得了突飞猛进的发展。
去年,中国制定了《新一代人工智能发展规划》立志要在AI总体技术和应用2020年与世界前沿同步,2025年AI成为产业升级和经济转型的主要动力,2030年,中国要成为世界主要AI创新中心。AI已经上升为国家策略,针对AI的投资也在不断迅速增长。
AI加持的自动驾驶汽车,自然语言处理,人脸识别等等行业已经逐渐变成现实,这些将深刻改变人类的生活和生产方式。
AI/DL的数据处理流程
采集数据：
根据业务需要,实际采集相应的数据,或者从专门的数据采集公司购买现成的原始数据。
数据预处理：
这些原始数据可能会存在有缺失值、重复值等,在使用之前需要进行数据预处理。数据预处理没有标准的流程,通常针对不同的任务和数据集属性的不同而不同。例如,调整照片的亮度、对比度等等。
特征工程：
将数据中的特征标注出来,比如标记自动驾驶采集的道路信息,道路两旁的汽车信息等等,再比如人脸识别的场景中,将人脸照片根据不同的特征进行分类等。
模型训练：

「深度学习福利」大神带你进阶工程师,立即查看>>>
Overfitting is a problem with sophisticated non-linear learning algorithms like gradient boosting.
In this post you will discover how you can use early stopping to limit overfitting with XGBoost in Python.
After reading this post, you will know: About early stopping as an approach to reducing overfitting of training data. How to monitor the performance of an XGBoost model during training and plot the learning curve. How to use early stopping to prematurely stop the training of an XGBoost model at an optimal epoch.
Let’s get started. Update Jan/2017 : Updated to reflect changes in scikit-learn API version 0.18.1. Update March/2018 : Added alternate link to download the dataset as the original appears to have been taken down.
Avoid Overfitting By Early Stopping With XGBoost In Python
Photo by Michael Hamann , some rights reserved.


Need help with XGBoost in Python?
Take my free 7-day email course and discover configuration, tuning and more (with sample code).
Click to sign-up now and also get a free PDF Ebook version of the course.
Start Your FREE Mini-Course Now!


Early Stopping to Avoid Overfitting
Early stopping is an approach to training complex machine learning models to avoid overfitting.
It works by monitoring the performance of the model that is being trained on a separate test dataset and stopping the training procedure once the performance on the test dataset has not improved after a fixed number of training iterations.
It avoids overfitting by attempting to automatically select the inflection point where performance on the test dataset starts to decrease while performance on the training dataset continues to improve as the model starts to overfit.
The performance measure may be the loss function that is being optimized to train the model (such as logarithmic loss), or an external metric of interest to the problem in general (such as classification accuracy).
Monitoring Training Performance With XGBoost
The XGBoost model can evaluate and report on the performance on a test set for the the model during training.
It supports this capability by specifying both an test dataset and an evaluation metric on the call to model.fit() when training the model and specifying verbose output.
For example, we can report on the binary classification error rate (“ error “) on a standalone test set ( eval_set ) while training an XGBoost model as follows:

1
2
eval_set = [(X_test, y_test)]
model.fit(X_train, y_train, eval_metric="error", eval_set=eval_set, verbose=True)
XGBoost supports a suite of evaluation metrics not limited to: “ rmse ” for root mean squared error. “ mae ” for mean absolute error. “ logloss ” for binary logarithmic loss and “ mlogloss ” for multi-class log loss (cross entropy). “ error ” for classification error. “ auc ” for area under ROC curve.
The full list is provided in the “ Learning Task Parameters ” section of the XGBoost Parameters webpage.
For example, we can demonstrate how to track the performance of the training of an XGBoost model on the Pima Indians onset of diabetes dataset , available from the UCI Machine Learning Repository (update: download from here ).
The full example is provided below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# monitor training performance
from numpy import loadtxt
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# load data
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
# split data into X and y
X = dataset[:,0:8]
Y = dataset[:,8]
# split data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=7)
# fit model no training data
model = XGBClassifier()
eval_set = [(X_test, y_test)]
model.fit(X_train, y_train, eval_metric="error", eval_set=eval_set, verbose=True)
# make predictions for test data
y_pred = model.predict(X_test)
predictions = [round(value) for value in y_pred]
# evaluate predictions
accuracy = accuracy_score(y_test, predictions)
print("Accuracy: %.2f%%" % (accuracy * 100.0))
Running this example trains the model on 67% of the data and evaluates the model every training epoch on a 33% test dataset.
The classification error is reported each iteration and finally the classification accuracy is reported at the end.
The output is provided below, truncated for brevity. We can see that the classification error is reported each training iteration (after each boosted tree is added to the model).

1
2
3
4
5
6
7
8
9
10
11
12
13
...
[89] validation_0-error:0.204724
[90] validation_0-error:0.208661
[91] validation_0-error:0.208661
[92] validation_0-error:0.208661
[93] validation_0-error:0.208661
[94] validation_0-error:0.208661
[95] validation_0-error:0.212598
[96] validation_0-error:0.204724
[97] validation_0-error:0.212598
[98] validation_0-error:0.216535
[99] validation_0-error:0.220472
Accuracy: 77.95%
Reviewing all of the output, we can see that the model performance on the test set sits flat and even gets worse towards the end of training.
Evaluate XGBoost Models With Learning Curves
We can retrieve the performance of the model on the evaluation dataset and plot it to get insight into how learning unfolded while training.
We provide an array of X and y pairs to the eval_metric argument when fitting our XGBoost model. In addition to a test set, we can also provide the training dataset. This will provide a report on how well the model is performing on both training and test sets during training.
For example:

1
2
eval_set = [(X_train, y_train), (X_test, y_test)]
model.fit(X_train, y_train, eval_metric="error", eval_set=eval_set, verbose=True)
In addition, the performance of the model on each evaluation set is stored and made available by the model after training by calling the model.evals_result() function. This returns a dictionary of evaluation datasets and scores, for example:

1
2
results = model.evals_result()
print(results)
This will print results like the following (truncated for brevity):

1
2
3
4
{
'validation_0': {'error': [0.259843, 0.26378, 0.26378, ...]},
'validation_1': {'error': [0.22179, 0.202335, 0.196498, ...]}
}
Each of ‘ validation_0 ‘ and ‘ validation_1 ‘ correspond to the order that datasets were provided to the eval_set argument in the call to fit() .
A specific array of results, such as for the first dataset and the error metric can be accessed as follows:

1
results['validation_0']['error']
Additionally, we can specify more evaluation metrics to evaluate and collect by providing an array of metrics to the eval_metric argument of the fit() function.
We can then use these collected performance measures to create a line plot and gain further insight into how the model behaved on train and test datasets over training epochs.
Below is the complete code example showing how the collected results can be visualized on a line plot.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# plot learning curve
from numpy import loadtxt
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from matplotlib import pyplot
# load data
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
# split data into X and y
X = dataset[:,0:8]
Y = dataset[:,8]
# split data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=7)
# fit model no training data
model = XGBClassifier()
eval_set = [(X_train, y_train), (X_test, y_test)]
model.fit(X_train, y_train, eval_metric=["error", "logloss"], eval_set=eval_set, verbose=True)
# make predictions for test data
y_pred = model.predict(X_test)
predictions = [round(value) for value in y_pred]
# evaluate predictions
accuracy = accuracy_score(y_test, predictions)
print("Accuracy: %.2f%%" % (accuracy * 100.0))
# retrieve performance metrics
results = model.evals_result()
epochs = len(results['validation_0']['error'])
x_axis = range(0, epochs)
# plot log loss
fig, ax = pyplot.subplots()
ax.plot(x_axis, results['validation_0']['logloss'], label='Train')
ax.plot(x_axis, results['validation_1']['logloss'], label='Test')
ax.legend()
pyplot.ylabel('Log Loss')
pyplot.title('XGBoost Log Loss')
pyplot.show()
# plot classification error
fig, ax = pyplot.subplots()
ax.plot(x_axis, results['validation_0']['error'], label='Train')
ax.plot(x_axis, results['validation_1']['error'], label='Test')
ax.legend()
pyplot.ylabel('Classification Error')
pyplot.title('XGBoost Classification Error')
pyplot.show()
Running this code reports the classification error on both the train and test datasets each epoch. We can turn this off by setting verbose=False (the default) in the call to the fit() function.
Two plots are created. The first shows the logarithmic loss of the XGBoost model for each epoch on the training and test datasets.
XGBoost Learning Curve Log Loss
The second plot shows the classification error of the XGBoost model for each epoch on the training and test datasets.
XGBoost Learning Curve Classification Error
From reviewing the logloss plot, it looks like there is an opportunity to stop the learning early, perhaps somewhere around epoch 20 to epoch 40.
We see a similar story for classification error, where error appears to go back up at around epoch 40.
Early Stopping With XGBoost
XGBoost supports early stopping after a fixed number of iterations.
In addition to specifying a metric and test dataset for evaluation each epoch, you must specify a window of the number of epochs over which no improvement is observed. This is specified in the early_stopping_rounds parameter.
For example, we can check for no improvement in logarithmic loss over the 10 epochs as follows:

1
2
eval_set = [(X_test, y_test)]
model.fit(X_train, y_train, early_stopping_rounds=10, eval_metric="logloss", eval_set=eval_set, verbose=True)
If multiple evaluation datasets or multiple evaluation metrics are provided, then early stopping will use the last in the list.
Below provides a full example for completeness with early stopping.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# early stopping
from numpy import loadtxt
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# load data
dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
# split data into X and y
X = dataset[:,0:8]
Y = dataset[:,8]
# split data into train and test sets
seed = 7
test_size = 0.33
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)
# fit model no training data
model = XGBClassifier()
eval_set = [(X_test, y_test)]
model.fit(X_train, y_train, early_stopping_rounds=10, eval_metric="logloss", eval_set=eval_set, verbose=True)
# make predictions for test data
y_pred = model.predict(X_test)
predictions = [round(value) for value in y_pred]
# evaluate predictions
accuracy = accuracy_score(y_test, predictions)
print("Accuracy: %.2f%%" % (accuracy * 100.0))
Running the example provides the following output, truncated for brevity:

1
2
3
4
5
6
7
8
9
10
11
...
[35] validation_0-logloss:0.487962
[36] validation_0-logloss:0.488218
[37] validation_0-logloss:0.489582
[38] validation_0-logloss:0.489334
[39] validation_0-logloss:0.490969
[40] validation_0-logloss:0.48978
[41] validation_0-logloss:0.490704
[42] validation_0-logloss:0.492369
Stopping. Best iteration:
[32] validation_0-logloss:0.487297
We can see that the model stopped training at epoch 42 (close to what we expected by our manual judgment of learning curves) and that the model with the best loss was observed at epoch 32.
It is generally a good idea to select the early_stopping_rounds as a reasonable function of the total number of training epochs (10% in this case) or attempt to correspond to the period of inflection points as might be observed on plots of learning curves.
Summary
In this post you discovered about monitoring performance and early stopping.
You learned: About the early stopping technique to stop model training before the model overfits the training data. How to monitor the performance of XGBoost models during training and to plot learning curves. How to configure early stopping when training XGBoost models.
Do you have any questions about overfitting or about this post? Ask your questions in the comments and I will do my best to answer.



Want To Learn The Algorithm Winning Competitions?
Develop Your Own XGBoost Models in Minutes
…with just a few lines of Python
Discover how in my new Ebook:
XGBoost With Python
It covers self-study tutorials like:
Algorithm Fundamentals , Scaling , Hyperparameters , and much more…
Bring The Power of XGBoost To
Your Own Projects
Skip the Academics. Just Results.
Click to learn more .



About Jason Brownlee
Jason Brownlee, Ph.D. is a machine learning specialist who teaches developers how to get results with modern machine learning methods via hands-on tutorials.
View all posts by Jason Brownlee →
Feature Importance and Feature Selection With XGBoost in Python
How to Best Tune Multithreading Support for XGBoost in Python
42 Responses to Avoid Overfitting By Early Stopping With XGBoost In Python shivam October 19, 2016 at 2:43 am #
Hi Jason,
Thanks for neat and nice explanations.
Can you please elaborate on below things –
1. What should we do if the error on train is higher as compared to error on test.
2. Apart for ealry stopping how can we tune regularization parameters effectively ?
REPLY Jason Brownlee October 19, 2016 at 9:20 am #
I’m glad you found them useful shivam.
Interesting question. Ideally, we want the error on train and test to be good. Generally, error on train is a little lower than test. If it is the other way around it might be a fluke and a sign of underlearning.
Trial and error. I find the sampling methods (stochastic gradient boosting) very effective as regularization in XGBoost, more here:
http://machinelearningmastery.com/stochastic-gradient-boosting-xgboost-scikit-learn-python/
REPLY Andy November 10, 2016 at 10:30 am #
Hi Jason,
Thank you so much for the all your posts. Your site really helped to get me started.
Quick question: Is the eval_metric and eval_set arguments available in .fit() for other models besides XGBoost? Say KNN, LogReg or SVM?
Also, Can those arguments be used in grid/random search? e.g. grid_search.fit(X, y, eval_metric “error”, eval_set= […. ….] )
REPLY Jason Brownlee November 11, 2016 at 10:00 am #
Thanks Andy.
Those arguments are specific to xgboost.
Here’s an example of grid searching xgboost:
http://machinelearningmastery.com/tune-learning-rate-for-gradient-boosting-with-xgboost-in-python/
REPLY VSP January 18, 2017 at 3:50 am #
Hi Jason,
Thank you for this post, it is very handy and clear.
In the case that I have a task that is measured by another metric, as F-score, will we find the optimal epoch in the loss learning curve or in this new metric? Are there proportional, even with Accuracy?
REPLY Jason Brownlee January 18, 2017 at 10:17 am #
I would suggest using the new metric, but try both approaches and compare the results.
Make decisions based on data.
REPLY Jimmy March 9, 2017 at 8:51 pm #
Hi Jason
Thanks for your sharing!
I have a question that since the python API document mention that
Early stopping returns the model from the last iteration (not the best one). If early stopping occurs, the model will have three additional fields: bst.best_score, bst.best_iteration and bst.best_ntree_limit.
So the model we get when early stopping occur may not be the best model, right?
how can we get that best model?
REPLY Jason Brownlee March 10, 2017 at 9:26 am #
Hi Jimmy,
Early stopping may not be the best method to capture the “best” model, however you define that (train or test performance and the metric).
You might need to write a custom callback function to save the model if it has a lower score than the best seen so far.
Sorry, I do not have an example, but I’d expect you will need to use the native xgboost API rather than sklearn wrappers.
REPLY Marcus May 10, 2018 at 11:31 am #
Hi Jimmy,
The best model (w.r.t. the eval_metric and eval_set) is available in bst.best_ntree_limit. You can make predictions using it by calling:
bst.predict(X_val, ntree_limit=bst.best_ntree_limit)
See also the prediction section of:
http://xgboost.apachecn.org/en/latest/python/python_intro.html?highlight=early%20stopping#early-stopping
Best,
Marcus
REPLY Jason Brownlee May 11, 2018 at 6:32 am #
Nice, thanks for sharing.
REPLY Shud March 13, 2017 at 5:02 pm #
You’ve selected early stopping rounds = 10, but why did the total epochs reached 42. Since you said the best may not be the best, then how do i get to control the number of epochs in my final model?
REPLY Jason Brownlee March 14, 2017 at 8:14 am #
Great question shud,
The early stopping does not trigger unless there is no improvement for 10 epochs. It is not a limit on the total number of epochs.
REPLY Shud March 14, 2017 at 3:08 pm #
Since the model stopped at epoch 32, my model is trained till that and my predictions are based out of 32 epochs?
REPLY Jason Brownlee March 15, 2017 at 8:08 am #
Correct.
REPLY G April 1, 2017 at 12:23 am #
Hi Jason,
I have a question regarding the use of the test set for early stopping to avoid overfitting…
Shouldn’t you use the train set? Shouldn’t we use the test set only for testing the model and not for optimizing it? (I see early stopping as model optimization)
Regards,
G
REPLY Jason Brownlee April 1, 2017 at 5:56 am #
Early stopping uses a separate dataset like a test or validation dataset to avoid overfitting.
If we used the training dataset alone, we would not get the benefits of early stopping. How would we know when to stop?
REPLY G April 1, 2017 at 8:18 pm #
I thought we would stop when the performances on the training set don’t improve in xx rounds to avoid to create a lot of not useful trees. Then use the selected number of estimator to compute the performances on the test set. Otherwise we might risk to evaluate our model using overoptimistic results. ie. we might get very high AUC because we select the best model, but in a real world experiment where we do not have labels our performances will decrease a lot. The use of the earlystopping on the evaluation set is legitim.. Could you please elaborate and give your opinion?
Thank you
PS I really like your posts..
REPLY G April 1, 2017 at 8:23 pm #
In short my point is: how can we use the early stopping on the test set if (in principle) we should use the labels of the test set only to evaluate the results of our model and not to “train/optimize” further the model…
REPLY Jason Brownlee April 2, 2017 at 6:27 am #
Often we split data into train/test/validation to avoid optimistic results. G. April 3, 2017 at 4:42 am #
Hi Jason, I agree. However in your post you wrote:
“It works by monitoring the performance of the model that is being trained on a separate test dataset and stopping the training procedure once the performance on the test dataset has not improved after a fixed number of training iterations.
It avoids overfitting by attempting to automatically select the inflection point where performance on the test dataset starts to decrease while performance on the training dataset continues to improve as the model starts to overfit.”
This could lead to the error of using the early stopping on the final test set while it should be used on the validation set or directly on the training to don’t create too many trees.
Could you confirm this?
Regards
REPLY Jason Brownlee April 4, 2017 at 9:09 am #
Early stopping requires two datasets, a training and a validation or test set.
REPLY Ogunleye May 11, 2017 at 8:27 pm #
Hello sir,
Thank you for the good work. I adapted your code to my dataset sir, my ‘validation_0’ error stays at zero only ‘validation_1’ error changes. What does that imply sir? Thank you and kind regards sir.
REPLY Jason Brownlee May 12, 2017 at 7:40 am #
Sorry, I’m not sure I understand.
Perhaps you could give more details or an example?
REPLY omoggbeyin May 14, 2017 at 12:01 pm #
Am sorry for not making too much sense initially. I used your XGBoost code and validation_0 stayed at value 0 while validation_1 also stayed at constant value 0f 0.0123 throughout the training. I just want your expert advice on why it is constant sir. Kind regards.
REPLY Jason Brownlee May 15, 2017 at 5:51 am #
That is odd.
Try different configuration, try different data. See if things change. You may have to explore a little to debug what is going on.
REPLY Omogbehin May 13, 2017 at 9:49 am #
[56] validation_0-error:0 validation_0-logloss:0.02046 validation_1-error:0 validation_1-logloss:0.028423
[57] validation_0-error:0 validation_0-logloss:0.020461 validation_1-error:0 validation_1-logloss:0.028407
[58] validation_0-error:0 validation_0-logloss:0.020013 validation_1-error:0 validation_1-logloss:0.027592
Stopping. Best iteration:
[43] validation_0-error:0 validation_0-logloss:0.020612 validation_1-error:0 validation_1-logloss:0.027545
Accuracy: 100.00%
REPLY Jason Brownlee May 14, 2017 at 7:22 am #
Very nice!
REPLY omogbeyin May 14, 2017 at 12:15 pm #
Thank you for the good work sir.
REPLY Jason Brownlee May 15, 2017 at 5:51 am #
I’m glad it helped.
REPLY davalo May 23, 2017 at 8:38 am #
Thanks for your post!
REPLY Jason Brownlee May 23, 2017 at 10:41 am #
Thanks davalo, I’m glad it helped.
REPLY Markos Flavio August 11, 2017 at 11:10 am #
Hi Jason, I have a question about early-stopping.
After saving the model that achieves the best validation error (say on epoch 50), how can I retrain it (to achieve better results) using this knowledge?
Is it valid to retrain it on a mix of training and validation sets considering those 50 epochs and expect to get the best result again? I know that some variance may occur after adding some more examples, but considering standard proportion values of dataset cardinalities (train=0.6, cv= 0.2, test=0.2), retraining the model using validation data is sufficient to ruin my previous result of 50 epochs? What’s the best practical in, say, a ML competition?
Another quick question: how do you manage validation sets for hyperparameterization and early stopping? Do you use the same set?
Thank you very much, Markos.
REPLY Jason Brownlee August 12, 2017 at 6:43 am #
Good question.
There’s no clear answer, you must experiment.
Perhaps you could train 5-10 models for 50 epochs and ensemble them. Perhaps compare the ensemble results to one-best model found via early stopping.
I split the training set into training and validation, see this post:
http://machinelearningmastery.com/difference-test-validation-datasets/

「深度学习福利」大神带你进阶工程师,立即查看>>>
Hadoop中自带的hadoop-mapreduce-examples-2.7.6.jar含有一些事例,本文将用pi计算圆周率。若想了解其计算原理,参考： http://thinkinginhadoop.iteye.com/blog/710847 。
具体步骤如下：
1. 启动Hadoop
切换到Hadoop安装目录下的sbin目录下执行 ./start-all.sh 命令
或执行 ./start-dfs.sh 和 ./start-yarn.sh 两条命令
2. 使用hadoop-mapreduce-examples-2.7.6.jar计算圆周率
hadoop jar ../share/hadoop/mapreduce/hadoop-mapreduce-examples-2.7.6.jar pi 10 10
其中：第一个10是指运行10次map任务,第二个10是指每个map任务投掷次数,所以总投掷次数是10×10=100。

「深度学习福利」大神带你进阶工程师,立即查看>>>
精准搜索方法（精确查找算法）
基于树: 搜索树算法(深度优先搜索/回溯算法 广度优先搜索 双向广度优先搜索), 蒙特卡洛树搜索
基于hash: hash查找
其他: 枚举算法 A*算法
相似搜索方法（精确查找算法）
基于树: kd树算法
基于hash: lsh算法, 百万到千万量, 如FALCONN和NMSLIB
基于矢量量化： pq算法, 亿级以上, 如Faiss
传统聚类
基于划分: kmeans
基于层次: 分解/聚合
基于统计: EM
基于密度: meanshift, dbscan
高维聚类
难点: 1.距离函数难于定义
2.基于距离的聚类可能失效(如果簇间距太小)
3.维度高引入的计算复杂度
基于超图：边有多点
基于子空间聚类（特征选择）: clique, optics
基于降维(向量压缩): 自组织特征映射,PCA,多维缩放
联合聚类: OLAP思想

「深度学习福利」大神带你进阶工程师,立即查看>>>
HanLP的Python接口,支持自动下载与升级HanLP,兼容py2、py3。
安装
pip install pyhanlp
使用命令hanlp来验证安装,如因网络等原因自动安装失败,可参考手动配置或Windows指南。
命令行
中文分词
使用命令hanlp segment进入交互分词模式,输入一个句子并回车,HanLP会输出分词结果：

$ hanlp segment
商品和服务
商品/n 和/cc 服务/vn
当下雨天地面积水分外严重
当/p 下雨天/n 地面/n 积水/n 分外/d 严重/a
龚学平等领导说,邓颖超生前杜绝超生
龚学平/nr 等/udeng 领导/n 说/v ,/w 邓颖超/nr 生前/t 杜绝/v 超生/vi
还可以重定向输入输出到文件等：
$ hanlp segment <<< '欢迎新老师生前来就餐'
欢迎/v 新/a 老/a 师生/n 前来/vi 就餐/vi

依存句法分析
命令为hanlp parse,同样支持交互模式和重定向：

服务器
通过hanlp serve来启动内置的http服务器,默认本地访问地址为：http://localhost:8765 ；也可以访问官网演示页面：http://hanlp.hankcs.com/ 。

升级
通过hanlp update命令来将HanLP升级到最新版。该命令会获取HanLP主项目最新版本并自动下载安装。
欢迎通过hanlp --help查看最新帮助手册。

API
通过工具类HanLP调用常用接口：

from pyhanlp import *

print(HanLP.segment('你好,欢迎在Python中调用HanLP的API'))
for term in HanLP.segment('下雨天地面积水'):
print('{}\t{}'.format(term.word, term.nature)) # 获取单词与词性
testCases = [
"商品和服务",
"结婚的和尚未结婚的确实在干扰分词啊",
"买水果然后来世博园最后去世博会",
"中国的首都是北京",
"欢迎新老师生前来就餐",
"工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作",
"随着页游兴起到现在的页游繁盛,依赖于存档进行逻辑判断的设计减少了,但这块也不能完全忽略掉。"]
for sentence in testCases: print(HanLP.segment(sentence))
# 关键词提取
document = "水利部水资源司司长陈明忠9月29日在国务院新闻办举行的新闻发布会上透露," \
"根据刚刚完成了水资源管理制度的考核,有部分省接近了红线的指标," \
"有部分省超过红线的指标。对一些超过红线的地方,陈明忠表示,对一些取用水项目进行区域的限批," \
"严格地进行水资源论证和取水许可的批准。"
print(HanLP.extractKeyword(document, 2))
# 自动摘要
print(HanLP.extractSummary(document, 3))
# 依存句法分析
print(HanLP.parseDependency("徐先生还具体帮助他确定了把画雄鹰、松鼠和麻雀作为主攻目标。"))

更多功能
更多功能,包括但不限于： 自定义词典 极速词典分词 索引分词 CRF分词 感知机词法分析 臺灣正體、香港繁體 关键词提取、自动摘要 文本分类、情感分析
请阅读HanLP主项目文档和demos目录以了解更多。调用更底层的API需要参考Java语法用JClass引入更深的类路径。以感知机词法分析器为例,这个类位于包名com.hankcs.hanlp.model.perceptron.PerceptronLexicalAnalyzer下,所以先用JClass得到类,然后就可以调用了：

PerceptronLexicalAnalyzer = JClass('com.hankcs.hanlp.model.perceptron.PerceptronLexicalAnalyzer')
analyzer = PerceptronLexicalAnalyzer()
print(analyzer.analyze("上海华安工业（集团）公司董事长谭旭光和秘书胡花蕊来到美国纽约现代艺术博物馆参观"))

输出：
[上海/ns 华安/nz 工业/n （/w 集团/n ）/w 公司/n]/nt 董事长/n 谭旭光/nr 和/c 秘书/n 胡花蕊/nr 来到/v [美国/ns 纽约/ns 现代/t 艺术/n 博物馆/n]/ns 参观/v
如果你需要多线程安全性,可使用SafeJClass；如果你需要延迟加载,可使用LazyLoadingJClass。如果你经常使用某个类,欢迎将其写入pyhanlp/__init__.py中并提交pull request,谢谢！

与其他项目共享data
HanLP具备高度可自定义的特点,所有模型和词典都可以自由替换。如果你希望与别的项目共享同一套data,只需将该项目的配置文件hanlp.properties拷贝到pyhanlp的安装目录下即可。本机安装目录可以通过hanlp --version获取。

同时,还可以通过--config临时加载另一个配置文件：

hanlp segment --config path/to/another/hanlp.properties

测试
git clone https://github.com/hankcs/pyhanlp.git
cd pyhanlp
pip install -e .
python tests/test_hanlp.py

文章转载自github.com/hankcs/pyhanlp

「深度学习福利」大神带你进阶工程师,立即查看>>>
==虹软官网地址==
http://www.arcsoft.com.cn
在官网注册账号,并且申请人脸识别激活码, 选择SDK版本和运行系统(windows/linux/android/ios) ,我们选择windows做测试,申请类型选择1:N ,功能模块包括人脸检测、人脸跟踪、人脸识别。申请之后会获取APP_ID 和SDK_Key,在代码中会用到。
==虹软SDK人脸检测目的==
主要是与face++人脸检测做对比,看能否在face++人脸检测之前选择虹软事先检测一下。
==c++部分功能实现==
选择 Qtcreator 4.2.1 ,新建c++ 库。 设置Qt .pro文件 #不加载Qt库 QT -= core gui #生成库名字 TARGET = detect_lib #定义生成lib TEMPLATE = lib DEFINES += DETECT_LIB_LIBRARY SOURCES += detect_lib.cpp #加载虹软sdk头文件 HEADERS += detect_lib.h \ inc/amcomdef.h \ inc/ammem.h \ inc/arcsoft_fsdk_face_detection.h \ inc/asvloffscreen.h \ inc/merror.h unix { target.path = /usr/lib INSTALLS += target } unix|win32: LIBS += -L$$PWD/lib/ -llibarcsoft_fsdk_face_detection INCLUDEPATH += $$PWD/. DEPENDPATH += $$PWD/.
上面是.pro文件,主要是一些配置信息,如生成库名字 加载虹软SDK 和头文件...
下面是detect_lib.h文件 主要供nodejs调用的接口文件。 #ifndef DETECT_LIB_H #define DETECT_LIB_H # ifdef __cplusplus # define EXTERN_NAME extern "C" # else # define EXTERN_NAME extern # endif #if defined(WIN32) # define Q_DECL_EXPORT __declspec(dllexport) # define Q_DECL_IMPORT __declspec(dllexport) #if defined(DETECT_LIB_LIBRARY) # define DETECT_LIBSHARED_EXPORT EXTERN_NAME Q_DECL_EXPORT # else # define DETECT_LIBSHARED_EXPORT EXTERN_NAME Q_DECL_IMPORT #endif #else # define DETECT_LIBSHARED_EXPORT EXTERN_NAME #endif DETECT_LIBSHARED_EXPORT int add(int a,int b); DETECT_LIBSHARED_EXPORT int detect(unsigned char * data,int width,int height); #endif // DETECT_LIB_H
接口add 函数 主要做测试用
int detect(unsigned char * data,int width,int height);
检测人脸函数, data：rgb像素值,width：图片宽度,height：图片高度
detect_lib.cpp #include #include "detect_lib.h" using namespace Nan ; using namespace v8; class DetectWorker : public AsyncWorker { public: DetectWorker(Callback *callback, unsigned char* buffer,int width,int height) : AsyncWorker(callback), p_buffer(buffer), m_width(width),m_height(height) {m_num = 0;} ~DetectWorker() {} //这个函数运行在工作线程,而不是v8线程,所以不能访问v8的数据 void Execute () { //m_num = add(12,3); m_num = detect(p_buffer,m_width,m_height); // m_num = 5; } //这个是libuv的回调函数,在这里可以使用v8的数据 void HandleOKCallback () { Local