python|人工智能初识移动开发|数据结构与算法

0. 人工智能初识目前人工智能越来越火，比如说AlphaGo打败了李世石、人工智能dota2打败了世界顶级的中单选手、马斯克的jarvis智能家居管家、各大汽车厂商布局无人驾驶汽车、苹果手机的Siri等语音助手和智能医疗等。
0.1 课前准备：

需要有linux命令行基础（我的《linux探索之旅》、《鸟哥的私房菜》和慕课网的《linux达人养成计划》）、python和数学基础（线性代数、微积分、概率论）

0.2 课程主要内容：

课程的主要内容包括人工智能的理论知识、开发工具介绍、TensorFlow基础练习和应用实践，
通过这门课程可以了解到人工智能的知识点、python库的使用和TensorFlow框架的使用和应用开发。

0.3 知识点：

人工智能：深度学习、强化学习和神经网络等
python：各种python的常用库
TensorFlow：原理、循序渐进的使用，最终实战

0.4 TensorFlow的介绍：
TensorFlow它是google开源的基于数据流图的科学计算库，适用于机器学习。
TensorFlow的基本构架

【python|人工智能初识】TensorFlow的详细架构

TensorFlow的特点：

灵活性：只要可以将计算表示成数据流图，就可以使用TensorFlow
跨平台：linux、windows、android、ios、raspberry pi等
多语言：上层开发语言python、c++、java、go等
速度快：包含了XLA这款强大的线性代数编辑器
上手快：keras、estimiators等高层api
可移植性：代码几乎不加修改移植到cpu、gpu、tpu等平台上

TensorFlow的著名用途：

DeepMind（google）的AlphaGo、AlphaGo Zero的底层技术
google产品：搜索，gmail，翻译、地图、android、照片、youtube
开发出击败dota2世界顶级选手的AI的OpenAI使用TensorFlow

TensorFlow的大事记：

2015年11月9google在github上开源了TensorFlow
2016年4月13TensorFlow0.8版本发布，支持分布式
2016年4月29开发AlphaGo的deepmind团队转向TensorFlow
2016年5月12开源基于TF的最准确语法解析器Syntaxnet
2016年6月27：TensorFlow0.9版本发布，增加移动设备支持
2016年8月30：高层库TF-Slim发布，可以更简单快速定义模型
2017年2月15：TensorFlow1.0版本，提高了速度和灵活性
2017年8月17：TensorFlow1.3版本，Estimators估算器加入
2017年11月2：TensorFlow1.4版本，keras等高级库被加入核心

主要机器学习库的对比：

学习方法：

官网
视频+书籍（吴恩达的maching lerning coursera）还有吴恩达的深度学习课程
实战

依次学习人工智能、数学知识、机器学习、深度学习、TensorFlow
TensorFlow的安装形式有

virtualenv
pip：python软件包管理系统即pip installs packages递归缩写
docker
anaconda
源代码编译

0.5 课程需要用到的软件及其安装：
操作系统：Ubuntu 16.04
python：2.7.x
python库：numpy，matplotlib等
TensorFlow
任天堂N64游戏主机模拟器：Mupen64plus
虚拟机：vitualbox 5.x
安装过程：这个过程等在自己电脑上实现后，编写出来步骤。
1. 人工智能、机器学习、深度学习的定义三者的范围

1.1 定义和分类：
机器学习等同通过训练找到一个好的函数模型，然后可以更好的预测出数据。
机器学习分为监督学习、无监督学习、半监督学习、强化学习

监督学习（supervised learning）：带标签
无监督学习（unsupervised learning）：不带标签，cluster（聚类）
半监督学习（semi-supervised learning）：少量标签
强化学习（（reinforcement learning））：基于环境而行动，以取得最大化预期利益

机器学习6步走：收集数据、准备数据（特征数据）、选择/建立模型、训练模型、测试模型、调节参数
机器学习关键的三步：

找一系列函数来实现预期的功能：建模问题
找一组合理的评价标准，来评估函数的好坏：评价问题
快速找到性能最佳的函数：优化问题（比如梯度下降就是这个目的）

深度学习：基于深度神经网络的学习研究称之为深度学习
深度学习的工作原理：

1、在神经网络中正向传播参数信号，经过隐藏层处理，输出结果
2、计算和预期的差距（误差），反向传播误差（BP算法），调整网络参数权重（还可以进行模型的调整）
3、不断地进行：正向传播->计算误差->反向传播->调整权重

1.2 过拟合问题：
过拟合：一丝不苟的拟合数据导致模型的泛化能力弱
解决办法：

降低数据量
正则化
dropout

1.3 人工智能发展简史：

沃伦.麦卡洛克和沃尔特.皮茨在1943年创造了神经网络的计算模型
由约翰.麦卡锡等人在1956年发起的达特茅斯会议（定义AI）
罗森布拉特1957年发明了感知器这种最简单的人工神经网络，从而出现了第一个高峰
1970年后的10几年是人工智能的第一个寒冬，原因是传统的感知器耗费的计算量和神经元的舒服平方成正比，计算机性能不够
RNN递归神经网络：由约翰、霍普菲尔德在1982年发明的一种递归神经网络，它具有反馈机制

1986大卫.鲁姆哈特完整提出了BP算法（back propagation），它最初是由保罗.沃伯斯于1974年发明。从而出现了第二个高峰
1990年开始，由于美国政府资助的人工智能计算机Darpa没能实现，导致人工智能进入了第二个寒冬
2006年杰弗里.辛顿提出基于深度（多层）的神经网络，从而出现了第三次热潮
人工智能进入了感知智能时代（运算智能、感知智能、认知智能）

2. TensorFlow的使用 2.1 创建一个简单的helloword显示：

mkdir mooc //创建目录mooc cd mooc//进入到目录mooc中 mkdir 1.helloworld//创建1.helloworld目录 cd 1.hellworld///进入到1、helloworld目录中 vim helloworld.py//用vim编辑器生成并且编辑helloworld.py //以下为helloworld.py的内容 #_*_ coding: UTF-8 -*_#引入TensorFlow库 improt tensorflow as tf #创建一个常量operation（操作） hw = tf.constant("Hello world ! I love tensorflow !") #启动一个TensorFlow的session（会话） sess = tf.session #运行Graph（计算图） printf sess.run(hw) #关闭session（会话） sess.close() //结束python helloworld.py

2.2 TensorFlow的基础模型：

TensorFlow的基础模型
边为（Tensor张量）、结点（operation操作）

会话、图的解释
tensor的属性包括：dtype、shape等
tensor有以下几种：

constant、常量
variable、变量
placeholder、占位符
sparsetensor、稀疏张量

tensor的表示法

var=tf.variable(3) var

设定tensor的属性（dtype、name）

named_var = tf.Variable([5,6], name="named_var",dtype=tf.int64)

TensorFlow的程序流程
2.3 可视化利器TensorBoard：
TensorBoard可以用来看到训练模型中的黑匣子内部的状态。
使用步骤：

1、tf.summary.FileWriter("日志保存地址",sess.graph)
2、tensorboard --logdir=日志所在路径
3、summary（总结、预览），用于到处关于模型的精简信息的方法，可以使用TensorBoard等工具访问这些信息

summary中图标表示的意思
一个训练模型的例子（tensorboard.py）：
#_ coding: UTF-8 -

improt tensorflow as tf//引入TensorFlow库 w=tf.Variable(2.0,dtype=tf.float32, name="weight")#权重 b=tf.Variable(1.0,dtype=tf.float32, name="bias")#偏差 x=tf.placeholder(dtype=tf.float32, name="input")#输入 with tf.name_scope("output")#输出的命名空间 y=w*x +b#输出path = "./log"#定义保=-存日志的路径 init=tf.global_variables_initializer()#初始化所有的变量 with tf.Session() as sess#创建session会话 sess.run(init) #变量呗初始化 writer=tf.summary.FileWriter(path,sess.graph) result =sess.run(y, {x:3.0}) print("y = %s" % result) #打印运行结果

所有的运行命令如下

vim tensorboard.py
python tensorboard.py
tensorboard --logdir=log

2.4 游乐场playground：
简介：

JavaScript编写的网页应用
通过浏览器就可以训练简单的神经网络
训练过程可视化，高度定制
网址：http://playground.tensorflow.org/
用于入门

2.5 用matplotlib来画一个动态的立体图：
matplotlib的简介：

一个极其强大的python会图库。官网matplotlib.org
可以用很少的代码即可回执2d、3d，静态或动态等各种图形
一般常用的是它的子包：PyPlot，提供类似MATLAB的绘图框架
安装matplotlib命令：sudo pip install matplotlib

生成一张两条曲线的图片

import matplotlib.pyyplot as plt import numpy as np x=np.linspace(-2,2,100) y1=3*x+4 y2=x**2plt.plot(x,y1) plt.plot(x,y2)plt.show()

同时生成2张图片

import matplotlib.pyyplot as plt import numpy as np x=np.linspace(-4,4,50) y1=3*x+4 y2=x**2plt.figure(num=1,figsize=(7,6)) plt.plot(x,y1) plt.plot(x,y2,color="red", linewidth=3.0,linestyle="--")plt.figure(num=2) plt.plot(x,y2,color="green")plt.show()

生成4个子图

import matplotlib.pyyplot as plt import numpy as npfrom matplotlib.ticker import NullFormatter #useful for "logit" scale#fixing random state for reproducibility np.random.seed(19680801) #make up some data in the interval[]0,1[ y=np.random.normal(loc=0.5,scal=0.4,size=1000) y=y[(y>0)&(y<1)] y.sort() x=np.arange(len(y))#plot with various axes scales plt.figure(1)#linear plt.subplot(221) plt.plot(x,y) plt.yscale('linear') plt.title('linear') plt.grid(True)#log plt.subplot(222) plt.plot(x,y) plt.yscale('log') plt.title('log') plt.grid(True)#symmetriclog plt.subplot(223) plt.plot(x,y-y.mean()) plt.yscale('symlog',linthreshy=0.01) plt.title('symlog') plt.grid(True)#linear plt.subplot(224) plt.plot(x,y) plt.yscale('logit') plt.title('logit') plt.grid(True)

如果需要画3D的图

from mpl_toolkits.mplot3d.axes3d import Axes3D

如果需要画动态图

import matplotlib.animation as animation

2.6 梯度下降解决线性回归问题：

#-*_ coding?: UTF-8 -*- #用梯度下降的优化方法来快四解决线性回归问题import numpy as py improt matplotlib.pyplot as plt import tensorfiow as tf#构建数据 points_num=100 vectors = [] #用numpy的正态分布随机分布函数生成100个点 #这些点的（x，y）坐标值对应的线性方程y=0.1*x+0.2 #权重（weight）0.1，偏差（bias）0.2 for i in xrange(points_num) x1=np.random.normal(0,0,0.66) y1=0.1 * x1 + 0.2 + np.random.normal(0,0,0.04) vectors.append([x1 ,y1]) x_data = https://www.it610.com/article/[v[0] for v in vectors] #真实的点的x坐标 y_data = [v[1] for v in vectors] #真实的点的y坐标#图像 1 ：展示100随机数据点 plt.plot(x_data, y_data,'r*', label="Original")#红色星型的点 plt.title("linear regression using gradient descent") plt.legend() plt.show()#构建线性回归模型 W = tf.Variable(tf.random_uniform([1],-1.0,1.0))#初始化权重 b = tf.Variable(tf.zeros([1]))#初始化 Bias y = W * x_data + b #模型计算出来的y#定义 loss function（损失函数）或者cost function（代价函数） #对tensor的所有唯独计算(（y-y_data）^2)之和/N loss = tf.reduce_mean(tf.square(y - y_data))#用梯度下降的优化器来优化我们的loss function optimizer = tf.train.GradientDescentOptimizer(0.5)#设置学习率 train = optimizer.minimize(loss)#创建会话 sess = tf.Session()#初始化数据流图中的所有变量 init tf.global_variables_initializer() sess.run(init)#训练20步 for step in xrange(20): #优化每一步 sess。run（train） #打印出每一步的损失，权重和偏差 print（“step=%d, loss=%f,[weight=%f bias=%f]”） \ %（step,sess.run(loss),sess.run(W), sess.run(b)）#图像2、：绘制所有的点并且回执初最佳的拟合直线plt.plot(x_data, y_data, 'r*', label="Original")#红色星型的点 plt.title("linear regression using gradient descent") plt.plot(x_data,sess.run(W)*x_data + sess.run(b),label="fitted line") plt.legend() plt.xlable('x') plt.ylable('y') plt.show()#关闭会话 sess.close()

2.7 激活函数：
插入激活函数（activation function）

#-*_ coding?: UTF-8 -*-import numpy as py improt matplotlib.pyplot as plt import tensorfiow as tf#创建输入数据 x = np.linspace(-7,7,180)#（-7，7）之间的等间隔#激活函数的原始实现 def sigmoid(inputs): y = [1/float(1+ np.exp(-x)) for x in inputs] return ydef relu(inputs): y = [x*(x>0) for x in inputs] def tanh(inputs): y = [(np.exp(x)-np.exp(-x)) / float(np.exp(x) + np.exp(-x)) for x in inputs] return y def softplus(inputs) y = [np.log(1 + np.exp(x)) for x in inputs] return y #经过TensorFlow的激活函数处理的各个Y值 y_sigmodi = tf.nn.sigmodi(x) y_relu = tf.nn.relu(x) y_tanh = tf.nn.tanh(x) y_softplus = tf.nn.softplus(x)#创建会话 sess = tf.Session() #运行 y_sigmodi, y_relu, y_tanh, y_softplus = sess.run([y_sigmodi, y_relu, y_tanh, y_softplus]) #创建各个激活函数的图像 plt.subplot(221) plt.plot(x,y_sigmodi,c="red", label="Sigmoid") plt.ylim(-0.2,1.2) plt.legend(loc="best")plt.subplot(222) plt.plot(x,y_relu,c="red", label="relu") plt.ylim(-1,6) plt.legend(loc="best")plt.subplot(223) plt.plot(x,y_tanh,c="red", label="tanh") plt.ylim(-1.3,1.3) plt.legend(loc="best")plt.subplot(224) plt.plot(x,y_softplus,c="red", label="softplus") plt.ylim(-1,6) plt.legend(loc="best")#显示图像 plt.show() #关闭会话 sess.close()

2.8 动手实现CNN卷积神经网络：
THE MNIST DATABASE:网址：yann.lecun.com

#-*_ coding?: UTF-8 -*-import numpy as py import tensorfiow as tf#下载并载入MNIST手写数字库（55000 * 28*28）它有55000张图片 form tensorflow.examples.tutorials.mnist import input_datamnist = input_data.read_data_sets('mnist_data',one_hot = True)#one_hot是读热码的编码（encoding）形式 #0，1，，2，3，4，5，6，7，8，9的十位数字 #0：1000000000 #1：0100000000 #2：0010000000依次到9#None表示张量的第一个维度可以是任何长度 input_x = tf.placeholder(tf.float32, [None,28*28])/255 output_y = tf.placeholder(tf.int32, [None,10]) input_x_images = tf.reshape(input_x, [-1,28,28,1])#改变形状之后的的输入#从 test数据集中选取3000个手写数字的图片 test_x = mnist.test.images[:3000]#图片 test_y = mnist.test.labels[:3000]#标签#构建卷积神经网络#构建第一层卷积神经网络conv1 = tf.layers.conv2d( inputs=input_x_images,#形状为28*28*1 filters=32,#32个过滤器，输出的深度是32 kernel_size=[5,5]，#过滤器在二维的大小是（5，5） strides=1，#步长是1 padding='same',#same表示输出的大小不变，因此需要在外围补2圈0 activation=tf.nn.relu#激活函数是relu )#形状[28*28*32] #第一层池化（亚采样） pool1 = tf.layers.max_pooling2d( inputs=conv1,#形状[28,28,32] pool_size=[2,2],#过滤器在二维的大小为（2*2） strides=2#步长是2 )#形状为[14,14,32]#第二层卷积神经网络 conv2 = tf.layers.conv2d( inputs=pool1,#形状为14*14*32 filters=64,#64个过滤器，输出的深度是64 kernel_size=[5,5]，#过滤器在二维的大小是（5，5） strides=1，#步长是1 padding='same',#same表示输出的大小不变，因此需要在外围补2圈0 activation=tf.nn.relu#激活函数是relu )#形状[14*14*64] #第二层池化（亚采样） pool2 = tf.layers.max_pooling2d( inputs=conv2,#形状[14,14,64] pool_size=[2,2],#过滤器在二维的大小为（2*2） strides=2#步长是2 )#形状为[7,7,64]#平坦化（flat） flat = tf.reshape(pool2,[-1,7*7*64]) #形状[7*7*64] #1024个神经元的全连接层 dense = tf.layers.dense(inputs=flat,units=1024,activation=tf.nn.relu) #dropout dropout = tf.layers.dropout(inputs=dense, rate=0.5) #构建10个神经元的全连接层，这里不用激活函数来做非线性化了 logits = tf.layers.dense(inputs = dropout, units=10)#输出形状[1,1,10]#计算误差（计算cross entropy(交叉熵)，再用softmax计算百分比概率） loss = tf.losses.softmax_cross_entropy(onehot_labels=output_y, logits=logits)#Adam优化器来最小化误差，学习率0.001 train_op = tf.train.AdamOptimizer(leraning_rate=0.001,minimize(loss))#精度。计算预测值和实际标签的匹配程度 #返回(accuracy,update_op),会创建两个局部变量accuracy = tf.metrics.accuracy( labels=tf.argmax(output_y,axis=1)， predictions=tf.argmax(logits, axis=1),)[1] )#创建会话 sess = tf.Session() #初始化变量:全局和局部 init = tf.group(tf.global_variables_initializer(),tf.local_variables_initializer()) sess.run(init)for i in range(20000): batch = mnist.train.next_bach(50) #cong train(训练)数据集中取下一个50个样本 train_loss,train_op = sess.run([loss,train_opt], {input_x: batch[0], output_y: batch[1]}) if i % 100 ==0: test_accuracy = sess.run(accuracy, {input_x: test_x, output_y: test_y}) print("step=%d, train loss=$.4f, [test accuracy=%.2f]" \ %(i, train_loss,test_accuracy) #测试：打印20个预测值和真实值的对 test_output = sess.run(logits, {input_x: test_x[:20]}) inferenced_y = np.argmax(test_output,1) printf(inferenced_y, 'inferenced numbers')#推测的数字 print(np.argmax(test_y[:20], 1), 'Real numbers')#真实的数字

转载于:https://www.cnblogs.com/agui125/p/9938461.html