TensorFlow Deep Learning

By4te

于 2022-01-14 15:37:27 发布

阅读量362

点赞数

分类专栏： Python 深度学习文章标签： tensorflow 深度学习机器学习

本文链接：https://blog.csdn.net/m0_49939117/article/details/122493005

版权

Python 同时被 2 个专栏收录

42 篇文章 2 订阅

订阅专栏

深度学习

10 篇文章 0 订阅

订阅专栏

资料来源：fuqiuai/TensorFlow-Deep-Learning: 用TensorFlow搭建CNN/RNN/LSTM/GRU/BiRNN/BiLSTM/BiGRU/Capsule Network等deep learning模型 (github.com)https://github.com/fuqiuai/TensorFlow-Deep-Learning

2 Tensorflow实现CNN（LeNet-5）

2.1 导入模块

2.2 加载数据

2.3 构建神经网络

3 Tensorflow实现Capsule Network

4 Tensorflow实现RNN/LSTM/GRU

5 Tensorflow实现Bi-RNN/SLTM/GRU

1 Tensorflow入门

1.1 张量和图

TensorFlow是一种采用数据流图，用于数值计算的开源软件库。其中Tensor代表传递的数据是张量（即多维数组），Flow表示使用计算图进行运算。

例程：

# exp1
a = tf.constant(2, tf.int16)
b = tf.constant(4, tf.float32)

with tf.Session() as session:
    tf.global_variables_initializer().run()
    print(session.run(a))
    print(session.run(b))

''' 
output=2 
       4.0
'''

# exp2
a = tf.constant(2, tf.int16)
b = tf.constant(4, tf.float32)

graph = tf.Graph()
with graph.as_default():
    a = tf.Variable(8, tf.float32)
    b = tf.Variable(tf.zeros([2,2], tf.float32))
    
with tf.Session(graph=graph) as session:
    tf.global_variables_initializer().run()
    print(session.run(a))
    print(session.run(b))
    
'''
output=8
        [[ 0.  0.]
         [ 0.  0.]]
'''

在TensorFlow中所有变量和运算都是存储在计算图中，在构建完模型所需的图，需要打开对话(Session)来运行计算图。

如以下代码，我们只定义了一张图，但并未运行它，因此不会输出结果

a=tf.constant([1,2],name="a")

b=tf.constant([2,4],name="b")

result = a+b

print(result)

需要创建一个运行结束后即关闭的会话来输出计算结果，有以下两种方法。

a=tf.constant([1,2])

b=tf.constant([2,4])

result = a+b

'''
sess=tf.Session()
print(sess.run(result))
sess.close
'''

with tf.Session() as sess:
    print(sess.run(result))

1.2 常量、变量和占位符

TensorFlow中最基本的单位tensor，包括常量constant、变量variable、占位符placeholder。以下例程定义常量与变量

import numpy as np

a=tf.constant(2,tf.int16)
b=tf.constant(8.9,tf.float32)

d=tf.Variable(4,tf.int16)

g = tf.constant(np.zeros(shape=(2,2), dtype=np.float32))
# 等价于 g=tf.zeros([2,2],tf.float32)

h = tf.zeros([11], tf.int16)
i = tf.ones([2,2], tf.float32)
l = tf.Variable(tf.zeros([5,6,5], tf.float32))

# print(a,'\n',d,'\n',g,'\n',i,'\n',h,'\n',l)
with tf.Session() as sess:
    print(sess.run(a),'\n',sess.run(g),'\n',sess.run(h))

'''
2 
 [[0. 0.]
 [0. 0.]] 
 [0 0 0 0 0 0 0 0 0 0 0]
'''

常量在赋值后不可修改，占位符在执行方法时设置。在含有优化器的算法内，变量是动态计算的，未使用优化器时，变量仍作为普通变量。使用变量前，需要执行初始化方法，系统才会给变量赋值。

with tf.Session() as sess:
    # 常量
    node1 = tf.constant(3.0, tf.float32)
    node2 = tf.constant(4.0)
    print (node1, node2)  # 只打印结点信息

    # 占位符
    a = tf.placeholder(tf.float32)
    b = tf.placeholder(tf.float32)
    adder_node = a + b  # 与调用add方法类似
    print (sess.run(adder_node, {a: 3, b: 4.5}))
    print (sess.run(adder_node, {a: [1, 3], b: [2, 4]}))

    # 变量
    W = tf.Variable([.3], tf.float32)
    b = tf.Variable([-.3], tf.float32)
    x = tf.placeholder(tf.float32)
    # linear_model = node1 * x + node2
    linear_model = W * x + b
    sess.run(tf.global_variables_initializer()) #初始化模型参数
    print ("linear_model: ", sess.run(linear_model, {x: [1, 2, 3, 4]}))

占位符在使用神经网络时很有帮助，以下展示了使用常量和占位符进行计算。

w1=tf.Variable(tf.random_normal([1,2],stddev=1,seed=1))

#因为需要重复输入x，而每建一个x就会生成一个结点，计算图的效率会低。所以使用占位符
x=tf.placeholder(tf.float32,shape=(1,2))
x1=tf.constant([[0.7,0.9]])

a=x+w1
b=x1+w1

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

#运行y时将占位符填上，feed_dict为字典，变量名不可变
y_1=sess.run(a,feed_dict={x:[[0.7,0.9]]})
y_2=sess.run(b)

print(y_1)
print(y_2)
sess.close

1.3 实例

构建三层全连接神经网络

# 定义变量w1,w2（权重）
w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))

# 定义占位符x,y（样本集）
x=tf.placeholder(tf.float32,shape=(None,2)) # None可以根据batch大小确定维度，在shape的一个维度上使用None
y=tf.placeholder(tf.float32,shape=(None,1))

# 定义ReLU激活函数
a=tf.nn.relu(tf.matmul(x,w1)) #tf.nn.relu(features, name = None),这个函数的作用是计算激活函数relu，即max(features, 0)。即将矩阵中每个元素的负值置0。
yhat=tf.nn.relu(tf.matmul(a,w2)) # tf.matmul为矩阵相乘,yhat为预测的值

# 定义交叉熵损失函数和训练算法AdamOptimizer
cross_entropy=-tf.reduce_mean(y*tf.log(tf.clip_by_value(yhat,1e-10,1.0))) #tf.clip_by_value(A, min, max)：输入一个张量A，把A中的每一个元素的值都压缩在min和max之间。小于min的让它等于min，大于max的元素的值等于max。
train_op=tf.train.AdamOptimizer(0.001).minimize(cross_entropy) # 学习率为0.001

# 随机生成512个样本，样本特征维数为2
data_size=512
X = np.random.RandomState(1).rand(data_size,2) # 样本范围为[0, 1)
# 生成标签，1为正样本,0为负样本
Y = [[int(x1+x2<1)] for (x1,x2) in X]

batch_size=10 # 每次训练读取样本个数

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer()) # 初始化
    print('初始化权重为：\n',sess.run(w1),'\n',sess.run(w2))
    steps=10001
    for i in range(steps):
        #选定每一个批量读取的首尾位置，确保在1个epoch（全部样本训练一次为1个epoch）内采样训练
        start = i*batch_size % data_size
        end = min(start+batch_size,data_size)
        sess.run(train_op,feed_dict={x:X[start:end],y:Y[start:end]}) # 开始训练
        if i % 1000 == 0:
            training_loss=sess.run(cross_entropy,feed_dict={x:X,y:Y})
            print("在迭代%d次后，训练损失为%g"%(i,training_loss))

上面的代码定义了一个简单的三层全连接网络（输入层、隐藏层和输出层分别为 2、3 和 1 个神经元），隐藏层和输出层的激活函数使用的是 ReLU 函数。该模型训练的样本总数为 512，每次迭代读取的批量为 10。这个简单的全连接网络以交叉熵为损失函数，并使用Adam优化算法进行权重更新。