TensorFlow实战Google深度学习框架 笔记 第二、三章

import tensorflow as tf
a = tf.constant([1.0, 2.0], name="a")
b = tf.constant([2.0, 3.0], name="b")
result = a + b
sess = tf.Session()
sess.run(result)
---输出---
array([3., 5.], dtype=float32)

print(a.graph is tf.get_default_graph())
---输出---
True

import tensorflow as tf

g1 = tf.Graph()
with g1.as_default():
    #g1中定义"v", 设置为0。
    v = tf.get_variable(
        "v", initializer = tf.zeros_initializer(shape = [1])
    )

g2 = tf.Graph()
with g2.as_default():
    #g2中定义"v", 设置为1。
    v = tf.get_variable(
        "v", initializer = tf.ones_initializer(shape = [1])
    )

with tf.Session(graph=g1) as sess:
    tf.global_variables_initializer().run()
    with tf.variable_scope("", reuse=True):
        print(sess.run(tf.get_variable("v")))
        #g1中"v"输出0。
    
with tf.Session(graph=g2) as sess:
    tf.global_variables_initializer().run()
    with tf.variable_scope("", reuse=True):
        print(sess.run(tf.get_variable("v")))
        #g2中"v"输出1。

g = tf.Graph()
# 指定计算运行的设备。
with g.device('/gpu:0'):
    result = a + b

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()
# 使用这个创建好的会话来得到关心的运算的结果。比如可以调用sess.run(result),
# 来得到 3.1 节样例中张量 result 的取值。
sess.run(...)
# 关闭会话使得本次运行巾使用到的资源可以被释放。
sess.close()

# 创建一个会话，并通过 Python 中的上下文管理器来管理这个会话。
with tf.Session() as sess:
# 使用创建好的会话来计算关心的结果。
sess.run (...)
# 不需要再调用"Session.close()"函数来关闭会话，
# 当上下文退出时会话关闭和资源释放也自动完成了。

sess = tf.Session()
with sess.as default():
print(result. eval())

sess = tf.Session()
# 以下两个命令有相同的功能。
print(sess.run(result))
print(result.eval(session=sess))

sess = tf.InteractiveSession()
prirnt(result. eval())
sess.close()

config = tf.ConfigProto(allow soft placement=True, log_device_placement=True)
sessl = tf.InteractiveSession(config=config)
sess2 = tf.Session(config=config)

a = tf.matmul(x, w1)
y = tf.matmul(a, w2)

#产生一个 2×3 的矩阵，矩阵中的元素是均值为 0，标准差为 2 的随机数。可以通过参数 mean 来指定平均值，默认为0。
weights = tf.Variable(tf.random_normal([2, 3]), stddev=2))

biases = tf.Variable(tf.zeros([3]))
# 生成一个初始值全部为 0 且长度为 3 的变量
w2 = tf.Variable(weights.initialized_value())
# w2 的初始值被设置成了与 weights 变量相同
w3 = tf.Variable(weights.initialized_value() * 2.0)
# w3 的初始值则是 weights 初始值的两倍

import tensorflow as tf
# 声明 w1、w2 两个变盘。这里还通过 seed 参数设定了随机种子，
# 这样可以保证每次运行得到的结果是一样的。
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 是一个 1×2 的矩阵。
x = tf.constant([[0.7, 0.9]])
# 通过 3.4.2 节描述的前向传播算法获得神经网络的输出。
a = tf.matmul(x, w1)
y = tf.matmul(a, w2)
sess = tf.Session()
# 与 3.4.2 中的计算不同，这里不能直接通过 sess.run(y) 来获取 y 的取值，
# 因为 w1 和 w2 都还没有运行初始化过程。以下两行分别初始化了 w1 和 w2 两个变量。
sess.run(w1.initializer) # 初始化 w1。
sess.run(w2.initializer) # 初始化 w2。
# 输出[[3.95757794]]。
print(sess.run(y))
sess.close()

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

w1 = tf.Variable(tf.random_normal([2, 3], stddev=1), name="w1")
w2 = tf.Variable(tf.random_normal([2, 3], dtype=tf.float64, stddev=1),
name="w2")
w1.assign(w2)
'''
程序将报错：
TypeError: Input 'value' of 'Assign' Op has type float64 that does not match type float32 of argument 'ref'.

w1 = tf.Variable(tf.random_normal([2, 3], stddev=1), name = "w1")
w2 = tf.Variable(tf.random_normal([2, 2], stddev=1), name = "w2")
# 下面这句会报维度不匹配的错误：
# ValueError: Dimension 1 in both shapes must be equal, but are 3 and 2
# for 'Assign_1' (op: 'Assign') with input shapes: [2, 3], [2, 2].
tf.assign(w1, w2)
# 这一句可以被成功执行。
tf.assign(w1, w2, validate_shape=False)

x = tf.placeholder(tf.float32, shape = (3, 2), name="input")
# 因为 x 在定义时指定了 n 为 3，所以在运行前向传播过程时需要提供 3 个样例数据。
print(sess.run(y, feed_dict={x: [[0.7, 0.9), [0.1, 0.4] , [0.5, 0.8]]}))

# 使用 sigmoid 函数将 y 转换为 0~1 之间的数值。转换后 y 代表预测是正样本的概率， 1-y 代表
# 预测是负样本的概率 。
y=tf.sigmoid(y)
# 定义损失函数来刻画预测值与真实值的差距。
cross_entropy = -tf.reduce_mean(
y_ * tf.log(tf.clip_by_value(y, 1e-10, 1.0))
+(1-y)*tf.log(tf.clip_by_value (1-y, 1e-10, 1.0)))
# 定义学习率，在第 4 章中将更加具体的介绍学习率。
learning_rate = 0.001
# 定义反向传播算法来优化神经网络中的参数。
train_step =\
tf.train.AdamOptimizer(learning_rate) .minimize (cross_entropy)

import tensorflow as tf

# NumPy 是一个科学计算的工具包，这里通过 NumPy 工具包生成模拟数据集。
from numpy.random import RandomState

# 定义训练数据 batch 的大小。
batch_size = 8

# 定义神经网络的参数，这里还是沿用 3.4.2 小节中给出的神经网络结构 。
w1 = tf.Variable(tf.random_normal([2, 3], stddev=1 , seed=1))
w2 = tf.Variable(tf.random_normal([3, 1], stddev=1 , seed=1))

# 在 shape 的一个维度上使用 None 可以方便使用不同的 batch 大小。在训练时需要把数据分
# 成比较小的 batch ， 但是在测试时，可以一次性使用全部的数据。当数据集比较小时这样比较
# 方便测试，但数据集比较大时，将大量数据放入一个 batch 可能会导致内存溢出。
x  = tf.placeholder(tf.float32, shape=(None, 2), name = 'x-input')
y_ = tf.placeholder(tf.float32, shape=(None, 1), name = 'y-input')

# 定义神经网络前向传播的过程。
a = tf.matmul (x, w1)
y = tf.matmul (a, w2)

# 定义损失函数和反向传播的算法。
y = tf.sigmoid(y)
cross_entropy = -tf.reduce_mean(
    y_ * tf.log(tf.clip_by_value(y, 1e-10, 1.0))
+(1-y)*tf.log(tf.clip_by_value(1 - y, 1e-10, 1.0)))
train_step = tf.train.AdamOptimizer(0.001).minimize(cross_entropy)

# 通过随机数生成一个模拟数据集。
rdm = RandomState(1)
dataset_size = 128
X = rdm.rand(dataset_size, 2)
# 定义规则来给出样本的标签。在这里所有 x1+x2<1 的样例都被认为是正样本（比如零件合格），
# 而其他为负样本（比如零件不合格）。和 TensorFlow 游乐场中的表示法不大一样的地方是，
# 在这里使用 0 来表示负样本， 1 来表示正样本。大部分解决分类问题的神经网络都会采用
#  0 和 1 的表示方法。
Y = [[int(x1+x2 < 1)] for (x1, x2) in X]
# 创建一个会话来运行 TensorFlow 程序。
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
# 初始化变量。
sess.run(init_op)

print(sess.run(w1))
print(sess.run(w2))

'''
在训练之前神经网络参数的值：
w1 = [[-0.81131822, 1.48459876, 0.06532937]
[-2.44270396, 0.0992484, 0.59122431]]
w2 = [[-0.81131822), [1.48459876], [0.06532937]]
'''

# 设定训练的轮数。
STEPS = 5000
for i in range (STEPS):
    # 每次选取 batch_size 个样本进行训练。
    start = (i * batch_size) % dataset_size
    end = min(start+batch_size, dataset_size)

    # 通过选取的样本训练神经网络并更新参数。
    sess.run(train_step, feed_dict={x:X[start:end], y_:Y[start:end]})
    if i % 1000 == 0 :
        # 每隔一段时间计算在所有数据上的交叉煽并输出。
        total_cross_entropy = sess.run(cross_entropy, feed_dict={x:X, y_:Y})
        print("After %d training step(s), cross entropy on all data is %g" % (i, total_cross_entropy))
        '''
        输出结果 ：
        After 0 training step (s), cross entropy on all data is 1.89805
        After 1000 training step (s), cross entropy on all data is 0.655075
        After 2000 training step (s), cross entropy on all data is 0.626172
        After 3000 training step (s), cross entropy on all data is 0.615096
        After 4000 training step (s), cross entropy on all data is 0.610309
        通过这个结果可以发现随着训练的进行，交叉煽是逐渐变小的。交叉熵越小说明
        预测的结果和真实的结果差距越小。
        '''
print(sess.run(w1))
print(sess.run(w2))
'''
在训练之后神经网络参数的值：
w1 = [[0.02476984, 0.5694868, 1.69219422]
[-2.19773483, -0.23668921, 1.11438966]]
w2 = [[-0.45544702], [0.49110931], [-0.9811033]]

可以发现这两个参数的取值已经发生了变化，这个变化就是训练的结果。
它使得这个神经网络能更好地拟合提供的训练数据。
'''