我在Keras（我是新手）创建了一个模型，并以某种方式设法很好地训练它。它需要300x300个图像，并尝试将它们分为两组。
$('.checkbox-inline label').text();现在我想想象第二个卷积层，如果可能的话，还想看第一个密集层。 “灵感”取自keras blog。通过使用# size of image in pixel
img_rows, img_cols = 300, 300
# number of classes (here digits 1 to 10)
nb_classes = 2
# number of convolutional filters to use
nb_filters = 16
# size of pooling area for max pooling
nb_pool = 20
# convolution kernel size
nb_conv = 20
X = np.vstack([X_train, X_test]).reshape(-1, 1, img_rows, img_cols)
y = np_utils.to_categorical(np.concatenate([y_train, y_test]), nb_classes)
# build model
model = Sequential()
model.add(Convolution2D(nb_filters, nb_conv, nb_conv, border_mode='valid', input_shape=(1, img_rows, img_cols)))
model.add(Activation('relu'))
model.add(Convolution2D(nb_filters, nb_conv, nb_conv))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes))
model.add(Activation('softmax'))
# run model
model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy'])
，我找到了图层的名称。然后我创建了以下frankenstein代码：
model.summary()执行后我得到：
from __future__ import print_function
from scipy.misc import imsave
import numpy as np
import time
#from keras.applications import vgg16
import keras
from keras import backend as K
# dimensions of the generated pictures for each filter.
img_width = 300
img_height = 300
# the name of the layer we want to visualize
# (see model definition at keras/applications/vgg16.py)
layer_name = 'convolution2d_2'
#layer_name = 'dense_1'
# util function to convert a tensor into a valid image
def deprocess_image(x):
# normalize tensor: center on 0., ensure std is 0.1
x -= x.mean()
x /= (x.std() + 1e-5)
x *= 0.1
# clip to [0, 1]
x += 0.5
x = np.clip(x, 0, 1)
# convert to RGB array
x *= 255
if K.image_dim_ordering() == 'th':
x = x.transpose((1, 2, 0))
x = np.clip(x, 0, 255).astype('uint8')
return x
# load model
loc_json = 'my_model_short_architecture.json'
loc_h5 = 'my_model_short_weights.h5'
with open(loc_json, 'r') as json_file:
loaded_model_json = json_file.read()
model = keras.models.model_from_json(loaded_model_json)
# load weights into new model
model.load_weights(loc_h5)
print('Model loaded.')
model.summary()
# this is the placeholder for the input images
input_img = model.input
# get the symbolic outputs of each "key" layer (we gave them unique names).
layer_dict = dict([(layer.name, layer) for layer in model.layers[1:]])
def normalize(x):
# utility function to normalize a tensor by its L2 norm
return x / (K.sqrt(K.mean(K.square(x))) + 1e-5)
kept_filters = []
for filter_index in range(0, 200):
# we only scan through the first 200 filters,
# but there are actually 512 of them
print('Processing filter %d' % filter_index)
start_time = time.time()
# we build a loss function that maximizes the activation
# of the nth filter of the layer considered
layer_output = layer_dict[layer_name].output
if K.image_dim_ordering() == 'th':
loss = K.mean(layer_output[:, filter_index, :, :])
else:
loss = K.mean(layer_output[:, :, :, filter_index])
# we compute the gradient of the input picture wrt this loss
grads = K.gradients(loss, input_img)[0]
# normalization trick: we normalize the gradient
grads = normalize(grads)
# this function returns the loss and grads given the input picture
iterate = K.function([input_img], [loss, grads])
# step size for gradient ascent
step = 1.
# we start from a gray image with some random noise
if K.image_dim_ordering() == 'th':
input_img_data = np.random.random((1, 3, img_width, img_height))
else:
input_img_data = np.random.random((1, img_width, img_height, 3))
input_img_data = (input_img_data - 0.5) * 20 + 128
# we run gradient ascent for 20 steps
for i in range(20):
loss_value, grads_value = iterate([input_img_data])
input_img_data += grads_value * step
print('Current loss value:', loss_value)
if loss_value <= 0.:
# some filters get stuck to 0, we can skip them
break
# decode the resulting input image
if loss_value > 0:
img = deprocess_image(input_img_data[0])
kept_filters.append((img, loss_value))
end_time = time.time()
print('Filter %d processed in %ds' % (filter_index, end_time - start_time))
# we will stich the best 64 filters on a 8 x 8 grid.
n = 8
# the filters that have the highest loss are assumed to be better-looking.
# we will only keep the top 64 filters.
kept_filters.sort(key=lambda x: x[1], reverse=True)
kept_filters = kept_filters[:n * n]
# build a black picture with enough space for
# our 8 x 8 filters of size 128 x 128, with a 5px margin in between
margin = 5
width = n * img_width + (n - 1) * margin
height = n * img_height + (n - 1) * margin
stitched_filters = np.zeros((width, height, 3))
# fill the picture with our saved filters
for i in range(n):
for j in range(n):
img, loss = kept_filters[i * n + j]
stitched_filters[(img_width + margin) * i: (img_width + margin) * i + img_width,
(img_height + margin) * j: (img_height + margin) * j + img_height, :] = img
# save the result to disk
imsave('stitched_filters_%dx%d.png' % (n, n), stitched_filters)
我想我有一些不好的尺寸，但甚至不知道从哪里开始。任何帮助，将不胜感激。感谢。
答案 0 :(得分：4)
Keras让人很容易获得图层＆＃39;权重和产出。请查看https://keras.io/layers/about-keras-layers/或https://keras.io/getting-started/functional-api-guide/#the-concept-of-layer-node。
您基本上可以使用每个图层的weights和output属性来获取它。
答案 1 :(得分：2)
在您的网络中，第一个卷积层中只有16个过滤器，接下来是16个过滤器，因此您有32个卷积过滤器。但是你正在运行for循环200.尝试将其更改为16或32.我正在使用TF后端运行此代码，它适用于我的小型CNN。 另外，更改图像拼接代码：
for i in range(n):
for j in range(n):
if(i * n + j)<=len(kept_filters)-1:
最好的运气......
答案 2 :(得分：2)
答案 3 :(得分：1)
只是一个简单的功能，如
def plot_conv_weights(model, layer_name):
W = model.get_layer(name=layer_name).get_weights()[0]
if len(W.shape) == 4:
W = np.squeeze(W)
W = W.reshape((W.shape[0], W.shape[1], W.shape[2]*W.shape[3]))
fig, axs = plt.subplots(5,5, figsize=(8,8))
fig.subplots_adjust(hspace = .5, wspace=.001)
axs = axs.ravel()
for i in range(25):
axs[i].imshow(W[:,:,i])
axs[i].set_title(str(i))
可以解决您的问题（只有卷积层）