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

2022-03-10

第一个设计思路是将需要使用的变量先以张量的形式保存，

没有实际值填充。

然后设计网络架构，也就是架构。

只能描述数据关系和层之间的关系。

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

看不出来，下划线部分是输入！

很多人喜欢调试程序来获取数据流，但对于这些网络，它真的失败了，因为你什么都看不到。

然后介绍这个展示页面，它可以让你清楚的观察数据之间的关系和数据的特征，例如：

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

 1 import tensorflow as tf
 2 import numpy as np
 3 
 4 #构造输入数据（我们用神经网络拟合x_data和y_data之间的关系）
 5 x_data = np.linspace(-1,1,300)[:, np.newaxis] #-1到1等分300份形成的二维矩阵
 6 noise = np.random.normal(0,0.05, x_data.shape) #噪音，形状同x_data在0-0.05符合正态分布的小数
 7 y_data = np.square(x_data)-0.5+noise #x_data平方，减0.05，再加噪音值
 8 
 9 #输入层（1个神经元）
10 xs = tf.placeholder(tf.float32, [None, 1]) #占位符，None表示n*1维矩阵，其中n不确定
11 ys = tf.placeholder(tf.float32, [None, 1]) #占位符，None表示n*1维矩阵，其中n不确定
12 
13 #隐层（10个神经元）
14 W1 = tf.Variable(tf.random_normal([1,10])) #权重，1*10的矩阵，并用符合正态分布的随机数填充
15 b1 = tf.Variable(tf.zeros([1,10])+0.1) #偏置，1*10的矩阵，使用0.1填充
16 Wx_plus_b1 = tf.matmul(xs,W1) + b1 #矩阵xs和W1相乘，然后加上偏置
17 output1 = tf.nn.relu(Wx_plus_b1) #激活函数使用tf.nn.relu
18 
19 #输出层（1个神经元）
20 W2 = tf.Variable(tf.random_normal([10,1]))
21 b2 = tf.Variable(tf.zeros([1,1])+0.1)
22 Wx_plus_b2 = tf.matmul(output1,W2) + b2
23 output2 = Wx_plus_b2
24 
25 #损失

26 loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys-output2),reduction_indices=[1])) #在第一维上，偏差平方后求和，再求平均值，来计算损失
27 train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss) # 使用梯度下降法，设置步长0.1，来最小化损失
28 
29 #初始化
30 init = tf.global_variables_initializer() #初始化所有变量
31 sess = tf.Session()
32 sess.run(init) #变量初始化
33 
34 #训练
35 for i in range(1000): #训练1000次
36     _,loss_value = sess.run([train_step,loss],feed_dict={xs:x_data,ys:y_data}) #进行梯度下降运算，并计算每一步的损失
37     if(i%50==0):
38         print(loss_value) # 每50步输出一次损失

加入后的代码如下：

  1 import tensorflow as tf
  2 import numpy as np
  3 max_steps=1000
  4 learning_rate=0.001 #学习率
  5 dropout=0.9 #保留的数据
  6 log_dir='./logs/xyhuashuguanxi'
  7 
  8 sess=tf.InteractiveSession()
  9 
 10 #构造输入数据（我们用神经网络拟合x_data和y_data之间的关系）
 11 x_data = np.linspace(-1,1,300)[:, np.newaxis] #-1到1等分300份形成的二维矩阵
 12 noise = np.random.normal(0,0.05, x_data.shape) #噪音，形状同x_data在0-0.05符合正态分布的小数
 13 y_data = np.square(x_data)-0.5+noise #x_data平方，减0.05，再加噪音值
 14 
 15 with tf.name_scope('input'):#with块中名字才是最重要的一个块
 16     #输入层（1个神经元）
 17     x = tf.placeholder(tf.float32, [None, 1]) #占位符，None表示n*1维矩阵，其中n不确定
 18     y = tf.placeholder(tf.float32, [None, 1]) #占位符，None表示n*1维矩阵，其中n不确定
 19 
 20 
 21 #定义神经网络的初始化方法

 22 def weight_varible():
 23     # initial=tf.truncated_normal(shape,stddev=0.1) #截断正态分布 这里可以用he_initinelize
 24     initial =tf.Variable(tf.random_normal([1, 10]))  # 权重，1*10的矩阵，并用符合正态分布的随机数填充
 25     return tf.Variable(initial) #创建一个变量
 26 
 27 def bias_variable(): #截距
 28     # initial = tf.constant(0.1,shape=shape)
 29     initial= tf.Variable(tf.zeros([1, 10]) + 0.1)
 30     return tf.Variable(initial)
 31 
 32 #以下代码是关于画图的，
 33 # 定义variable变量的数据汇总函数，我们计算出变量的mean、stddev、max、min
 34 #对这些标量数据使用tf.summary.scalar进行记录和汇总，使用tf.summary.histogram直接记录变量var的直方图数据
 35 def variable_summaries(var):
 36     with tf.name_scope('summaries'):
 37         mean=tf.reduce_mean(var)
 38         tf.summary.scalar('mean',mean)
 39         with tf.name_scope('stddev'):
 40             stddev=tf.sqrt(tf.reduce_mean(tf.square(var-mean)))
 41 
 42         tf.summary.scalar('stddev',stddev)
 43         tf.summary.scalar('max',tf.reduce_max(var))
 44         tf.summary.scalar('min',tf.reduce_min(var))
 45         tf.summary.histogram('histogram',var)
 46 
 47 # 设计一个MLP多层神经网络来训练数据，在每一层中都对模型数据进行汇总
 48 def nn_layer(input_tensor, layer_name, act=tf.nn.relu):
 49     with tf.name_scope(layer_name):
 50         # 定义一个隐藏层input_dim上一层 output_dim本层输出
 51         with tf.name_scope('weights'):
 52             weights = weight_varible()  # shape传进来是上一层输入，
 53             # 本层输出如果是MLP，就是全连接可以知道参数个数
 54             variable_summaries(weights)  # 把权重的各个中标（方差+平均值）进行总结
 55         with tf.name_scope('biases'):
 56             biases = bias_variable()
 57             variable_summaries(biases)

 58         with tf.name_scope('Wx_plus_b'):
 59             preactivate = tf.matmul(input_tensor, weights) + biases  # 带到激活函数之前的公式
 60             tf.summary.histogram('pre_activations', preactivate)
 61             activations = act(preactivate, name='activations')
 62             # 运用激活函数 函数里面传函数 高阶函数
 63             return activations
 64 
 65 
 66 #隐层（10个神经元）
 67 hidden1=nn_layer(x,'layer1') #建立第一层 隐藏层
 68 # with tf.name_scope('dropout'):
 69 #     keep_prob=tf.placeholder(tf.float32)
 70 #     tf.summary.scalar('dropout_keep_probability',keep_prob)
 71 #     dropped=tf.nn.dropout(hidden1,keep_prob) #应用drop_out函数，保留下来的数据
 72 
 73 # W1 = tf.Variable(tf.random_normal([1,10])) #权重，1*10的矩阵，并用符合正态分布的随机数填充
 74 # b1 = tf.Variable(tf.zeros([1,10])+0.1) #偏置，1*10的矩阵，使用0.1填充
 75 # Wx_plus_b1 = tf.matmul(x,W1) + b1 #矩阵xs和W1相乘，然后加上偏置
 76 # output1 = tf.nn.relu(Wx_plus_b1) #激活函数使用tf.nn.relu
 77 
 78 #然后使用nn_layer定义神经网络输出层，其输入维度为上一层隐含节点数500，输出维度为类别数10，
 79 # 同时激活函数为全等映射identity，暂时不适用softmax
 80 #然后使用nn_layer定义神经网络输出层，其输入维度为上一层隐含节点数500，输出维度为类别数10，
 81 # 同时激活函数为全等映射identity，暂时不适用softmax
 82 # output2 =nn_layer(dropped,'layer2',act=tf.identity)#建立第二层 输出层
 83 #输出层（1个神经元）
 84 W2 = tf.Variable(tf.random_normal([10,1]))
 85 b2 = tf.Variable(tf.zeros([1,1])+0.1)
 86 Wx_plus_b2 = tf.matmul(hidden1,W2) + b2
 87 output2 = Wx_plus_b2
 88 
 89 #损失
 90 #使用tf.nn.softmax_cross_entropy_with_logits()对前面的输出层的结果进行softmax处理并计算
 91 # 交叉熵损失cross_entopy,计算平均损失，使用tf.summary.scalar进行统计汇总
 92 with tf.name_scope('cross_entropy'):
 93     # diff=tf.nn.softmax_cross_entropy_with_logits(logits=y,labels=y)

 94     loss = tf.reduce_mean(tf.reduce_sum(tf.square(y - output2), reduction_indices=[1]))  # 在第一维上，偏差平方后求和，再求平均值，来计算损失
 95     #输出层给出结果logits=y，每一行的y是有10个数预测10个值，然后利用这10个值做归一化，
 96     # 然后具备一个概率的含义，第二不计算交叉熵
 97     with tf.name_scope('total'):
 98         cross_entropy=tf.reduce_mean(loss)#平均损失
 99 tf.summary.scalar('cross_entorpy',cross_entropy)
100 
101 # loss = tf.reduce_mean(tf.reduce_sum(tf.square(y-output2),reduction_indices=[1])) #在第一维上，偏差平方后求和，再求平均值，来计算损失
102 #下面使用Adam优化器对损失进行优化，同时统计预测正确的样本数并计算正确率accuracy，汇总
103 with tf.name_scope('train'):
104     train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss) # 使用梯度下降法，设置步长0.1，来最小化损失
105 
106 #Adamoptimizer比SGD更好一些，下降速度更快，更容易计算局部最优解，当数据量大的时候不如SGD
107 #learning_rate虽然是固定的，后面会自适应，根据上一次的结果，所以大数据量的话，不如定义好策略，这样省时间
108 with tf.name_scope('accuracy'):
109     with tf.name_scope('correct_predicition'):
110         correct_predition=tf.equal(tf.argmax(y,1),tf.argmax(output2,1))
111         #预测值最大的索引和真实值的索引
112     with tf.name_scope('accuracy'):
113         accuracy=tf.reduce_mean(tf.cast(correct_predition,tf.float32))
114         #true 1 false 0 reduce_mean 是一个比例得到的结果
115 tf.summary.scalar('accuracy',accuracy)
116 
117 #因为我们之前定义了太多的tf.summary汇总操作，注意执行这些操作太
118 # 麻烦，使用tf.summary.merge_all()直接获取所有汇总操作，以便后面执行
119 merged=tf.summary.merge_all()
120 #定义两个tf.summary.FileWirter文件记录器在不同的子目录，分别用来存储训练和测试的日志数据
121 train_writer=tf.summary.FileWriter(log_dir+'/train',sess.graph)
122 test_writer=tf.summary.FileWriter(log_dir+'/test')
123 #同时，将Session计算图sess.graph加入训练过程，这样在TensorBoard的GRAPHS窗口中就能展示
124 # 整个计算图的可视化效果，最后初始化全部变量
125 tf.global_variables_initializer().run()
126 
127 #初始化
128 init = tf.global_variables_initializer() #初始化所有变量
129 sess = tf.Session()

130 sess.run(init) #变量初始化
131 
132 
133 # #定义feed_dict函数，如果是训练，需要设置dropout，如果是测试，keep_prob设置为1
134 # def feed_dict(train):
135 #     if train:#如果是训练数据的话需要droupout，测试的时候不要Droupout
136 #         xs,ys= mnist.train.next_batch(100) #每一次拿一批次数据去训练
137 #         k=dropout
138 #     else:
139 #         xs,ys=mnist.test.images,mnist.test.labels #真正测试的话全部测试，不是拿一批次的数据了
140 #         k=1.0
141 #     return {x:xs,y_:ys,keep_prob:k}
142 
143 #执行训练、测试、日志记录操作。创建模型的保存器
144 saver=tf.train.Saver()
145 #训练
146 for i in range(max_steps): #训练1000次
147     # _,loss_value = sess.run([train_step,loss],feed_dict={x:x_data,y:y_data}) #进行梯度下降运算，并计算每一步的损失
148     if(i%50==0):
149         summary, loss_value = sess.run([merged, accuracy], feed_dict={x:x_data,y:y_data})
150         test_writer.add_summary(summary, i)  # 然后写出
151         print('Accuracy at step %s:%s' % (i, loss_value))
152         print(loss_value) # 每50步输出一次损失
153 
154 train_writer.close()
155 test_writer.close()

运行后，打开cmd，进入logs文件根目录（必须！！！），输入–=logs根目录，后面会输出url，在你的浏览器中可以打开：

或者直接在浏览器中输入

:6006

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

分类：

技术要点：

相关文章：