张量

TensorFlow 中的tensor就张量，可见张量在tensorflow中低位非同一般。在tensorflow中所有的数据都是通过张量的形式表示的。张量可以简单的理解为多维数组，其中零阶张量表示标量，就是一个数。第n阶张量表示n维数组。但张量在tensorflow中的实现并不是直接采用数组的形式，它只是对tensorflow中运算结果的引用。在张量中并没有真正的保存数字，它只是保存如何得到这些数字的计算过程。比如代码的运行结果并不会得到加法的结果，而只是保存如何得到结果的过程的引用

张量使用

import tensorflow as tf
a = tf.constant([1, 2, 3], name="a")
b = tf.constant([2, 3, 4], name="b")
result = a + b
print(result)

计算图

Tensorflow中flow就简单可以理解为就是计算图。它表达了张量之间通过计算相互转化的过程。Tensorflow程序一般分为两个阶段。在第一个阶段
定义计算图中所有的计算。第二阶段执行计算。在tensorflow中系统会自动维护一个默认的计算图，通过tf.get_default_graph函数可以获得当前
默认的计算图。以下代码示意了如何获得默认计算图。不同计算图上的张量、运算不会共享

import tensorflow as tf
# 不同计算图上的张量、运算不会共享
g1 = tf.Graph()  # 生成新的计算图
with g1.as_default():
    v = tf.get_variable("v", initializer=tf.zeros_initializer(), shape=[1])
g2 = tf.Graph()  # 生成新的计算图
with g2.as_default():
    v = tf.get_variable("v", initializer=tf.ones_initializer(), shape=[1])
# 读取计算图g1中的v
with tf.Session(graph=g1) as sess:
    tf.global_variables_initializer().run()
    with tf.variable_scope("", reuse=True):
        print("v in g1: %s" % str(sess.run(tf.get_variable("v"))))
# 读取计算图g2中的v
with tf.Session(graph=g2) as sess:
    tf.global_variables_initializer().run()
    with tf.variable_scope("", reuse=True):
        print("v in g2: %s" % str(sess.run(tf.get_variable("v"))))

会话

上例中并没有输出result的值，那么如何得到result值呢？答案是会话（session）。tensorflow中通过会话来执行定义好的运算。会话管理并管理tensorflow程序运行时需要的所有资源。tensorflow中的使用会话有两种方式

• 需要明确的打开和关闭会话

sess = tf.Session()
print(sess.run(result)) # 和下面一行功能一直
print(result.eval(session=sess))
sess.close()

• 用python中的上下文管理器, 关闭、异常处理由管理器来完成

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

变量

tensorflow变量定义：

import tensorflow as tf
b1 = tf.Variable(tf.zeros([3])) # 常数生成
b2 = tf.Variable([1, 2, 3]) # 
b3 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1)) # 随机函数生成,指定seed那么每次生成的结果都一样
b4 = tf.Variable(b3.initialized_value() * 3) # 别的变量的初始化值生成
with tf.Session() as sess:
    sess.run(b1.initializer)  # tensorflow中变量的初始化需要被明确的调用
    sess.run(b2.initializer)
    sess.run(b3.initializer)
    sess.run(b4.initializer)
    print(sess.run(b1))
    print(sess.run(b2))
    print(sess.run(b3))
    print(sess.run(b4))
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()  # 省去上面一个一个的初始化的繁琐。一个函数初始化所有的变量
    sess.run(init_op)
    print(sess.run(b1))
    print(sess.run(b2))
    print(sess.run(b3))
    print(sess.run(b4))

tensorflow中变量的初始化有三种方式

• 随机数生成函数
• 常数生成函数
• 其他变量的初始值

<center>tensorflow 随机生成函数</center>

<center>tensorflow常数生成函数</center>

张量、变量的区别与联系

tensorflow中所有的数据都是通过张量来组织的，那么为什么又出现了变量了呢？在tensorflow中变量声明函数tf.Variable()是一个运算。这个运算的结果就是一个张量，所以变量是一种特殊的张量。tf.constant等常量函数生成的张量是不可变的，没有assign操作，只能引用于值，不能引用于操作，但是tf.Variable()声明的变量是可变的，有assign操作，且可以应用于操作，必须tf.Variable(a+b).

一个完整的神经网络样例程序

下面给出一个实例程序来训练如下的神经网络（全连接神经网络），输入2个节点，隐藏层3个节点，输出一个节点。主要用来学习代码应该这么写

import tensorflow as tf
import numpy as np
# sgd batch的大小
batch_size = 8
# 定义神经网络的参数
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 = 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)))  #clip_by_value 参数修剪，防止0的数，大于1的数
# 定义目标函数
train_step = tf.train.AdamOptimizer(0.001).minimize(cross_entropy)
# 生成一个模拟数据集
rdm = np.random.RandomState(1)
dataset_size = 128
# 样本
X = rdm.rand(dataset_size, 2)
# label, Attention: 这里的Y是一个矩阵
Y = [[int(x1 + x2 < 1)] for (x1, x2) in X]
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    # 初始化变量
    sess.run(init_op)
    STEPS = 5000
    for i in range(STEPS):
#         print("step:%d,start", i)
        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[start:end],
                    y_: Y[start:end]
                })
            print("step:%d, %f", i, total_cross_entropy)
    print(sess.run(w1))
    print(sess.run(w2))

总结

一个完整的神经网络程序需要包含以下三个步骤

1. 定义神经网络的结果和前项传播的结果
2. 定义损失函数已经选择反向传播的优化算法
3. 生成会话已经在训练数据上反复执行方向传播算法

import numpy as np
import tensorflow as tf
rdm = np.random.RandomState(1)
X = rdm.rand(128, 2)
Y = [[int(x1+x2< 1)] for (x1,x2) in X]
print(Y[0:8])
w1 = tf.Variable(tf.random_normal((2, 3), stddev=1, seed=1))
w2 = tf.Variable(tf.random_normal((3, 1), stddev=1, seed=128))
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    print(sess.run(w1))
    print(sess.run(w2))