Tensorflow_基础_人工智能基础串讲1

本篇的主要内容

人工智能的基础及其含义
神经网络的基础
1. 张量
2. 计算图
3. 会话
神经网络的八股
1. 准备
2. 前传
3. 反传
4. 迭代

1. 人工智能的基础及其含义

人工智能：机器模拟人的意思跟思维
机器学习：实现人工智能的一种方法，是人工智能的子集
深度学习：是深层次的神经网络，是机器学习的一种实现的方法，是机器学习的子集
机器学习的定义：如果一个程序可以在人物T上，随着经验E的增加，效果P随之增加，这个程序可以从经验中学习
机器学习的过程/单个神经元：
1.

　　　　　　2.基于Tensorflow的神经网络

用张量表示数据
用计算图搭建神经网络
用会话执行计算图
优化线上的权重，得到计算模型

　　　　　　3.对每个点进行展开解释

　　1.张量(tensor)：

多维数组（列表），阶：张量的维数，张量可以表示0阶到N阶数组
1阶张量为标量
2阶张量为向量
3阶张量为矩阵

　　2.计算图

搭建神经网络的计算过程，只搭建，不运算
计算图只描述运算过程，不计算运算的结果
tf.constant 定义常数
在tensorflow中数据的类型有浮点型：tf.float32 整形：tf.int32
在vim编辑器中建立一个例子

 1     mkdir tf  //创建tf这个文件夹
 2     cd tf   //打开tf文件夹
 3     vim tf3_1.py   //表示在文件夹tf中创建一个文件 为 tf3_1.py
 4     
 5     
 6     # vim中编辑
 7     import tensorflow as tf
 8     a = tf.constant([1.0,2.0])  //定义一个张量常数a的值为1.0  2.0  
 9     b = tf.constant([3.0,4.0])  //直接将常数写在括号中就行
10     result = a + b
11     print result
12     ~           
13     
14     # 在终端中输出结果
15     python tf3_1.py
16     
17     //输出的结果为
18     Tensor("add:0", shape=(2,), dtype=float32)
19     //add:节点名 0:第0个输出  shape:维度 2:一维数组的长度为2  dtype=float32数据类型为浮点型

　　3.会话（Session）

执行图中的节点运算

 1     import tensorflow as tf
　2     x = tf.constant([[1.0,2.0]])
 3     w = tf.constant([3.0],[4.0]])
 4     y = tf.matmul(x,w)
 5     print y
 6     with tf.Session() as sess:
 7          print sess.run(y)
 8     
 9     # 执行后的结果 
10     # doaoao@ubuntu:~/tf$ python tf3_4.py
11     # Tensor("MatMul:0", shape=(1, 1), dtype=float32)
12     # [[11.]]    
13     # 计算过程1.0*3.0 + 2.0*4.0 = 11.0

注：修改Tensorflow的配置文件（让Tensorflow的提示等级降低）

     doaoao@ubuntu:~/tf$ vim ~/.bashrc  #打开其配置文件
    # 在配置文件中加入 export TF_CPP_MIN_LOG_LEVEL=2

    doaoao@ubuntu:~/tf$ source ~/.bashrc  # 让所修改的配置生效

　　4.参数

　　即上图中的权重 W ，用变量表示，随机给初始值

　1 w = tf.Variable(tf.random_normal([2,3], stddev=2, mean=0, seed=1))
 2  # 生成随机数 将生成的方式写在括号中 
 3  # 后三个如果没有特殊要求，可以不写
 4  
 5 # tf.random_normal :表示生成正态分布的随机数
 6 # [2,3]            ：产生2*3的矩阵
 7 # stddev=2         ：标准差为2
 8 # mean=0           ：均值为0
 9 # seed=1           : 随机种子（如果去掉，每次生成的随机数将不一致）
10 
11 # tf.random_normal 可以用 tf.truncated_normal 替换
12 # 去掉过大偏离点的正态分布
13 # 如果随机出来的数，偏离平均值超过两个标准差，这个数据将重新生成
14 
15 # tf.random_uniform() 平均分布函数

- tf.zeros 全0的数组 tf.zeros([3,2],int32) 生成 [[0,0],[0,0],[0,0]]
- 　　tf.ones 全1的数组 tf.ones([3,2],int32) 生成 [[1,1],[1,1],[1,1]]
- 　　tf.fill 全定值的数组 tf.fill([3,2],6) 生成 [[6,6],[6,6],[6,6]]
- 　　tf.constant 直接给值 tf.constant([3,2,1]) 生成 [3,2,1]

5.神经网络的实现过程（//前3个步骤为训练过程第4步为使用的过程）
1. 准备数据集，提取特征，作为输入喂给神经网络
  1. 包括数据集的特征，包括数据集的标签（如零件是否合格）
1. 搭建NN结构，从输入到输出（先搭建计算图，在用会话执行）
  1. ( NN前向传播法 -> 计算输出）
2. 大量特征数据为给NN，迭代优化参数
  1. ( NN 反向传播法 -> 优化参数训练模型 )
1. 使用训练好的模型训练和分类

前向传播（搭建模型，实现推理）

例如：生产一批零部件，将以及为x，重量为y的特征输入NN，通过NN后输出一个数值
变量的初始化，计算图节点运算都要用会话（wish结构）实现
1. ```
1 wish tf.Session() as sess:
2     sess.run()
```
变量的初始化：在sess.run函数中用 tf.global_varlables_initiallzer()
1. ```
1 init_op = tf.global_varlables_initiallzer()
2 sess.run(init_op)
```
计算图节点运算：在sess.run函数中，写入待运算的节点
1. ```
sess.run(y) 
```

先用tf.placeholder 帮输入占位，在sess.run 函数中用feed_dict 喂数据

# 喂一组数据
x = tf.placeholder(tf.float,shape=(1,2)) 
    # 1表示喂入一组数据  2表示喂入数据的特征有几个（比如重量体积有两个特征）
sess.run(y,feed_dict={x: [[0.5,0.6]]})

# 一次性喂多组数据
x = tf.placeholder(tf.float,shape=(None,2))
    # None 表示先空着
sess.run(y,feed_dict={x: [[0.1,0.2],[0.3,0.4]]})

向神经网络中喂入特定的值

# 向神经网络写入特定的值


  1 #coding:utf-8
  2 import tensorflow as tf
  3 
  4 
  5 x = tf.constant([[0.7,0.5]])
  6 w1 = tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
  7 w2 = tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
  8 
  9 a = tf.matmul(x,w1)
 10 y = tf.matmul(a,w2)
 11 
 12 with tf.Session() as sess:
 13     init_op = tf.global_variables_initializer()
 14     sess.run(init_op)
 15     print "y in tf3_5.py is :\n",sess.run(y)
 16

向神经网络中喂入一组数据（特征）

# 向神经网络喂入一组数据（特征）

  1#coding:utf-8
  2 import tensorflow as tf
  3 
  4 
  5 x = tf.placeholder(tf.float32,shape=(1,2))
  6 w1 = tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
  7 w2 = tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
  8 
  9 a = tf.matmul(x,w1)
 10 y = tf.matmul(a,w2)
 11 
 12 with tf.Session() as sess:
 13     init_op = tf.global_variables_initializer()
 14     sess.run(init_op)
 15     print "y in tf3_5.py is :\n",sess.run(y,feed_dict={x: [[0.7,0.5]]})
 16

向神经网络中喂入多组数据（特征）

# 向神经网络喂入多组数据（特征）


  1 #coding:utf-8
  2 import tensorflow as tf
  3 
  4 # 定义输入和参数
  5 # 利用placeholder 定义输入 (sess.run 喂入多组数据)
  6 x = tf.placeholder(tf.float32,shape=(None,2))
  7 w1 = tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
  8 w2 = tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
  9 
 10 #定义向前传播的过程
 11 a = tf.matmul(x,w1)
 12 y = tf.matmul(a,w2)
 13 
 14 # 调用会话计算结果
 15 with tf.Session() as sess:
 16     init_op = tf.global_variables_initializer()
 17     sess.run(init_op)
 18     print "y in tf3_5.py is :\n",sess.run(y,feed_dict={x: [[0.7,0.5],[0.2,0.    3],[0.3,0.4],[0.4,0.5]]})
 19     print "w1:\n", sess.run(w1)
 20     print "w2:\n", sess.run(w2)

7.反向传播

反向传播：训练模型参数，在所有的参数上用梯度下降，使NN模型在训练的数据上的损失函数最小
反向传播的训练方法：以减小loss值为优化的目标
损失函数（loss）:预测值（y）与已知的答案（y_）的差距
loss = tf.reduce_mean(tf.square(y_-y)) //已知答案减去前向传播计算出来的结果

反向传播的训练方法（训练时选择其中一个即可）

# 三种反向传播的训练方法
strain_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(losss)

strain_step = train.MomenttumOptimizer(learning_rate,momentum).minimize(loss)

strain_stept = tf.train.AdamOptimizer(learning_rate).minimize(lose)

学习率 learning_rate ：决定参每次的更新幅度，使用时可以选择一个比较小的值填入
- 神经网络的实现过程
  1. 准备数据集，提取特征，作为输入喂给神经网络
  2. 搭建神经网络结构，从输入到输出（先搭建计算图，在用会话执行）
    - （神经网络前向传播算法->计算输出）
  3. 大量的数据特征喂给神经网络，迭代优化神经网络参数
    - （神经网络反向传播->优化训练模型）
  4. 使用训练号的模型进行预测和分类

# 搭建神经网络的八股：准备，前传，反传，迭

准备
1. import 常量的定义生成数据集
前向传播：定义输入定义输出
1. Y= （数据集的标签）
2. x=（输入参数）
3. y_= （标准答案）
4. w1= （第一层网络的参数）
5. w2= （第二层网络的参数）
6. a= （先用矩阵乘法求出 a）
7. y= （定义推理过程用矩阵乘法求出 y）
反向传播：定义损失函数，反向传播的方法
1. loss= （定义损失函数）
2. train_step= （反向传播方法）

生成会话训练STEPS轮

在with中实现

  1 # coding:utf-8
  2 # 导入模块 生成模拟的数据集
  3 
  4 # 导入tensorflow 模块　简写为 tf
  5 import tensorflow as tf
  
  # 导入numpy模块 python的科学计算模块
  6 import numpy as np
  7 
  8 # 一次喂入神经网络多少组数据　不能过大
  9 BATCH_SIZE = 8
 10 
 11 seed = 23455
 12 
 13 # 基于seed产生的随机数
 14 rng = np.random.RandomState(seed)
 15 # 随机数返回32行2列的矩阵　表示具有32组　具有两种特征（体积　重量）
 16 # 作为输入的数据集
 17 X = rng.rand(32,2)
 18 
 19 
 20 # 从这个32行２列的矩阵中　取出一行　判断如果小于１　给Ｙ赋值1 否则给Y赋值０
 21 # Y 作为输入数据集的标签（输入数据集的正确答案）
 22 Y = [[int(x0 + x1 < 1)] for (x0, x1) in X]
 23 print "X:\n",X
 24 print "Y:\n",Y
 25 
 26 # 定义神经网络的输入　参数　输出　定义向前传播的过程
 27 x = tf.placeholder(tf.float32, shape=(None, 2))
 28 
 29 # 正确答案的标签（每个标签只有一个元素 合格或者不合格）
 30 y_ = tf.placeholder(tf.float32, shape=(None, 1))
 31 
 32 # w1 对应x  w2 对应y
 33 w1 = tf.Variable(tf.random_normal([2, 3],stddev=1, seed=1))
 34 w2 = tf.Variable(tf.random_normal([3, 1],stddev=1, seed=1))
 35 
 36 # 前向传播的计算过程描述 用矩阵乘法实现
 37 a = tf.matmul(x, w1)
 38 y = tf.matmul(a, w2)
 39 
 40 # 定义损失函数 及反向传播方法
 41 loss = tf.reduce_mean(tf.square(y-y_))
 42 
 43 # 将其学习率设置为0.001
 44 train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
 45 
 46 
 47 # 生成回话 训练STEPS轮
 48 with tf.Session() as sess:
 49     init_op = tf.global_variables_initializer()
 50     sess.run(init_op)
 51 
 52     # 打印优化前的参数 w1 w2
 53     print "w1:\n",sess.run(w1)
 54     print "w2:\n",sess.run(w2)
 55     print "\n"
 56 
 57     # 训练模型
 58     STEPS = 3000
 59     for i in range(STEPS):
 60         start = (i*BATCH_SIZE) % 32
 61         end = start + BATCH_SIZE
 62 
 63         # 抽取相应的数据集 从start 到 end 的特征和标签，喂入神经网络
 64         sess.run(train_step, feed_dict={x: X[start:end],y_: Y[start:end]})
 65         if i % 500 == 0:
 66             total_loss = sess.run(loss, feed_dict={x:X,y_:Y})
 67             print ("After %d,%g" % ( i,total_loss))
 68 
 69     # 输出训练后的参数值
 70     print "/n"
 71     print "w1:\n",sess.run(w1)
 72     print "w2:\n",sess.run(w2)
 73 
 74

posted @ 2018-10-11 18:05 一头牛这么多人放阅读(277) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

一头牛这么多人放

Tensorflow_基础_人工智能基础串讲1

公告