主页 > 案例大全 > 论文方式解析-时空大数据预测和异常检测的研究与实现

论文方式解析-时空大数据预测和异常检测的研究与实现

2021-04-01 13:08:52

  在当今社会中,人们总是会提到“大数据”,甚至认为全球的信息发展已经进入了“大数据时代”。随着新兴信息技术的迅速发展,所有的变化,都成为了可被感知、记录、存储、分析的利用数据。

  人工智能是?计算机学科的一个分支,近三十年来它获得了迅速的发展。人工智能是研究使计算机来模拟人的某些思维过程和智能行为,主要包括计算机实现智能的原理、制造类似于人脑智能的计算机,使计算机能实现更高层次的应用。

  机器学习是实现人工智能的最主要的途径,即以机器学习为手段解决人工智能中的问题。机器学习算法是一类从数据中自动分析获得规律(模型),并利用规律对未知数据进行预测的算法。本文采用机器学习的方式实现时空大数据预测和异常检测的研究与实现。

  “时空大数据时代”的到来也不是偶然的,它来自于智能感知技术、互联网、物联网和云计算等新兴信息技术的推动,来自于天空地海一体的对地观测所形成的泛在测绘。时空大数据主要基于两个事实:首先是人类生活在地球(或其它星体)上,一切活动都是在一定的时空环境中进行的,而所有大数据都是人类活动的产物;其次,从可视化的角度来看,只有将所有的大数据与时空数据整合起来,才能直观地为人类提供大数据的空间概念(空间分布、趋势)。从这个意义上讲,大数据本身就发生在一定的时间和空间。大数据本质上是时空大数据。时空大数据强调大数据与时空数据的融合,并以时空大数据的生成为分析和挖掘的对象。分析和挖掘的过程是在时空中进行的。分析和挖掘的结果反映了时间变化和空间分布的趋势。

  大数据的本质是解决问题,大数据的核心价值就在于预测,而企业经营的核心也是基于预测而做出正确判断。在谈论大数据应用时,最常见的应用案例便是“预测股市”“预测流感”“预测消费者行为”等。

  大数据预测则是基于大数据和预测模型去预测未来某件事情的概率。让分析从“面向已经发生的过去”转向“面向即将发生的未来”这是是大数据分析与传统数据分析的最大不同。

  1.1.1国内研究现状

  中国最大的电子商务公司阿里巴巴已经在利用大数据技术提供服务:阿里信用贷与淘宝数据魔方。每天有数以万计的交易在淘宝上进行。与此同时相应的交易时间、商品价格、购买数量会被记录,更重要的是,这些信息可以与买方和卖方的年龄、性别、地址、兴趣爱好等个人特征信息相匹配。各大中小城市的百货大楼做不到这一点,大大小小的超市也做不到这一点,而互联网时代的淘宝可以。淘宝数据魔方就是淘宝平台上的大数据应用方案,通过这一服务,商家可以了解淘宝平台上的行业宏观情况、自己品牌的市场状况和消费者行为情况等,并可以据此进行生产、库存决策。而与此同时,更多的消费者也可以更优惠的价格买到心仪的宝贝。而阿里信用贷则是阿里巴巴通过掌握的企业交易数据,借助大数据技术自动分析判定是否给予企业贷款,裙撑不会出现人工干预。截至2017年,阿里巴巴已经放款300多亿元,坏账率约0.3%左右,大大低于商业银行。

  腾讯利用大数据技术促使腾讯视频成为国内第一。腾讯视频凭借全平台资源,建立ISEE内容精细化运营战略,利用腾讯视频的庞大数据资源,了解用户喜好和用户的常见行为。通过技术优势带给用户恒昊的观看体验。最后借助腾讯视频社区化的关系链和多平台触达能力,让营销内容得到最大范围的传播,致力于成为国内最大的在线视频媒体交流平台。

  创想智慧城市研究中心:数据量的激增以及大数据技术的特点使得社会对大数据技术的需求日益增加,各个领域均开始出现成功利用大数据的案例。政府、运营商、互联网企业是大数据技术的主要推动者,而未来有管大数据的投资讲主要集中在客户的精准营销、智慧城市建设、电子商务等几个领域。

  1.1.2国外研究现状

  国国家科学基金会(NSF)则将大数据定义为“由科学仪器、传感设备、互联网交易、电子邮件、音视频软件、网络点击流等多种数据源生成的大规模、多元化、复杂、长期的分布式数据集”。Wiki对大数据的定义为:所涉及的资料量规模巨大到无法透过目前主流软件工具,在合理时间内达到撷取、管理、处理、并整理成为帮助企业经营决策更积极目的的资讯。

  麦肯锡全球数据分析研究所在2011年5月发表的一篇论文中所说:“大数据是指大小超出了典型数据库工具收集、存储、管理和分析能力的数据集。”但它同时指出“大数据”并非总是说有数百个TB才算得上。根据实际使用情况,有时候数百个GB的数据也可称为大数据,这主要要看它的第三个维度,也就是速度或者时间维度。

  权威IT研究与顾问咨询公司Gartner将大数据定义为“在一个或多个维度上超出传统信息技术的处理能力的极端信息管理和处理问题”。IBM公司把大数据概括为规模Volume快速Velocity和多样Variety,即3V,而4V则是3V的基础上多一个Value价值。具体来讲,Volume指数据量极大并仍在持续增大;Velocity指所需的处理速度快,响应时间短;Variety指数据类型繁多,包括结构化数据、半结构化数据甚至是非结构化数据(以此区分大数据与海量数据两个概念);Value指价值密度低,以视频为例,不间断的监控录像中,有用的数据长度可能仅有一两秒。

  国外公共文化大数据的实践:丹佛公共图书馆——开展服务递送大数据项目获取公众需求;德国数字图书馆——开放整合数据提高资源利用率;科罗拉多历史博物馆——数据分析洞察观众需求;英国国家美术馆——开放数字绘画满足文化需求;法国政府——开放数据近端移动项目使文化服务无处不在。

  2概述

  2.1交通时空大数据和医疗时空大数据概述

  智能交通系统(ITS)拥有实时的交通和天气信息,所有车辆都能够预先知道并避开交通堵塞,减少二氧化碳的排放,沿最快捷的路线到达目的地,能随时找到最近的停车位,甚至在大部分时间车辆可以自动驾驶,而乘客可以在旅途中欣赏在线电视节目。

  这需要信息技术、交通大数据、先进交通管理给予支持。依托城市交通信息中心,实现城市公共汽车系统、出租车系统与轨道交通系统、交通信号系统、电子通信系统、车辆导航系统、电子地图系统综合集成的一体化交通信息管理。

  目前智能交通已经取得以下应用实例:

  1)利用智能交通信息技术支撑,交通大数据支撑,先进交通管理支持等,实现道路的“零堵塞”、“零伤亡”和“极限同行能力”。

  2)利用车辆轨迹和交通监控数据,为政府改善交通状况,为乘客提供交通信息,为驾驶员提高行车效益提供帮助。

  3)根据用户历史数据,为司机和乘客设计一种双向最优出租车招车/候车服务模型。

  4)基于出租车GNSS轨迹数据,并结合天气及个人驾驶习惯、技能和对道路的熟悉程度等,设计针对个人的最优导航算法,可平均为每30min的行车路线节约5min时间。

  5)利用车联网技术和用户车辆惯性传感器数据,汇集司机急刹、急转等驾驶行为数据,预测司机的移动行为,为司机提供主动安全预警服务。

  智慧医疗是为了实现各级医院之间人才资源、医疗信息资源和医疗文献资源共享。

  信息技术支持:人的身体和生理微型感知技术;互联网远程医疗技术;医学影像分析处理和三维仿真技术;计算机电子医疗档案技术;医疗卫生物联网技术。

  医疗大数据支持:城市医疗卫生机构(行政机构、各类各级医院、卫生院所、保健、药品商店、急救中心等)的空间分布数据;地方病、流行病、急性传染病数据;各类各级医院特色(专业)、人才、床位、医疗档案(病历)、大型专业和特殊设备、医疗文献等数据;个人保健数据。

  目前智能医疗已经取得以下应用实例:

  1)流感传播预测:美国Rochester大学的AdemSadliek等人,利用全球定位系统数据,分析纽约63万多微博用户的440万条微博数据,绘制身体不适用户位置“热点”地图,显示流感在纽约的传播情况,指出最早可在个人出现流感症状之前8天做出预测,准确率达90%。

  2)个人保健:通过安装在人身的各类传感器,对人的健康指数(体温、血压、心电图、血氧等)进行监测,并实时传递至医疗保健中心,如有异常,保健中心会通过手机,提醒你去医院检查身体。

  3)远程医疗:通过国家卫生信息网络,利用医疗资源共享及检查结果互认数据以及急重病人异地送诊过程中的实时监控数据,在线会诊分析、治疗和途中急救等。

  2.2交通时空大数据和医疗时空大数据概述

  智能交通系统(ITS)拥有实时的交通和天气信息,所有车辆都能够预先知道并避开交通堵塞,减少二氧化碳的排放,沿最快捷的路线到达目的地,能随时找到最近的停车位,甚至在大部分时间车辆可以自动驾驶,而乘客可以在旅途中欣赏在线电视节目。这需要信息技术、交通大数据、先进交通管理给予支持。依托城市交通信息中心,实现城市公共汽车系统、出租车系统与轨道交通系统、交通信号系统、电子通信系统、车辆导航系统、电子地图系统综合集成的一体化交通信息管理。

  智慧医疗是为了实现各级医院之间人才资源、医疗信息资源和医疗文献资源共享。

  信息技术支持:人的身体和生理微型感知技术;互联网远程医疗技术;医学影像分析处理和三维仿真技术;计算机电子医疗档案技术;医疗卫生物联网技术。医疗大数据支持:城市医疗卫生机构(行政机构、各类各级医院、卫生院所、保健、药品商店、急救中心等)的空间分布数据;地方病、流行病、急性传染病数据;各类各级医院特色(专业)、人才、床位、医疗档案(病历)、大型专业和特殊设备、医疗文献等数据;个人保健数据。

  2.3研究基本方法和技术

  编程:python

  模型搭建:tensorflow

  机器学习工具:WEKA

  开发机器学习应用:数据收集、样本标注、特征抽取、模型训练、模型应用。

  tensorflow模型搭建:用RNN进行IMDb情感分析、MNIST手写数字识别。

  3基于机器学习的大数据预测和异常检测解决方案

  3.1机器学习

  机器学习是人工智能的一个分支。机器学习是实现人工智能的最主要的途径,即以机器学习为手段解决人工智能中的问题。机器学习算法是一类从数据中自动分析获得规律(模型),并利用规律对未知数据进行预测的算法。

  开发机器学习应用的步骤

  1、数据收集:收集数据的方式包括自有数据中心(通过传感器、信息系统等方式采集)、网络爬虫、付费API等。多数情况下还要对收集到的数据进行清洗、格式化等预处理。

  2、样本标注:机器学习模型的执行是以样本为单位的,需要将原始数据组织成样本的形式并进行标签的标注。标签是用于表示样本的一个类型或数值。

  3、特征抽取:针对每一个样本,计算对问题具有描述能力的特征(大部分情况下,原始数据的属性无法很好的描述问题)。

  4、模型训练:选择一个算法(如决策树、支持向量机、神经网络等)进行机器学习模型的训练。在此基础上还要对模型的效果进行检验和评估。

  5、模型应用:给定一个未知标注的样本,首先抽取其特征(与训练时的特征一致),然后输入训练好的模型即能得到预测的标注。

  3.2tensorflow模型搭建

  TensorFlow使用Tensor来表示数据,使用graph来表示计算任务,在session中运行图,通过variable维护状态

  4需求及可行性分析

  4.1需求分析

  目前,我国的城市信息化建设绝大部分还停留在数字化、网络化阶段,而一旦数字化、网络化发展成熟,积累了大量数据,势必就会产生进一步的信息化需求,这就是智能化。简单地说,智慧城市就是让城市更聪明,本质上是让作为城市主体的人更聪明。通过互联网把无处不在的被植入城市物体的智能化传感器连接起来形成的物联网,实现对物理城市的全面感知,利用云计算等技术对感知信息进行智能处理和分析,实现网上“数字城市”与物联网的融合,并发出指令,对包括政务、民生、环境、公共安全、城市服务、工商活动等在内的各种需求做出智能化响应和智能化决策支持。

  4.2可行性分析

  截至2015年底,我国智慧城市建设的数量已达到386个,其中省级和副省级智慧城市建设达到100%,地级市建设智慧城市达到74%,县级城市建设智慧城市达到32%,取得了一些进展,但也暴露了许多问题,主要表现在:缺乏国家层面的顶层设计与综合协调机制;缺乏健全的信息安全技术、机制与体系;缺乏应对大数据挑战的技术与管理机制;缺乏智慧城市建设的风险认识和对应策略;盲目跟风,无明确目标;协调不够,各自为政;试点过多,流于形式;体制机制缺乏创新。

  根据智慧城市建设中暴露出来的问题,亟待加强顶层设计、统筹规划、科学引导、有序推进。正是在这种情况下,国家发展改革委、中央网络办等25个部委于2016年5月联合成立了新型智慧城市建设部级协调工作组。新型智慧城市是适应新型智慧城镇化建设,以信息化创新引领城市发展转型,全面推进新一代信息通信技术与城市发展融合创新,加快工业化、信息化、城镇化、农业现代化融合,提高城市治理能力现代化水平,实现城市可持续发展的新路径、新模式、新形态。

  新型智慧城市对时空信息的需求,主要体现在智慧城市时空信息云平台建设(如图1所示)。其中:

  1)共享。指地理时空数据为城市各部门(行业)共享(城市“一张图”),即各部门(行业)在统一的地理时空数据基础上建设各自的业务应用系统。

  2)交换。各部门(行业)能交换的信息都应以统一地理时空数据进行定位,相互交换,避免出现不一致现象。

  3)聚合。指各部门(行业)除不能公开的信息都应聚合在统一的地理时空数据上,以建立城市综合决策系统。

  4)传感网接入。指时空信息云平台应是一个开放共享平台,包括具有空间位置特征的地面传感网(如大气、地面温度、水质监测、土壤监测等)和地下管线智能感知设备等,都应能接入时空信息云平台。

  5)时空大数据体系。指传感网接入数据、地理时空数据与各部门(行业)融合的数据所建成的时空大数据集,并对其进行一致性处理,形成时空大数据体系。

  6)时空大数据统计分析与挖掘。指对时空大数据进行时间序列和空间趋势的统计分析和数据挖掘,发现知识,为空间决策支持系统提供知识服务。

  5总体设计

  5.1实验数据收集、实验环境搭建

  Tensorflow介绍:

  TensorFlow是一个开源的、基于Python的机器学习框架,它由Google开发,并在图形分类、音频处理、推荐系统和自然语言处理等场景下有着丰富的应用,是目前最热门的机器学习框架。

  除了Python,TensorFlow也提供了C/C++、Java、Go、R等其它编程语言的接口。

  可视化数据流图:

  TensorFlow?使用TensorBoard来提供计算图形的图形图像。这使得理解、调试和优化复杂的神经网络程序变得很方便。TensorBoard也可以提供有关网络执行的量化指标。它读取TensorFlow事件文件,其中包含运行TensorFlow会话期间生成的摘要数据。

  Tensorflow安装:

  1、从官方网站下载Anaconda

  https://www.anaconda.com/download/

  2.进行软件安装

  3.安装完成Anaconda之后进行环境变量测试

  4、进行正式的安装tensflow

  5.通过命令:pipinstall--upgrade--ignore-installedtensorflow安装

  6、确认是否安装成功

  机器学习代码:

  importrandom

  defread_csv_file(filePath):

  fin=open(filePath,'r')

  alllines=fin.readlines()

  fin.close()

  samples=[]

  forlineinalllines:

  values=line.split(',')

  feature1=float(values[0])

  feature2=float(values[1])

  feature3=float(values[2])

  feature4=float(values[3])

  label=values[4].rstrip('\n')

  sample=(feature1,feature2,feature3,feature4,label)

  samples.append(sample)

  returnsamples

  defdump_arff_file(filePath,samples):

  fout=open(filePath,'w')

  fout.write("@relationiris\n\n")

  fout.write("@attributesepal_lengthreal\n")

  fout.write("@attributesepal_widthreal\n")

  fout.write("@attributepetal_lengthreal\n")

  fout.write("@attributepetal_widthreal\n")

  fout.write("@attributeclass{Iris-setosa,Iris-versicolor,Iris-virginica}\n\n")

  fout.write("@data\n")

  forsampleinsamples:

  fout.write("%s,%s,%s,%s,%s\n"%(sample[0],sample[1],sample[2],sample[3],sample[4]))

  fout.flush()

  fout.close()

  samples=read_csv_file('iris.data.csv')

  random.shuffle(samples)

  forsampleinsamples:

  print(sample)

  dump_arff_file('iris.data.arff',samples)

  print('finished!')

  Tensorflow:

  {

  "cells":[

  {

  "cell_type":"markdown",

  "metadata":{},

  "source":[

  "#数据预处理"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":1,

  "metadata":{

  "collapsed":false,

  "scrolled":true

  },

  "outputs":[

  {

  "name":"stderr",

  "output_type":"stream",

  "text":[

  "UsingTensorFlowbackend.\n"

  ]

  }

  ],

  "source":[

  "fromkeras.utilsimportnp_utils\n",

  "importnumpyasnp\n",

  "np.random.seed(10)"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":2,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "fromkeras.datasetsimportmnist\n",

  "(x_train_image,y_train_label),\\\n",

  "(x_test_image,y_test_label)=mnist.load_data()"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":3,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "x_Train=x_train_image.reshape(60000,784).astype('float32')\n",

  "x_Test=x_test_image.reshape(10000,784).astype('float32')"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":4,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "x_Train_normalize=x_Train/255\n",

  "x_Test_normalize=x_Test/255"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":5,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "y_Train_One_Hot=np_utils.to_categorical(y_train_label)\n",

  "y_Test_One_Hot=np_utils.to_categorical(y_test_label)"

  ]

  },

  {

  "cell_type":"markdown",

  "metadata":{

  "collapsed":true

  },

  "source":[

  "#建立模型"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":6,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "fromkeras.modelsimportSequential\n",

  "fromkeras.layersimportDense\n",

  "fromkeras.layersimportDropout"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":7,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "model=Sequential()"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":8,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "#将“输入层”与“隐藏层”加入模型"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":9,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "model.add(Dense(units=1000,\n",

  "input_dim=784,\n",

  "kernel_initializer='normal',\n",

  "activation='relu'))"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":10,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "model.add(Dropout(0.5))"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":11,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "#将“输出层”加入模型"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":12,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "model.add(Dense(units=10,\n",

  "kernel_initializer='normal',\n",

  "activation='softmax'))"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":13,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "name":"stdout",

  "output_type":"stream",

  "text":[

  "_________________________________________________________________\n",

  "Layer(type)OutputShapeParam#\n",

  "=================================================================\n",

  "dense_1(Dense)(None,1000)785000\n",

  "_________________________________________________________________\n",

  "dropout_1(Dropout)(None,1000)0\n",

  "_________________________________________________________________\n",

  "dense_2(Dense)(None,10)10010\n",

  "=================================================================\n",

  "Totalparams:795,010\n",

  "Trainableparams:795,010\n",

  "Non-trainableparams:0\n",

  "_________________________________________________________________\n",

  "None\n"

  ]

  }

  ],

  "source":[

  "print(model.summary())"

  ]

  },

  {

  "cell_type":"markdown",

  "metadata":{},

  "source":[

  "#训练模型"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":14,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "model.compile(loss='categorical_crossentropy',\n",

  "optimizer='adam',metrics=['accuracy'])"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":15,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "name":"stdout",

  "output_type":"stream",

  "text":[

  "Trainon48000samples,validateon12000samples\n",

  "Epoch1/10\n",

  "6s-loss:0.3566-acc:0.8942-val_loss:0.1621-val_acc:0.9543\n",

  "Epoch2/10\n",

  "5s-loss:0.1604-acc:0.9532-val_loss:0.1168-val_acc:0.9662\n",

  "Epoch3/10\n",

  "5s-loss:0.1163-acc:0.9653-val_loss:0.0989-val_acc:0.9707\n",

  "Epoch4/10\n",

  "6s-loss:0.0929-acc:0.9722-val_loss:0.0909-val_acc:0.9722\n",

  "Epoch5/10\n",

  "5s-loss:0.0751-acc:0.9776-val_loss:0.0826-val_acc:0.9761\n",

  "Epoch6/10\n",

  "5s-loss:0.0624-acc:0.9801-val_loss:0.0770-val_acc:0.9773\n",

  "Epoch7/10\n",

  "5s-loss:0.0547-acc:0.9841-val_loss:0.0789-val_acc:0.9767\n",

  "Epoch8/10\n",

  "5s-loss:0.0491-acc:0.9851-val_loss:0.0742-val_acc:0.9782\n",

  "Epoch9/10\n",

  "5s-loss:0.0427-acc:0.9861-val_loss:0.0690-val_acc:0.9793\n",

  "Epoch10/10\n",

  "6s-loss:0.0378-acc:0.9885-val_loss:0.0664-val_acc:0.9802\n"

  ]

  }

  ],

  "source":[

  "train_history=model.fit(x=x_Train_normalize,\n",

  "y=y_Train_One_Hot,validation_split=0.2,\n",

  "epochs=10,batch_size=200,verbose=2)"

  ]

  },

  {

  "cell_type":"markdown",

  "metadata":{},

  "source":[

  "#以图形显示训练过程"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":16,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "importmatplotlib.pyplotasplt\n",

  "defshow_train_history(train_history,train,validation):\n",

  "plt.plot(train_history.history[train])\n",

  "plt.plot(train_history.history[validation])\n",

  "plt.title('TrainHistory')\n",

  "plt.ylabel(train)\n",

  "plt.xlabel('Epoch')\n",

  "plt.legend(['train','validation'],loc='upperleft')\n",

  "plt.show()"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":17,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "data":{

  "image/png":

  "text/plain":[

  ""

  ]

  },

  "metadata":{},

  "output_type":"display_data"

  }

  ],

  "source":[

  "show_train_history(train_history,'acc','val_acc')"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":18,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "data":{

  "image/png":

  "text/plain":[

  ""

  ]

  },

  "metadata":{},

  "output_type":"display_data"

  }

  ],

  "source":[

  "show_train_history(train_history,'loss','val_loss')"

  ]

  },

  {

  "cell_type":"markdown",

  "metadata":{},

  "source":[

  "#评估模型的准确率"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":19,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "name":"stdout",

  "output_type":"stream",

  "text":[

  "9920/10000[============================>.]-ETA:0s\n",

  "accuracy=0.9808\n"

  ]

  }

  ],

  "source":[

  "scores=model.evaluate(x_Test_normalize,y_Test_One_Hot)\n",

  "print()\n",

  "print('accuracy=',scores[1])"

  ]

  },

  {

  "cell_type":"markdown",

  "metadata":{},

  "source":[

  "#进行预测"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":20,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "name":"stdout",

  "output_type":"stream",

  "text":[

  "9888/10000[============================>.]-ETA:0s"

  ]

  }

  ],

  "source":[

  "prediction=model.predict_classes(x_Test)"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":21,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "data":{

  "text/plain":[

  "array([7,2,1,...,4,5,6],dtype=int64)"

  ]

  },

  "execution_count":21,

  "metadata":{},

  "output_type":"execute_result"

  }

  ],

  "source":[

  "prediction"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":22,

  "metadata":{

  "collapsed":true

  },

  "outputs":[],

  "source":[

  "importmatplotlib.pyplotasplt\n",

  "defplot_images_labels_prediction(images,labels,\n",

  "prediction,idx,num=10):\n",

  "fig=plt.gcf()\n",

  "fig.set_size_inches(12,14)\n",

  "ifnum>25:num=25\n",

  "foriinrange(0,num):\n",

  "ax=plt.subplot(5,5,1+i)\n",

  "ax.imshow(images[idx],cmap='binary')\n",

  "title=\"label=\"+str(labels[idx])\n",

  "iflen(prediction)>0:\n",

  "title+=\",predict=\"+str(prediction[idx])\n",

  "\n",

  "ax.set_title(title,fontsize=10)\n",

  "ax.set_xticks([]);ax.set_yticks([])\n",

  "idx+=1\n",

  "plt.show()"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":23,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "data":{

  "image/png":

  "text/plain":[

  ""

  ]

  },

  "metadata":{},

  "output_type":"display_data"

  }

  ],

  "source":[

  "plot_images_labels_prediction(x_test_image,y_test_label,\n",

  "prediction,idx=340)"

  ]

  },

  {

  "cell_type":"markdown",

  "metadata":{},

  "source":[

  "#confusionmatrix"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":24,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "data":{

  "text/html":[

  "

\n",

  "\n",

  "\n",

  "\n",

  "\n",

  "predict\n",

  "0\n",

  "1\n",

  "2\n",

  "3\n",

  "4\n",

  "5\n",

  "6\n",

  "7\n",

  "8\n",

  "9\n",

  "\n",

  ""

"

  ],

  "text/plain":[

  "predict0123456789\n",

  "label\n",

  "0973102001120\n",

  "10112730002030\n",

  "26110063302650\n",

  "31001000010332\n",

  "4104096601127\n",

  "53001518614152\n",

  "6620163937030\n",

  "72383100100632\n",

  "8501541129532\n",

  "94506132050974"

  ]

  },

  "execution_count":24,

  "metadata":{},

  "output_type":"execute_result"

  }

  ],

  "source":[

  "importpandasaspd\n",

  "pd.crosstab(y_test_label,prediction,\n",

  "rownames=['label'],colnames=['predict'])"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":25,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "data":{

  "text/html":[

  "

\n",

  "\n",

  "\n",

  "\n",

  "\n",

  "\n",

  "label\n",

  "predict\n",

  "\n",

  "\n",

  "\n",

  "\n",

  "0\n",

  "7\n",

  "7\n",

  "\n",

  "\n",

  "1\n",

  "2\n",

  "2\n",

  "\n",

  "\n",

  "\n",

  "

"

  ],

  "text/plain":[

  "labelpredict\n",

  "077\n",

  "122"

  ]

  },

  "execution_count":25,

  "metadata":{},

  "output_type":"execute_result"

  }

  ],

  "source":[

  "df=pd.DataFrame({'label':y_test_label,'predict':prediction})\n",

  "df[:2]"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":26,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "data":{

  "text/html":[

  "

\n",

  "\n",

  "\n",

  "\n",

  "\n",

  "\n",

  "label\n",

  "predict\n",

  "\n",

  "\n",

  "\n",

  "\n",

  "340\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "1003\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "1393\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "1670\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "2035\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "2526\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "2597\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "2810\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "3902\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "4271\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "4355\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "4360\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "5937\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "5972\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "5982\n",

  "5\n",

  "3\n",

  "\n",

  "\n",

  "\n",

  "

"

  ],

  "text/plain":[

  "labelpredict\n",

  "34053\n",

  "100353\n",

  "139353\n",

  "167053\n",

  "203553\n",

  "252653\n",

  "259753\n",

  "281053\n",

  "390253\n",

  "427153\n",

  "435553\n",

  "436053\n",

  "593753\n",

  "597253\n",

  "598253"

  ]

  },

  "execution_count":26,

  "metadata":{},

  "output_type":"execute_result"

  }

  ],

  "source":[

  "df[(df.label==5)&(df.predict==3)]"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":27,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "data":{

  "image/png":

  "text/plain":[

  ""

  ]

  },

  "metadata":{},

  "output_type":"display_data"

  }

  ],

  "source":[

  "plot_images_labels_prediction(x_test_image,y_test_label\n",

  ",prediction,idx=340,num=1)"

  ]

  },

  {

  "cell_type":"code",

  "execution_count":28,

  "metadata":{

  "collapsed":false

  },

  "outputs":[

  {

  "data":{

  "image/png":

  "text/plain":[

  ""

  ]

  },

  "metadata":{},

  "output_type":"display_data"

  }

  ],

  "source":[

  "plot_images_labels_prediction(x_test_image,y_test_label\n",

  ",prediction,idx=1289,num=1)"

  ]

  }

  ],

  "metadata":{

  "anaconda-cloud":{},

  "kernelspec":{

  "display_name":"Python[default]",

  "language":"python",

  "name":"python3"

  },

  "language_info":{

  "codemirror_mode":{

  "name":"ipython",

  "version":3

  },

  "file_extension":".py",

  "mimetype":"text/x-python",

  "name":"python",

  "nbconvert_exporter":"python",

  "pygments_lexer":"ipython3",

  "version":"3.5.2"

  }

  },

  "nbformat":4,

  "nbformat_minor":1

  }

  5.2时空大数据预测技术研发

  from__future__importdivision,print_function

  importtensorflowastf

  importmatplotlib.pyplotasplt

  importnumpyasnp

  #ImportMNISTdata

  importinput_data

  mnist=input_data.read_data_sets("MNIST_data",one_hot=True)

  deftrain_size(num):

  print('TotalTrainingImageinDataset='+str(mnist.train.images.shape))

  print('----------------------------------------------------')

  x_train=mnist.train.images[:num,:]

  print('x_trainExamplesLoaded='+str(x_train.shape))

  y_train=mnist.train.labels[:num,:]

  print('y_trainExamplesLoaded='+str(y_train.shape))

  print('')

  returnx_train,y_train

  deftest_size(num):

  print('TotalTestExamplesinDataset='+str(mnist.test.images.shape))

  print('----------------------------------------------------')

  x_test=mnist.test.images[:num,:]

  print('x_testExamplesLoaded='+str(x_test.shape))

  y_test=mnist.test.labels[:num,:]

  print('y_testExamplesLoaded='+str(y_test.shape))

  returnx_test,y_test

  defdisplay_digit(num):

  print(y_train[num])

  label=y_train[num].argmax(axis=0)

  image=x_train[num].reshape([28,28])

  plt.title('Example:%dLabel:%d'%(num,label))

  plt.imshow(image,cmap=plt.get_cmap('gray_r'))

  plt.show()

  defdisplay_mult_flat(start,stop):

  images=x_train[start].reshape([1,784])

  foriinrange(start+1,stop):

  images=np.concatenate((images,x_train[i].reshape([1,784])))

  plt.imshow(images,cmap=plt.get_cmap('gray_r'))

  plt.show()

  x_train,y_train=train_size(55000)

  x_test,y_test=test_size(2048)

  display_digit(np.random.randint(0,x_train.shape[0]))

  display_mult_flat(0,400)

  #Parameters

  learning_rate=0.001

  training_iters=500

  batch_size=128

  display_step=10

  #NetworkParameters

  n_input=784#MNISTdatainput(imgshape:28*28)

  n_classes=10#MNISTtotalclasses(0-9digits)

  dropout=0.85#Dropout,probabilitytokeepunits

  x=tf.placeholder(tf.float32,[None,n_input])

  y=tf.placeholder(tf.float32,[None,n_classes])

  keep_prob=tf.placeholder(tf.float32)

  defconv2d(x,W,b,strides=1):

  x=tf.nn.conv2d(x,W,strides=[1,strides,strides,1],padding='SAME')

  x=tf.nn.bias_add(x,b)

  returntf.nn.relu(x)

  defmaxpool2d(x,k=2):

  returntf.nn.max_pool(x,ksize=[1,k,k,1],strides=[1,k,k,1],padding='SAME')

  defconv_net(x,weights,biases,dropout):

  #reshapetheinputpicture

  x=tf.reshape(x,shape=[-1,28,28,1])

  #Firstconvolutionlayer

  conv1=conv2d(x,weights['wc1'],biases['bc1'])

  #MaxPoolingusedfordownsampling

  conv1=maxpool2d(conv1,k=2)

  #Secondconvolutionlayer

  conv2=conv2d(conv1,weights['wc2'],biases['bc2'])

  #MaxPoolingusedfordownsampling

  conv2=maxpool2d(conv2,k=2)

  #Reshapeconv2outputtomatchtheinputoffullyconnectedlayer

  fc1=tf.reshape(conv2,[-1,weights['wd1'].get_shape().as_list()[0]])

  #Fullyconnectedlayer

  fc1=tf.add(tf.matmul(fc1,weights['wd1']),biases['bd1'])

  fc1=tf.nn.relu(fc1)

  #Dropout

  fc1=tf.nn.dropout(fc1,dropout)

  #Outputtheclassprediction

  out=tf.add(tf.matmul(fc1,weights['out']),biases['out'])

  returnout

  weights={

  #5x5conv,1input,and32outputs

  'wc1':tf.Variable(tf.random_normal([5,5,1,32])),

  #5x5conv,32inputs,and64outputs

  'wc2':tf.Variable(tf.random_normal([5,5,32,64])),

  #fullyconnected,7x7x64inputs,and1024outputs

  'wd1':tf.Variable(tf.random_normal([7*7*64,1024])),

  #1024inputs,10outputsforclassdigits

  'out':tf.Variable(tf.random_normal([1024,n_classes]))

  }

  biases={

  'bc1':tf.Variable(tf.random_normal([32])),

  'bc2':tf.Variable(tf.random_normal([64])),

  'bd1':tf.Variable(tf.random_normal([1024])),

  'out':tf.Variable(tf.random_normal([n_classes]))

  }

  pred=conv_net(x,weights,biases,keep_prob)

  cost=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred,labels=y))

  optimizer=tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

  correct_prediction=tf.equal(tf.argmax(pred,1),tf.argmax(y,1))

  accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

  init=tf.global_variables_initializer()

  train_loss=[]

  train_acc=[]

  test_acc=[]

  withtf.Session()assess:

  sess.run(init)

  step=1

  whilestep<=training_iters:

  batch_x,batch_y=mnist.train.next_batch(batch_size)

  sess.run(optimizer,feed_dict={x:batch_x,y:batch_y,keep_prob:dropout})

  ifstep%display_step==0:

  loss_train,acc_train=sess.run([cost,accuracy],

  feed_dict={

  x:batch_x,

  y:batch_y,

  keep_prob:1.

  })

  print("Iter"+str(step)+",MinibatchLoss="+\

  "{:.2f}".format(loss_train)+",TrainingAccuracy="+\

  "{:.2f}".format(acc_train))

  #Calculateaccuracyfor2048mnisttestimages.

  #Notethatinthiscasenodropout

  acc_test=sess.run(accuracy,

  feed_dict={x:mnist.test.images,

  y:mnist.test.labels,

  keep_prob:1.})

  print("TestingAccuracy:"+"{:.2f}".format(acc_test))

  train_loss.append(loss_train)

  train_acc.append(acc_train)

  test_acc.append(acc_test)

  step+=1

  eval_indices=range(0,training_iters,display_step)

  #Plotlossovertime

  plt.plot(eval_indices,train_loss,'k-')

  plt.title('SoftmaxLossperiteration')

  plt.xlabel('Iteration')

  plt.ylabel('SoftmaxLoss')

  plt.show()

  #Plottrainandtestaccuracy

  plt.plot(eval_indices,train_acc,'k-',label='TrainSetAccuracy')

  plt.plot(eval_indices,test_acc,'r--',label='TestSetAccuracy')

  plt.title('TrainandTestAccuracy')

  plt.xlabel('Generation')

  plt.ylabel('Accuracy')

  plt.legend(loc='lowerright')

  plt.show()

  5.3时空大数据异常检测数据研发

  #-*-coding:utf-8-*-

  from__future__importdivision,print_function,absolute_import#使用python3规范

  importtflearn

  fromtflearn.data_utilsimportshuffle,to_categorical#混洗独热

  fromtflearn.layers.coreimportinput_data,dropout,fully_connected#数据输入、辍学、全连接

  fromtflearn.layers.convimportconv_2d,max_pool_2d#CNN池化

  fromtflearn.layers.estimatorimportregression#回归

  fromtflearn.data_preprocessingimportImagePreprocessing#图像预处理

  fromtflearn.data_augmentationimportImageAugmentation#图像增强

  #Dataloadingandpreprocessing

  fromtflearn.datasetsimportcifar10

  (X,Y),(X_test,Y_test)=cifar10.load_data()

  X,Y=shuffle(X,Y)

  Y=to_categorical(Y,10)

  Y_test=to_categorical(Y_test,10)

  #Real-timedatapreprocessing

  img_prep=ImagePreprocessing()

  img_prep.add_featurewise_zero_center()#均值

  img_prep.add_featurewise_stdnorm()#标准差

  #Real-timedataaugmentation

  img_aug=ImageAugmentation()

  img_aug.add_random_flip_leftright()#随机左右翻转

  img_aug.add_random_rotation(max_angle=25.)#随机旋转图像

  #Convolutionalnetworkbuilding

  network=input_data(shape=[None,32,32,3],data_preprocessing=img_prep,data_augmentation=img_aug)

  network=conv_2d(network,32,3,activation='relu')

  network=max_pool_2d(network,2)

  network=conv_2d(network,64,3,activation='relu')

  network=conv_2d(network,64,3,activation='relu')

  network=max_pool_2d(network,2)

  network=fully_connected(network,512,activation='relu')

  network=dropout(network,0.5)

  network=fully_connected(network,10,activation='softmax')

  network=regression(network,optimizer='adam',loss='categorical_crossentropy',learning_rate=0.001)

  #Trainusingclassifier

  model=tflearn.DNN(network,tensorboard_verbose=0)

  model.fit(X,Y,n_epoch=50,shuffle=True,validation_set=(X_test,Y_test),show_metric=True,batch_size=96,run_id='cifar10_cnn')

  5.4demo开发

  importnumpyasnp

  fromkeras.preprocessing.imageimportImageDataGenerator

  fromkeras.modelsimportSequential

  fromkeras.layersimportDropout,Flatten,Dense

  fromkerasimportapplications

  #dimensionsofourimages.

  img_width,img_height=256,256

  top_model_weights_path='bottleneck_fc_model.h5'

  train_data_dir='data/dogs_and_cats/train'

  validation_data_dir='data/dogs_and_cats/validation'

  nb_train_samples=4000

  nb_validation_samples=640

  epochs=50

  batch_size=16

  defsave_bottleneck_features():

  datagen=ImageDataGenerator(rescale=1./255)

  #buildtheVGG16network

  model=applications.VGG16(include_top=False,weights='imagenet')

  generator=datagen.flow_from_directory(

  train_data_dir,

  target_size=(img_width,img_height),

  batch_size=batch_size,

  class_mode=None,

  shuffle=False)

  bottleneck_features_train=model.predict_generator(generator,nb_train_samples//batch_size)

  np.save('bottleneck_features_train.npy',bottleneck_features_train)

  generator=datagen.flow_from_directory(

  validation_data_dir,

  target_size=(img_width,img_height),

  batch_size=batch_size,

  class_mode=None,

  shuffle=False)

  bottleneck_features_validation=model.predict_generator(generator,nb_validation_samples//batch_size)

  np.save('bottleneck_features_validation.npy',bottleneck_features_validation)

  deftrain_top_model():

  train_data=np.load('bottleneck_features_train.npy')

  train_labels=np.array([0]*(nb_train_samples//2)+[1]*(nb_train_samples//2))

  validation_data=np.load('bottleneck_features_validation.npy')

  validation_labels=np.array([0]*(nb_validation_samples//2)+[1]*(nb_validation_samples//2))

  model=Sequential()

  model.add(Flatten(input_shape=train_data.shape[1:]))

  model.add(Dense(256,activation='relu'))

  model.add(Dropout(0.5))

  model.add(Dense(1,activation='sigmoid'))

  model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics=['accuracy'])

  model.fit(train_data,train_labels,epochs=epochs,batch_size=batch_size,validation_data=(validation_data,validation_labels))

  model.save_weights(top_model_weights_path)

  save_bottleneck_features()

  train_top_model()

  #-*-coding:utf-8-*-

  importos

  importglob

  importshutil

  importsys

  defMv_cat_dog_in_different_file():

  images=glob.glob('kaggle/train/*.jpg')

  cat_path='data/dogs_and_cats/train/cats'

  dog_path='data/dogs_and_cats/train/dogs'

  fori,imageinenumerate(images):

  if'cat'inimage:

  shutil.copy(image,cat_path)

  elif'dog'inimage:

  shutil.copy(image,dog_path)

  else:

  print('数据集中存在异常数据:',image)

  sys.exit()

  ifi%5000==0:

  print('已经拷贝了%d张图像了'%(i))

  Mv_cat_dog_in_different_file()

  importglob

  importshutil

  importsys

  defGener_Valid():

  images=glob.glob('kaggle/train/*.jpg')

  cat_path='data/dogs_and_cats/validation/cats'

  dog_path='data/dogs_and_cats/validation/dogs'

  cat_num=0

  dog_num=0

  fori,imageinenumerate(images):

  #首先拷贝1000张猫到验证集中

  ifcat_num<1001:

  if'cat'inimage:

  shutil.copy(image,cat_path)

  cat_num=cat_num+1

  #然后拷贝狗的图像

  ifdog_num<1001:

  if'dog'inimage:

  shutil.copy(image,dog_path)

  dog_num=dog_num+1

  ifcat_num>=1001anddog_num>=1001:

  print('********已经拷贝了%d张猫,拷贝了%d张狗**********'%(cat_num,dog_num))

  sys.exit()

  Gener_Valid()