TensorFlow基础

TensorFlow基础

TensorFlow运行模型 – 会话(session)

import tensorflow as tf

# 创建张量
a = tf.constant([1.0,2.0],name = 'a')
b = tf.constant([2.0,3.0],name = 'b')
result = tf.add(a,b,name = 'add')
print(result)
'''
输出：
Tensor("add:0", shape=(2,), dtype=float32)
'''

# 创建会话
sess = tf.Session()
print(sess.run(result))
sess.close()

# with方法创建会话
with tf.Session() as sess:
    print(sess.run(result))

变量

API： tf.Variable

# 生成200个全0元素的张量
biases = tf.Variable(tf.zeros([200]),name = 'biases')

# 生产784*200的矩阵，服从std = 0.35， mean = 0的正态分布
weights = tf.Variable(tf.random_normal([784,200],stddev = 0.35,mean = 0,seed = 1),name = 'weights')

神经网络常用生成随机数数组的函数

函数 描述
tf.random_normal() 生成正态分布随机数
tf.truncated_normal() 生成去掉过大偏离点的正态分布随机数
tf.random_uniform() 生成均匀分布随机数
tf.zeros 表示生成全 0 数组
tf.ones 表示生成全 1 数组
tf.fill 表示生成全定值数组
tf.constant

变量初始化

变量的初始化必须在模型的其它操作运行之前先明确地完成。最简单的方法就是添加一个给所有变量初始化的操作，并在使用模型之前首先运行那个操作。

weights = tf.Variable(tf.random_normal([784,200],stdev=0.35),name = 'weights')
biases = tf.Variable(tf.zero([200]),name = 'biases')

# 初始化
init_op = tf.initialize_all_variables()

with tf.Session() as sess:
    sess.run(init_op)
    

神经网络的实现

基本步骤

1、准备数据集，提取特征，作为输入喂给神经网络（ Neural Network NN)
2、搭建 NN 结构，从输入到输出（先搭建计算图，再用会话执行）
3、大量特征数据喂给 NN ，迭代优化 NN 参数
4、使用训练好的模型预测

向前传播

1 - 变量初始化:汇总所有待优化变量

init_op = tf.global_variables_initializer()
sess.run(init_op)

2 - 计算图节点运算:sess.run中写入待运算的节点

sess.run(y)

3 - tf.placeholder占位，在sess.run函数中用feed_dict喂数据

with tf.Session() as sess:
    # 喂一组数据
    x = tf.placeholder(tf.float32,shape = (1,2))
    y = x+x
    r = sess.run(y,feed_dict{x:[[0.5,0.6]]})
    print(r)

    # 喂多组数据
    x = tf.placeholder(tf.float32,shape = (None,2))
    y = tf.reduce_sum(x,0)
    r = sess.run(y,feed_dict = {x:{[1,2],[3,4],[5,6],[7,8]}})
    print(r)

反向传播

训练模型参数，在所有参数使用梯度下降，使神经网络模型在训练数据上的损失函数最小

损失函数

1 - 解决回归问题的损失函数：均方误差MSE

API：

loss_mse = tf.reduce_mean(tf.square(y_ - y))

反向传播训练方法：以减小loss值为优化目标，主要有：
梯度下降
adam优化器等
API

# 梯度下降
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
# Adam优化器
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)

（1）梯度下降

[外链图片转存失败(img-yf8qAqRQ-1568382151328)(E:\pycharm\My_Note\06_AI\17_tensorflow\day18\images\1563866296204.png)]

其中，?(?)为损失函数， ?为参数， ?为学习率。

（2）Adam优化器
利用自适应学习率的优化算法。
Adam 算法和随机梯度下降算法不同。
随机梯度下降算法保持单一的学习率更新所有的参数，学习率在训练过程中并不会改变。
而 Adam 算法通过计算梯度的一阶矩估计和二阶矩估计而为不同的参数设计独立的自适应性学习率。

2 - 解决分类问题的损失函数:交叉熵(cross entropy)

假设有两个分布p（1, 0, 0）与 q（0.8, 0.1, 0.1），则它们在给定样本集上的交叉熵定义如下： $$CE(p,q)=-\sum p(x)logq(x)$$

API：

ce = -tf.reduce_sum(p *tf.log(tf.clip_by_value(q,1e-12,1.0)))
# （1e-12 是为了防止log0出现）

总结：
交叉熵刻画了两个概率分布之间的距离， 它是分类问题中使用比较广的一种损失函数。
交叉熵越大，两个概率分布距离越远， 两个概率分布越相异 ;
交叉熵越小，两个概率分布距离越近 ，两个概率分布越相似 。

TensorFlow交叉熵函数

# sigmoid交叉熵
tf.nn.sigmoid_cross_entropy_with_logits(logits=预测输出,labels=真实输出)
# softmax交叉熵
tf.nn.softmax_cross_entropy_with_logits(logits=预测输出,labels=真实输出)

sigmoid
计算方式：对输入的y’先通过sigmoid函数计算，再计算它们的交叉熵，但是它对交叉熵的计算方式进行了优化，使得出的结果不至于溢出。
适用：每个类别相互独立但互不排斥的情况：例如一幅图可以同时包含一条狗和一只大象。
output不是一个数，而是一个batch中每个样本的loss,所以一般配合tf.reduce_mean(loss)使用。

softmax
计算方式：对输入的logits先通过softmax函数计算，再计算它们的交叉熵，但是它对交叉熵的计算方式进行了优化，使得结果不至于溢出。
适用：每个类别相互独立且排斥的情况，一幅图只能属于一类，而不能同时包含一条狗和一只大象。
output：不是一个数，而是一个batch中每个样本的loss，所以一般配合tf.reduce_mean(loss)使用。

神经网络计算过程

1. 导入模块，生成模拟数据集； import 常量定义 生成数据集
2. 前向传播：定义输入、参数和输出 x = y = w1 = w2 = b1 = b2 = y_ =
3. 反向传播：定义损失函数、反向传播方法 loss = train_step =
4. 生成会话，训练 STEPS 轮

with tf.session() as sess:
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    STEPS=3000
    for i in range(STEPS):
    start=
    end=
    sess.run(train_step, feed_dict = {})

基于TensorFlow训练神经网络

import tensorflow as tf
import numpy as np
import sklearn.datasets as datasets
import matplotlib.pyplot as mp

BATCH_SIZE = 8   # 将数据分为8个部分
seed = 23455 

# 生成随机数种子
np.random.seed(0)
X, Y = datasets.make_moons(200, noise=0.10)
# noise : double or None (default=None)，Standard deviation of Gaussian noise added to the data.

# 将Y 和 按位取反Y合并
Y = np.array(np.column_stack((Y, ~Y+2)), dtype='f4')
print(Y)

#定义神经网络的输入、参数和输出，定义向前传播过程
x = tf.placeholder(tf.float32, shape=(None,2), name='x')
y = tf.placeholder(tf.float32, shape=(None,2), name='y')

w1 = tf.Variable(tf.random_normal((2,3),stddev=1,seed=1))
b1 = tf.Variable(tf.random_normal((3,),stddev=1,seed=1))
w2 = tf.Variable(tf.random_normal((3,2),stddev=1,seed=1))
b2 = tf.Variable(tf.random_normal((2,),stddev=1,seed=1))

# * + 激活
l1 = tf.nn.sigmoid(tf.add(tf.matmul(x,w1), b1))
# * +
y_ = tf.add(tf.matmul(l1,w2), b2)

# softmax损失函数
loss = tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=y_))
# 逆向更权， 梯度下降
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss)

# 生成会话，训练step轮
with tf.Session() as sess:
    # 初始化变量
    init_op=tf.global_variables_initializer()
    sess.run(init_op)

    #训练模型
    STEPS = 30000 # 训练30000步
    for i in range(STEPS):
        start = (i*BATCH_SIZE) % 32
        end = start + BATCH_SIZE
        sess.run(train_step,feed_dict={x:X[start:end], y:Y[start:end]})
        if i % 500 ==0:
            total_loss = sess.run(loss,feed_dict={x:X, y:Y})
            print("After %d training steps, loss on all data is %g"%
            (i,total_loss))
            
    pred_y = sess.run(y_, feed_dict={x:X})
    pred_y = np.piecewise(pred_y, [pred_y<0, pred_y>0], [0, 1])