当应用于图像层时来自Conv层的权重给出饱和输出

Question

当我使用训练有素的体重时，我用image_layer可视化我的第一层输出。但是，当我尝试想象时，我得到如下白色图像：

忽略最后四个，过滤器大小为7x7，其中有32个。

该模型基于以下架构（代码附加）：

import numpy as np
import tensorflow as tf
import cv2
from matplotlib import pyplot as plt
% matplotlib inline

model_path = "T_set_4/Model/model.ckpt"

# Define the model parameters
# Convolutional Layer 1.
filter_size1 = 7          # Convolution filters are 7 x 7 pixels.
num_filters1 = 32         # There are 32 of these filters.

# Convolutional Layer 2.
filter_size2 = 7          # Convolution filters are 7 x 7 pixels.
num_filters2 = 64         # There are 64 of these filters.

# Fully-connected layer.
fc_size = 512             # Number of neurons in fully-connected layer.

# Define the data dimensions
# We know that MNIST images are 48 pixels in each dimension.
img_size = 48

# Images are stored in one-dimensional arrays of this length.
img_size_flat = img_size * img_size

# Tuple with height and width of images used to reshape arrays.
img_shape = (img_size, img_size)

# Number of colour channels for the images: 1 channel for gray-scale.
num_channels = 1

# Number of classes, one class for each of 10 digits.
num_classes = 2

def new_weights(shape):
    return tf.Variable(tf.truncated_normal(shape, stddev=0.05))

def new_biases(length):
    return tf.Variable(tf.constant(0.05, shape=[length]))

def new_conv_layer(input,              # The previous layer.
               num_input_channels, # Num. channels in prev. layer.
               filter_size,        # Width and height of each filter.
               num_filters,        # Number of filters.
               use_pooling=True):  # Use 2x2 max-pooling.

# Shape of the filter-weights for the convolution.
# This format is determined by the TensorFlow API.
shape = [filter_size, filter_size, num_input_channels, num_filters]

# Create new weights aka. filters with the given shape.
weights = new_weights(shape=shape)

# Create new biases, one for each filter.
biases = new_biases(length=num_filters)

# Create the TensorFlow operation for convolution.
# Note the strides are set to 1 in all dimensions.
# The first and last stride must always be 1,
# because the first is for the image-number and
# the last is for the input-channel.
# But e.g. strides=[1, 2, 2, 1] would mean that the filter
# is moved 2 pixels across the x- and y-axis of the image.
# The padding is set to 'SAME' which means the input image
# is padded with zeroes so the size of the output is the same.
layer = tf.nn.conv2d(input=input,
                     filter=weights,
                     strides=[1, 1, 1, 1],
                     padding='SAME')

# Add the biases to the results of the convolution.
# A bias-value is added to each filter-channel.
layer += biases

# Rectified Linear Unit (ReLU).
# It calculates max(x, 0) for each input pixel x.
# This adds some non-linearity to the formula and allows us
# to learn more complicated functions.
layer = tf.nn.relu(layer)

# Use pooling to down-sample the image resolution?
if use_pooling:
    # This is 2x2 max-pooling, which means that we
    # consider 2x2 windows and select the largest value
    # in each window. Then we move 2 pixels to the next window.
    layer = tf.nn.max_pool(value=layer,
                           ksize=[1, 2, 2, 1],
                           strides=[1, 2, 2, 1],
                           padding='SAME')
# norm1
norm1 = tf.nn.lrn(layer, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75,
                name='norm1')

# Note that ReLU is normally executed before the pooling,
# but since relu(max_pool(x)) == max_pool(relu(x)) we can
# save 75% of the relu-operations by max-pooling first.

# We return both the resulting layer and the filter-weights
# because we will plot the weights later.
return layer, weights

def flatten_layer(layer):
# Get the shape of the input layer.
    layer_shape = layer.get_shape()

# The shape of the input layer is assumed to be:
# layer_shape == [num_images, img_height, img_width, num_channels]

# The number of features is: img_height * img_width * num_channels
# We can use a function from TensorFlow to calculate this.
num_features = layer_shape[1:4].num_elements()

# Reshape the layer to [num_images, num_features].
# Note that we just set the size of the second dimension
# to num_features and the size of the first dimension to -1
# which means the size in that dimension is calculated
# so the total size of the tensor is unchanged from the reshaping.
layer_flat = tf.reshape(layer, [-1, num_features])

# The shape of the flattened layer is now:
# [num_images, img_height * img_width * num_channels]

# Return both the flattened layer and the number of features.
return layer_flat, num_features

def new_fc_layer(input,          # The previous layer.
             num_inputs,     # Num. inputs from prev. layer.
             num_outputs,    # Num. outputs.
             use_relu=True): # Use Rectified Linear Unit (ReLU)?

# Create new weights and biases.
weights = new_weights(shape=[num_inputs, num_outputs])
biases = new_biases(length=num_outputs)

# Calculate the layer as the matrix multiplication of
# the input and weights, and then add the bias-values.
layer = tf.matmul(input, weights) + biases

# Use ReLU?
if use_relu:
    layer = tf.nn.relu(layer)

return layer


# Create the model

tf.reset_default_graph()

x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='x')
x_image = tf.reshape(x, [-1, img_size, img_size, num_channels])

y_true = tf.placeholder(tf.float32, shape=[None, num_classes], 
name='y_true')
y_true_cls = tf.argmax(y_true, dimension=1)

# Create the model footprint

layer_conv1, weights_conv1 =     new_conv_layer(input=x_image,
           num_input_channels=num_channels,
           filter_size=filter_size1,
           num_filters=num_filters1,
           use_pooling=True)

layer_conv2, weights_conv2 =     new_conv_layer(input=layer_conv1,
           num_input_channels=num_filters1,
           filter_size=filter_size2,
           num_filters=num_filters2,
           use_pooling=True)

layer_flat, num_features = flatten_layer(layer_conv2)

layer_fc1 = new_fc_layer(input=layer_flat,
                 num_inputs=num_features,
                 num_outputs=fc_size,
                 use_relu=True)

layer_fc2 = new_fc_layer(input=layer_fc1,
                 num_inputs=fc_size,
                 num_outputs=num_classes,
                 use_relu=False)

y_pred = tf.nn.softmax(layer_fc2)
y_pred_cls = tf.argmax(y_pred, dimension=1)

# Restore the model

saver = tf.train.Saver()
session = tf.Session()
saver.restore(session, model_path)

我创建可视化权重的代码来自以下内容： Source code

有人能告诉我培训或网络是否太浅？

Answer 1

这是对培训早期阶段第一个卷积层产生的要素图（而不是权重）的完美描述。

第一层学习提取简单的特征，学习过程有点慢，因此你首先要学会模糊＆＃34;输入图像，但一旦网络开始收敛，您将看到第一层将开始提取有意义的低级特征（边缘等）。

只需监控培训流程，让网络培训更多。

相反，如果你的表现不好（总是看一下验证准确度），你的功能图总是看起来很吵，你应该开始调整超参数（降低学习率，规范，...）以便提取有意义的功能，从而获得良好的结果