使用tensorflow设计的网络模型看不到数据流向怎么办

首先tensorflow的设计思想就是先把需要用的变量已张量的形式保存，

实际上并没有实质的数值填充。

然后设计网络架构，也仅仅是架构而已，

只能说明数据关系和层与层之间的关系。

真正的数据输入是在主程序入口处，一般如下所示：

看到没，划线部分即为输入！

很多人喜欢用debug调试程序，以获得数据流向，但是对于这些网络确实失败的，因为你啥也看不到。

那么tensorflow就引入了tensorboard这个显示页面，可以让你清晰的观察数据之间的关系，以及数据特点，举个例子如下：

拟合x与y的关系，网络代码如下：

import tensorflow as tf
import numpy as np

#构造输入数据（我们用神经网络拟合x_data和y_data之间的关系）
x_data = np.linspace(-1,1,300)[:, np.newaxis] #-1到1等分300份形成的二维矩阵
noise = np.random.normal(0,0.05, x_data.shape) #噪音，形状同x_data在0-0.05符合正态分布的小数
y_data = np.square(x_data)-0.5+noise #x_data平方，减0.05，再加噪音值

#输入层（1个神经元）
xs = tf.placeholder(tf.float32, [None, 1]) #占位符，None表示n*1维矩阵，其中n不确定
ys = tf.placeholder(tf.float32, [None, 1]) #占位符，None表示n*1维矩阵，其中n不确定

#隐层（10个神经元）
W1 = tf.Variable(tf.random_normal([1,10])) #权重，1*10的矩阵，并用符合正态分布的随机数填充
b1 = tf.Variable(tf.zeros([1,10])+0.1) #偏置，1*10的矩阵，使用0.1填充
Wx_plus_b1 = tf.matmul(xs,W1) + b1 #矩阵xs和W1相乘，然后加上偏置
output1 = tf.nn.relu(Wx_plus_b1) #激活函数使用tf.nn.relu

#输出层（1个神经元）
W2 = tf.Variable(tf.random_normal([10,1]))
b2 = tf.Variable(tf.zeros([1,1])+0.1)
Wx_plus_b2 = tf.matmul(output1,W2) + b2
output2 = Wx_plus_b2

#损失
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys-output2),reduction_indices=[1])) #在第一维上，偏差平方后求和，再求平均值，来计算损失
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss) # 使用梯度下降法，设置步长0.1，来最小化损失

#初始化
init = tf.global_variables_initializer() #初始化所有变量
sess = tf.Session()
sess.run(init) #变量初始化

#训练
for i in range(1000): #训练1000次
    _,loss_value = sess.run([train_step,loss],feed_dict={xs:x_data,ys:y_data}) #进行梯度下降运算，并计算每一步的损失
    if(i%50==0):
        print(loss_value) # 每50步输出一次损失

加入tensorboard后的代码如下：

import tensorflow as tf
import numpy as np
max_steps=1000
learning_rate=0.001 #学习率
dropout=0.9 #保留的数据
log_dir='./logs/xyhuashuguanxi'

sess=tf.InteractiveSession()

#构造输入数据（我们用神经网络拟合x_data和y_data之间的关系）
x_data = np.linspace(-1,1,300)[:, np.newaxis] #-1到1等分300份形成的二维矩阵
noise = np.random.normal(0,0.05, x_data.shape) #噪音，形状同x_data在0-0.05符合正态分布的小数
y_data = np.square(x_data)-0.5+noise #x_data平方，减0.05，再加噪音值

with tf.name_scope('input'):#with块中名字才是最重要的一个块
    #输入层（1个神经元）
    x = tf.placeholder(tf.float32, [None, 1]) #占位符，None表示n*1维矩阵，其中n不确定
    y = tf.placeholder(tf.float32, [None, 1]) #占位符，None表示n*1维矩阵，其中n不确定


#定义神经网络的初始化方法
def weight_varible():
    # initial=tf.truncated_normal(shape,stddev=0.1) #截断正态分布 这里可以用he_initinelize
    initial =tf.Variable(tf.random_normal([1, 10]))  # 权重，1*10的矩阵，并用符合正态分布的随机数填充
    return tf.Variable(initial) #创建一个变量

def bias_variable(): #截距
    # initial = tf.constant(0.1,shape=shape)
    initial= tf.Variable(tf.zeros([1, 10]) + 0.1)
    return tf.Variable(initial)

#以下代码是关于画图的，
# 定义variable变量的数据汇总函数，我们计算出变量的mean、stddev、max、min
#对这些标量数据使用tf.summary.scalar进行记录和汇总，使用tf.summary.histogram直接记录变量var的直方图数据
def variable_summaries(var):
    with tf.name_scope('summaries'):
        mean=tf.reduce_mean(var)
        tf.summary.scalar('mean',mean)
        with tf.name_scope('stddev'):
            stddev=tf.sqrt(tf.reduce_mean(tf.square(var-mean)))

        tf.summary.scalar('stddev',stddev)
        tf.summary.scalar('max',tf.reduce_max(var))
        tf.summary.scalar('min',tf.reduce_min(var))
        tf.summary.histogram('histogram',var)

# 设计一个MLP多层神经网络来训练数据，在每一层中都对模型数据进行汇总
def nn_layer(input_tensor, layer_name, act=tf.nn.relu):
    with tf.name_scope(layer_name):
        # 定义一个隐藏层input_dim上一层 output_dim本层输出
        with tf.name_scope('weights'):
            weights = weight_varible()  # shape传进来是上一层输入，
            # 本层输出如果是MLP，就是全连接可以知道参数个数
            variable_summaries(weights)  # 把权重的各个中标（方差+平均值）进行总结
        with tf.name_scope('biases'):
            biases = bias_variable()
            variable_summaries(biases)
        with tf.name_scope('Wx_plus_b'):
            preactivate = tf.matmul(input_tensor, weights) + biases  # 带到激活函数之前的公式
            tf.summary.histogram('pre_activations', preactivate)
            activations = act(preactivate, name='activations')
            # 运用激活函数 函数里面传函数 高阶函数
            return activations


#隐层（10个神经元）
hidden1=nn_layer(x,'layer1') #建立第一层 隐藏层
# with tf.name_scope('dropout'):
#     keep_prob=tf.placeholder(tf.float32)
#     tf.summary.scalar('dropout_keep_probability',keep_prob)
#     dropped=tf.nn.dropout(hidden1,keep_prob) #应用drop_out函数，保留下来的数据

# W1 = tf.Variable(tf.random_normal([1,10])) #权重，1*10的矩阵，并用符合正态分布的随机数填充
# b1 = tf.Variable(tf.zeros([1,10])+0.1) #偏置，1*10的矩阵，使用0.1填充
# Wx_plus_b1 = tf.matmul(x,W1) + b1 #矩阵xs和W1相乘，然后加上偏置
# output1 = tf.nn.relu(Wx_plus_b1) #激活函数使用tf.nn.relu

#然后使用nn_layer定义神经网络输出层，其输入维度为上一层隐含节点数500，输出维度为类别数10，
# 同时激活函数为全等映射identity，暂时不适用softmax
#然后使用nn_layer定义神经网络输出层，其输入维度为上一层隐含节点数500，输出维度为类别数10，
# 同时激活函数为全等映射identity，暂时不适用softmax
# output2 =nn_layer(dropped,'layer2',act=tf.identity)#建立第二层 输出层
#输出层（1个神经元）
W2 = tf.Variable(tf.random_normal([10,1]))
b2 = tf.Variable(tf.zeros([1,1])+0.1)
Wx_plus_b2 = tf.matmul(hidden1,W2) + b2
output2 = Wx_plus_b2

#损失
#使用tf.nn.softmax_cross_entropy_with_logits()对前面的输出层的结果进行softmax处理并计算
# 交叉熵损失cross_entopy,计算平均损失，使用tf.summary.scalar进行统计汇总
with tf.name_scope('cross_entropy'):
    # diff=tf.nn.softmax_cross_entropy_with_logits(logits=y,labels=y)
    loss = tf.reduce_mean(tf.reduce_sum(tf.square(y - output2), reduction_indices=[1]))  # 在第一维上，偏差平方后求和，再求平均值，来计算损失
    #输出层给出结果logits=y，每一行的y是有10个数预测10个值，然后利用这10个值做归一化，
    # 然后具备一个概率的含义，第二不计算交叉熵
    with tf.name_scope('total'):
        cross_entropy=tf.reduce_mean(loss)#平均损失
tf.summary.scalar('cross_entorpy',cross_entropy)

# loss = tf.reduce_mean(tf.reduce_sum(tf.square(y-output2),reduction_indices=[1])) #在第一维上，偏差平方后求和，再求平均值，来计算损失
#下面使用Adam优化器对损失进行优化，同时统计预测正确的样本数并计算正确率accuracy，汇总
with tf.name_scope('train'):
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss) # 使用梯度下降法，设置步长0.1，来最小化损失

#Adamoptimizer比SGD更好一些，下降速度更快，更容易计算局部最优解，当数据量大的时候不如SGD
#learning_rate虽然是固定的，后面会自适应，根据上一次的结果，所以大数据量的话，不如定义好策略，这样省时间
with tf.name_scope('accuracy'):
    with tf.name_scope('correct_predicition'):
        correct_predition=tf.equal(tf.argmax(y,1),tf.argmax(output2,1))
        #预测值最大的索引和真实值的索引
    with tf.name_scope('accuracy'):
        accuracy=tf.reduce_mean(tf.cast(correct_predition,tf.float32))
        #true 1 false 0 reduce_mean 是一个比例得到的结果
tf.summary.scalar('accuracy',accuracy)

#因为我们之前定义了太多的tf.summary汇总操作，注意执行这些操作太
# 麻烦，使用tf.summary.merge_all()直接获取所有汇总操作，以便后面执行
merged=tf.summary.merge_all()
#定义两个tf.summary.FileWirter文件记录器在不同的子目录，分别用来存储训练和测试的日志数据
train_writer=tf.summary.FileWriter(log_dir+'/train',sess.graph)
test_writer=tf.summary.FileWriter(log_dir+'/test')
#同时，将Session计算图sess.graph加入训练过程，这样在TensorBoard的GRAPHS窗口中就能展示
# 整个计算图的可视化效果，最后初始化全部变量
tf.global_variables_initializer().run()

#初始化
init = tf.global_variables_initializer() #初始化所有变量
sess = tf.Session()
sess.run(init) #变量初始化


# #定义feed_dict函数，如果是训练，需要设置dropout，如果是测试，keep_prob设置为1
# def feed_dict(train):
#     if train:#如果是训练数据的话需要droupout，测试的时候不要Droupout
#         xs,ys= mnist.train.next_batch(100) #每一次拿一批次数据去训练
#         k=dropout
#     else:
#         xs,ys=mnist.test.images,mnist.test.labels #真正测试的话全部测试，不是拿一批次的数据了
#         k=1.0
#     return {x:xs,y_:ys,keep_prob:k}

#执行训练、测试、日志记录操作。创建模型的保存器
saver=tf.train.Saver()
#训练
for i in range(max_steps): #训练1000次
    # _,loss_value = sess.run([train_step,loss],feed_dict={x:x_data,y:y_data}) #进行梯度下降运算，并计算每一步的损失
    if(i%50==0):
        summary, loss_value = sess.run([merged, accuracy], feed_dict={x:x_data,y:y_data})
        test_writer.add_summary(summary, i)  # 然后写出
        print('Accuracy at step %s:%s' % (i, loss_value))
        print(loss_value) # 每50步输出一次损失

train_writer.close()
test_writer.close()

 运行后，打开cmd,进入到logs文件的根目录下（一定要！！！），输入tensorboard --logdir=logs的根目录，等下会输出网址，在你的浏览器打开就可以了：

 或者在浏览器中直接输入

 http://localhost:6006 

还是不行的话，可能和你的电脑配置有关。