发新帖

请教:对于同一个模型,预测结果随输入样本数量而改变

[复制链接]
1103 7

快来加入 TensorFlowers 大家庭!

您需要 登录 才可以下载或查看,没有帐号?加入社区

x
目前在做一个softmax的分类,非常基础,是分类电视台标的。输入维度是[None, 96*35]遇到个问题,对于模型的训练,精度可以达到99.9%。把这个模型保存下来,然后调用这个模型进行预测,发现当输入的预测图像矩阵是一副图片,即[1,96*35],不论输入啥图片,哪怕是zeros,都会得到同一个判断分类,但是,如果测试输入矩阵变多,比如一次10幅图[10,96*35],输出就正常了。想问下我哪里做错了导致模型不变的情况下判断结果跟输入的图片个数有关?
下面是我的测试代码
  1. def recognize(img_input, pb_file_path):
  2.     with tf.Graph().as_default():
  3.         output_graph_def = tf.GraphDef()

  4.     with open(pb_file_path, "rb") as f:
  5.         output_graph_def.ParseFromString(f.read())
  6.         _ = tf.import_graph_def(output_graph_def, name="")

  7.     with tf.Session() as sess:
  8.         init = tf.global_variables_initializer()
  9.         sess.run(init)

  10.         input_x = sess.graph.get_tensor_by_name("Input:0")
  11.         # print input_x
  12.        out_softmax = sess.graph.get_tensor_by_name("Y_predict:0")
  13.             
  14.        img_try = img_input

  15.        test_input = np.float32(img_try/255)
  16.        img_out_softmax = sess.run(out_softmax, feed_dict={input_x:test_input})

  17.        prediction_labels = np.argmax(img_out_softmax, axis=1)

  18.        return prediction_labels


  19. #----------------------Use Sub Function to Predict --------------------------------------------
  20. start = 10
  21. for i in range(1,10):  #将测试图像从一次带入1张遍历到一次带入10张,看测试结果
  22.     r = recognize(img_test[start:start+i], "./pretrained/graph.pb")
  23.     print(listmapping(r,TV_LOGO_s))
复制代码
测试结果,可以看到图像为1张的时候结果误判成cctv5+,但是随着一次带入图片变多(图片没有变化,还是这些图,可以理解为总共10张图,第一次带入第一张,第二次带入第一第二张,以此类推),结果就正确了
QQ截图20180507231216.png

这个问题已经困扰我一周了,请指教!!!
最后附上模型截图
QQ截图2ddd.png

非常感谢
yunhai_luo已获得悬赏 10 金币+5 金币

最佳答案

首先再次感谢楼主的分享,借楼主的模型学习了一下batch normalization,收益良多。对于楼主的代码我还没有能力修改,对于出现不稳定性的原因,我比较确信是batch normalization的原因,但是由于没有能力直接对楼主 ...
本楼点评(5) 收起
  • yunhai_luo请问楼主一个可能不相关的问题:楼主的pb_file是怎么得到的?代码里貌似看不出来,也没有导出过计算图。如果是确实是frozen的模型,那就没有变量了,为何楼主要初始化变量呢?
    2018-5-8 08:07 回复
  • oceancjc回复 yunhai_luo :
    你好,我的理解是,图的结构是定死的,但是输入节点还是一个变量,在run的时候需要feed数据的,输出也还是一个变量,中间的权重啥的的确定死了,所以还是需要初始化变量的
    2018-5-8 08:12 回复
  • yunhai_luo回复 oceancjc : 就我所知,固定好的模型应该是不需要初始化变量的,学习了。楼主能说一下tf.global_variables()有什么变量吗?
    2018-5-8 08:37 回复
  • oceancjc回复 yunhai_luo :两个变量,代码的第13和15行
    2018-5-8 11:36 回复
  • yunhai_luo回复 oceancjc :楼主方便分享一下pb文件吗?想学习一下楼主的模型,我在下面解释了,谢谢!
    2018-5-8 13:12 回复

精彩评论7

oceancjc  TF荚荚  发表于 2018-5-8 08:11:24 | 显示全部楼层
你好,我的理解是,图的结构是定死的,但是输入节点还是一个变量,在run的时候需要feed数据的,输出也还是一个变量,中间的权重啥的的确定死了,所以还是需要初始化变量的
本楼点评(0) 收起
yunhai_luo  TF豆豆  发表于 2018-5-8 12:56:08 | 显示全部楼层
本帖最后由 yunhai_luo 于 2018-5-8 13:05 编辑

楼主的问题我解决不了,但我挺好奇楼主frozen的模型是什么情况。我在点评中也提到过,就我所知,固定好的模型应该是不需要初始化变量的。除此之外,输入和输出一般都是不会作为变量存在的。这里的变量指的是tf.global_variables()所给出的GraphKeys.GLOBAL_VARIABLES所涵盖的变量。楼主这里导入固定模型后,所有变量都确实被固化了,但输入和输出成为了GraphKeys.GLOBAL_VARIABLES中的变量,也因此需要初始化变量。不知道楼主构建和训练模型时输入和输出是否也是变量,但这一现象个人没有见过,应该跟楼主模型的特异性有关,不知道楼主是否方便分享一下pb文件以供学习。这里提供一下我的测试代码,模型很傻,请包涵,只是为了解释一下我上面说过的现象:

首先,构建训练模型:
  1. import tensorflow as tf
  2. import numpy as np

  3. x = tf.placeholder(tf.float32, shape=[None, 1])
  4. y_ = tf.layers.dense(x, units=1, name='pred')
  5. loss = tf.losses.mean_squared_error(labels=x, predictions=y_)
  6. optimizer = tf.train.GradientDescentOptimizer(0.01)
  7. train_op = optimizer.minimize(loss)
  8. init = tf.global_variables_initializer()
  9. saver = tf.train.Saver()

  10. print(tf.global_variables())

  11. with tf.Session() as sess:
  12.     sess.run(init)
  13.     for _ in range(10):
  14.         sess.run(train_op, feed_dict={x: np.arange(10).reshape((-1, 1))})
  15.     tf.train.write_graph(sess.graph.as_graph_def(), r'.\test', 'test.pb', False)
  16.     saver.save(sess, r'.\test\test')
复制代码

从输出的tf.global_variables()可以看出,输入和输出都不是变量。另外,这段代码会在当前路径下新建test文件夹,其中保存了计算图,一些元数据和10步训练之后的参数,用于下面freeze模型。
  1. from tensorflow.python.tools import freeze_graph

  2. freeze_graph.freeze_graph(input_graph=r'test\test.pb',
  3.                           input_saver='',
  4.                           input_binary=True,
  5.                           input_checkpoint=r'test\test',
  6.                           output_node_names='pred/BiasAdd',
  7.                           restore_op_name="save/restore_all",
  8.                           filename_tensor_name="save/Const:0",
  9.                           output_graph=r'frozen.pb',
  10.                           clear_devices=True,
  11.                           initializer_nodes='')
复制代码


这段代码会在当前路径下保存一个frozen.pb文件,是固化保存的模型,用于下面恢复模型。根据楼主提供的信息,我不确定楼主是如何保存和恢复模型的,鉴于楼主用的是pb文件,按常见情况,我斗胆推测是这样固化的,请楼主指正。

下面这段代码需要重开python终端运行,目的是排除之前计算图中的残存变量对于理解新恢复模型的干扰。
  1. import numpy as np
  2. import tensorflow as tf

  3. graph_def = tf.GraphDef()
  4. with open(r'frozen.pb', "rb") as f:
  5.     graph_def.ParseFromString(f.read())
  6. tf.import_graph_def(graph_def, name='infer')
  7. x = tf.get_default_graph().get_tensor_by_name('infer/Placeholder:0')
  8. y = tf.get_default_graph().get_tensor_by_name('infer/pred/BiasAdd:0')
  9. print(tf.global_variables())

  10. test = np.random.permutation(10).reshape((-1, 1))

  11. with tf.Session() as sess:
  12.     for i in range(10):
  13.         y_val = sess.run(y, feed_dict={x: test[:i]})
  14.         print(dict(zip(test[:i].flatten().tolist(), np.around(y_val.astype(np.float64), 2).flatten().tolist())))
复制代码

这段代码是恢复模型并用于预测,在这个例子中,从输出的tf.global_variables()可以看出,这里没有任何变量,输入和输出也都不是变量,所以无须初始化变量,得到的预测也大致正确。
本楼点评(1) 收起
  • oceancjc非常感谢你的指点,或许这个跟我得到的奇怪结果有关系,晚上我试试,我会把所有代码贴出来,方便大家一起讨论。
    再次感谢
    2018-5-8 16:54 回复
M丶Sulayman  TF豆豆  发表于 2018-5-8 16:56:52 | 显示全部楼层
yunhai_luo 发表于 2018-5-8 12:56
楼主的问题我解决不了,但我挺好奇楼主frozen的模型是什么情况。我在点评中也提到过,就我所知,固定好的模 ...

赞赞赞,又学到了~我先保存下
本楼点评(0) 收起
M丶Sulayman  TF豆豆  发表于 2018-5-8 16:57:23 | 显示全部楼层
嗯嗯,贴出来,一起学习,改进
本楼点评(0) 收起
oceancjc  TF荚荚  发表于 2018-5-8 22:33:40 | 显示全部楼层
yunhai_luo 发表于 2018-5-8 12:56
楼主的问题我解决不了,但我挺好奇楼主frozen的模型是什么情况。我在点评中也提到过,就我所知,固定好的模 ...

你好,对于引用模型不需要初始化变量的观点是正确的,我已经改正,但是注释掉这两句话并不会对结果有任何影响。还是不对的。为了方便大神们帮我看问题,我将数据集换成了minst,发现有类似的结果,我将所有代码都上传上来。麻烦帮我看下,包括模型,以及pb文件保存方法1.建立并训练模型,保存checkpoint

  1. import numpy as np
  2. import tensorflow as tf
  3. import tensorflow.examples.tutorials.mnist.input_data as input_data
  4. mnist = input_data.read_data_sets(r"D:\MachineLearning\minst", one_hot=True)

  5. def batch_normal(Y,offset_Beta,scale_J,iteration):
  6.     exp_moving_avg = tf.train.ExponentialMovingAverage(0.998, iteration) # adding the iteration prevents from averaging across non-existing iterations
  7.     mean, variance = tf.nn.moments(Y, [0])
  8.     update_moving_averages = exp_moving_avg.apply([mean, variance])
  9.     m = exp_moving_avg.average(mean)
  10.     v = exp_moving_avg.average(variance)
  11.     # Ybn = tf.nn.batch_normalization(Y, m, v, offset_Beta, scale_J, 1e-5)
  12.     Ybn = tf.nn.batch_normalization(Y, mean, variance, offset_Beta, scale_J, 1e-5)
  13.     return Ybn,update_moving_averages


  14. def hidden_layer(X, sizeOutput, iteration = 10, non_linear_name = '',enable_bn=False):
  15.     sizeInput = X.shape[1]
  16.     W = tf.Variable( tf.truncated_normal([int(sizeInput),int(sizeOutput)],stddev=0.001) )
  17.    
  18.     if enable_bn:   
  19.         Z = tf.matmul(X,W)         #In bach norm, the bias B can be ommited due to the offset
  20.         scale_J = tf.Variable(tf.ones([int(sizeOutput)]))
  21.         offset_Beta = tf.Variable(tf.zeros([int(sizeOutput)]))
  22.         Y, update_moving_averages = batch_normal(Z,offset_Beta,scale_J, iteration)
  23.     else:           
  24.         B = tf.Variable(tf.zeros([1,sizeOutput]))
  25.         Y = tf.matmul(X,W) + B
  26.         
  27.         
  28.     if non_linear_name == '':                     return   Y,0
  29.     elif non_linear_name == 'softmax':     A = tf.nn.softmax(Y)
  30.     elif non_linear_name == 'relu':           A = tf.nn.relu(Y)
  31.     elif non_linear_name == 'sigmoid':     A = tf.nn.sigmoid(Y)
  32.     return A, update_moving_averages


  33. #X       = tf.placeholder(tf.float32, [None, 96*35],name = 'Input')
  34. #Y_LABEL = tf.placeholder(tf.float32, [None, CLASSES], name = 'Label')
  35. X       = tf.placeholder(tf.float32, [None, 28*28],name = 'Input')
  36. Y_LABEL = tf.placeholder(tf.float32, [None, 10], name = 'Label')
  37. lr      = tf.placeholder(tf.float32, name = 'LearningRate')
  38. iters   = tf.placeholder(tf.int32, name = 'Iterations')

  39. A0, update_ema0 = hidden_layer(X,512, iters, 'relu',True)
  40. A1, update_ema1 = hidden_layer(A0,256, iters, 'relu',True)
  41. A2, update_ema2 = hidden_layer(A1,128,iters, 'relu',True)
  42. A3, update_ema3 = hidden_layer(A2,64, iters, 'relu',True)
  43. A4, update_ema4 = hidden_layer(A3,32, iters, 'relu',True)
  44. Y_linear,nocare = hidden_layer(A4, Y_LABEL.shape[1])
  45. Y_predict       = tf.nn.softmax(Y_linear,name = 'Y_predict')
  46. update_ema = tf.group(update_ema0, update_ema1, update_ema2, update_ema3, update_ema4)
  47. #update_ema = tf.group(update_ema0, update_ema2, update_ema3)

  48. #cross_entropy = tf.reduce_mean(
  49. #    tf.nn.softmax_cross_entropy_with_logits(labels=Y_LABEL, logits=Y_linear))
  50. cross_entropy = tf.reduce_mean( -tf.reduce_sum(Y_LABEL * tf.log(Y_predict), reduction_indices=[1]) )
  51. #train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
  52. train_step = tf.train.AdamOptimizer(lr).minimize(cross_entropy)
  53. sess = tf.InteractiveSession()
  54. tf.global_variables_initializer().run()


  55. max_learning_rate = 0.1
  56. min_learning_rate = 0.001
  57. decay_speed = 2000.0


  58. saver = tf.train.Saver()
  59. img_train_float = np.float32(mnist.train.images)
  60. img_test_float = np.float32(mnist.test.images)
  61. print(img_train_float.shape)
  62. for _ in range(2000):
  63.     #batch_xs, batch_ys= next_batch(img_train_float,label_train,500)
  64.     batch_xs, batch_ys= batch_xs, batch_ys = mnist.train.next_batch(500)
  65.     learning_rate = min_learning_rate + (max_learning_rate - min_learning_rate) * np.exp(-_/decay_speed)
  66.     sess.run(train_step, feed_dict={X: batch_xs, Y_LABEL: batch_ys, lr:learning_rate})
  67.     if _%100 == 0:
  68.         correct_prediction = tf.equal(tf.argmax(Y_linear, 1), tf.argmax(Y_LABEL, 1))
  69.         accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
  70.         #print('This is round {} ...'.format(_))
  71.         #print(batch_ys[0])
  72.         #showImgfrombytes(batch_xs[0])
  73.         saver.save(sess, "./Model_Minst/TVLogo_5_relu_softmax.ckpt",global_step= _ )
  74.         #print(sess.run(accuracy, feed_dict={X:img_test_float, Y_LABEL: label_test}))
  75.         print(sess.run(accuracy, feed_dict={X:img_test_float, Y_LABEL: mnist.test.labels}))
复制代码
2.保存成pb文件

  1. import tensorflow as tf
  2. with tf.Session() as sess:

  3.     #初始化变量
  4.     sess.run(tf.global_variables_initializer())

  5.     #获取最新的checkpoint,其实就是解析了checkpoint文件
  6.     latest_ckpt = tf.train.latest_checkpoint("./Model_Minst")

  7.     #加载图
  8.     restore_saver = tf.train.import_meta_graph('./Model_Minst/TVLogo_5_relu_softmax.ckpt-1900.meta')

  9.     #恢复图,即将weights等参数加入图对应位置中
  10.     restore_saver.restore(sess, latest_ckpt)

  11.     #将图中的变量转为常量
  12.     output_graph_def = tf.graph_util.convert_variables_to_constants(
  13.     sess, sess.graph_def , ["Y_predict"])
  14.     #将新的图保存到"/pretrained/graph.pb"文件中
  15.     tf.train.write_graph(output_graph_def, 'pretrained', "graph_minst.pb", as_text=False)
复制代码
3.调用2中生成的pb文件预测数据
  1. def recognize(img_input, pb_file_path):
  2.     with tf.Graph().as_default():
  3.         output_graph_def = tf.GraphDef()

  4.         with open(pb_file_path, "rb") as f:
  5.             output_graph_def.ParseFromString(f.read())
  6.             _ = tf.import_graph_def(output_graph_def, name="")

  7.         with tf.Session() as sess:
  8.             #init = tf.global_variables_initializer()
  9.             #sess.run(init)

  10.             input_x = sess.graph.get_tensor_by_name('Input:0')
  11.             #print (input_x)
  12.             out_softmax = sess.graph.get_tensor_by_name("Y_predict:0")
  13.             # print out_softmax
  14.             # out_label = sess.graph.get_tensor_by_name("output:0")
  15.             # print out_label

  16.             # img = io.imread(jpg_path)
  17.             # img = transform.resize(img, (224, 224, 3))
  18.             
  19.             img_try = img_input
  20.             test_input = np.float32(img_try/255)
  21.             img_out_softmax = sess.run(out_softmax, feed_dict={input_x:test_input})

  22.             #print ("img_out_softmax:",img_out_softmax)
  23.             prediction_labels = np.argmax(img_out_softmax, axis=1)
  24.             #print ("label:",prediction_labels)
  25.             return prediction_labels

  26. start = 30
  27. for i in range(1,30):
  28.     r = recognize(mnist.test.images[start:start+i], "./pretrained/graph_minst.pb")
  29.     print(r)
复制代码
结果:
123.png

TV Logo Recog_5relusoftmax_reducing_lr -Debug On Minst.rar

1.93 KB, 下载次数: 40

本楼点评(1) 收起
  • yunhai_luo谢谢分享!简单看了一下,不知道是不是batch_normalization的问题,因为貌似你的均值和方差是来源于整个batch的,batch的任何改变都会反应在你模型的参数变化上,这不仅仅是样本数量,可能即使都是30个样本,但改变其中一些样本,你对没变样本的预测也会改变;而对于batch_normalization的使用应该是区分训练和预测两种情况的。这只是我的感觉,等我有时间仔细实验一下再请教。
    2018-5-9 02:48 回复
yunhai_luo  TF豆豆  发表于 2018-5-9 15:22:43 | 显示全部楼层
本帖最后由 yunhai_luo 于 2018-5-9 15:25 编辑
oceancjc 发表于 2018-5-8 22:33
你好,对于引用模型不需要初始化变量的观点是正确的,我已经改正,但是注释掉这两句话并不会对结果有任何 ...

首先再次感谢楼主的分享,借楼主的模型学习了一下batch normalization,收益良多。对于楼主的代码我还没有能力修改,对于出现不稳定性的原因,我比较确信是batch normalization的原因,但是由于没有能力直接对楼主的代码进行修改测试,不好说百分百肯定,希望下面我的一些心得能对楼主有帮助。在分享拙见之前,想请教楼主两个问题:
1. 我只对batch normalization代码方面有些许收获,关于它对模型拟合学习上的作用(比如说数学上的特性)完全不了解,楼主能否谈谈batch normalization对于模型哪方面有所提升?有什么原理?有什么适用问题?

2. 楼主模型中每一层都进行了batch normalization,在其他例子中也见过这样的,请问这是常见或者必要的作法吗?它跟其他层应该如何搭配比较好?

先重复一下我点评里的分析,楼主模型中batch normalization部分,均值和方差都是来源于输入特征数据的,而且与batch的构成有关。此外,均值和方差都是张量而不是变量,所以不存在训练和固定的问题,也就是说在楼主导入固定模型后,这两个量仍然会随输入特征数据变化,定性的说,这就有可能解释楼主说的“预测结果随输入样本数量而改变”。至于我说的关于即使样本数量不变而只改变样本构成的做法,根据上述解释,可以推测也同样会出现不稳定性。这个假说可以通过将楼主代码最后的循环改为以下代码来证实:
  1. start = 30
  2. for i in range(1,30):
  3.     r = recognize(mnist.test.images[i:i+30], "graph_minst.pb")
  4.     print(np.pad(r, (i,0), 'constant'))
复制代码

结果我就不贴了,随着这30个样本抽样窗口的移动,我的运行可以看到不稳定性出现。这个结果算是从侧面说明了楼主的问题很有可能与batch normalization有关。

下面说有什么办法,我只有一个比较简单又比较无脑的例子,应该不适用于楼主,但算是给出一个稳定的例子,加上后面的一些想法,希望楼主能找到适合自己的解决办法。下面这个例子用的是tf.layers.batch_normalization而不是tf.nn.batch_normalization,也就是捡现成的,tf.layers.batch_normalization有一个"training"参数可以用来区分训练和预测(到这个地步我不打算深入关于区分的实现了,比较懒,不好意思)。

构建训练模型(这里特别缩短了训练次数以便降低精确度,这样后面的不稳定性更容易看到):
  1. import tensorflow as tf
  2. from tensorflow.examples.tutorials.mnist import input_data

  3. mnist = input_data.read_data_sets("test", one_hot=True)

  4. tf.reset_default_graph()
  5. x = tf.placeholder('float32', (None, 784), name='x')
  6. y = tf.placeholder('float32', (None, 10), name='y')
  7. phase = tf.placeholder(tf.bool, name='phase')

  8. dense = tf.layers.dense(x, 100)
  9. batchnorm = tf.layers.batch_normalization(dense, training=phase)
  10. activation = tf.nn.relu(batchnorm, 'relu')
  11. logits = tf.layers.dense(activation, 10)
  12. predicts = tf.argmax(logits, 1, name='predicts')
  13. accuracy = tf.reduce_mean(tf.cast(
  14.     tf.equal(tf.argmax(y, 1), predicts), tf.float32))
  15. loss = tf.losses.softmax_cross_entropy(onehot_labels=y, logits=logits)

  16. update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
  17. with tf.control_dependencies(update_ops):
  18.     train_op = tf.train.GradientDescentOptimizer(0.01).minimize(loss)

  19. saver = tf.train.Saver()
  20. with tf.Session() as sess:
  21.     sess.run(tf.global_variables_initializer())
  22.     for _ in range(200):
  23.         x_train, y_train = mnist.train.next_batch(100)
  24.         sess.run(train_op, feed_dict={'x:0': x_train,
  25.                             'y:0': y_train,
  26.                             'phase:0': 1})
  27.     print(sess.run(accuracy, feed_dict={'x:0': mnist.test.images,
  28.                                         'y:0': mnist.test.labels,
  29.                                         'phase:0': 0}))
  30.     saver.save(sess, 'testpb/testpb.ckpt')
复制代码

保存模型:
  1. import tensorflow as tf

  2. restore_saver = tf.train.import_meta_graph('testpb/testpb.ckpt.meta')
  3. with tf.Session() as sess:
  4.     restore_saver.restore(sess, tf.train.latest_checkpoint('testpb'))
  5.     output_graph_def = tf.graph_util.convert_variables_to_constants(
  6.         sess, sess.graph_def , ['predicts'])
  7. tf.train.write_graph(output_graph_def, '.', 'graph_mnist.pb', as_text=False)
复制代码

导入模型进行预测:
  1. import numpy as np
  2. import tensorflow as tf
  3. import tensorflow.examples.tutorials.mnist.input_data as input_data

  4. mnist = input_data.read_data_sets('test', one_hot=True)

  5. graph_def = tf.GraphDef()
  6. with open('graph_mnist.pb', "rb") as f:
  7.     graph_def.ParseFromString(f.read())
  8. tf.import_graph_def(graph_def, name='')

  9. with tf.Session() as sess:
  10.     for i in range(30):
  11.         print(sess.run('predicts:0', feed_dict={'x:0': mnist.test.images[:i],
  12.                                                 'phase:0': 1}))
复制代码

当你将最后一行的'phase:0': 1改为'phase:0': 0后,应该可以观察到区别。

最后说一下对于实现训练预测区分的一个小想法,楼主代码中用到了"tf.train.ExponentialMovingAverage",我大胆猜测是想要训练完成后用这个替代均值和方差,从而实现模型的稳定。看过一些例子,确实有训练完替换的做法,想来这应该可以解决楼主模型稳定性的问题。


本楼点评(0) 收起
oceancjc  TF荚荚  发表于 2018-5-9 23:39:59 | 显示全部楼层
yunhai_luo 发表于 2018-5-9 15:22
首先再次感谢楼主的分享,借楼主的模型学习了一下batch normalization,收益良多。对于楼主的代码我还没有 ...

是的,我以为freeze了就把batch norm里的参数也定死了,嗯嗯,这点是我弄错了,你分析的对,如果这些参数不是定死的,那么就是随着batch size而变化,所以会根据测试的batch size而得到不同的结果,我尝试去重新改下模型架构后再交流,离正确答案越来越近了,非常感谢

本楼点评(0) 收起
您需要登录后才可以回帖 登录 | 加入社区

本版积分规则

主题

帖子

6

积分
快速回复 返回顶部 返回列表