def resize(img):
return resize_images(img, 66, 200, 'channels_first')
def call(self, inputs, **kwargs):
return K.resize_images(inputs,
self.height,
self.width,
data_format="channels_last",
interpolation=self.interpolation)
def build_explanation_model(self,
input_dim,
output_dim,
loss,
downsample_factors=(1, )):
num_indices, num_channels, steps, downsampling_factor =\
MaskingUtil.get_input_constants(input_dim, downsample_factors)
if downsampling_factor != 1 and num_indices is None:
raise ValueError(
"Attribution downsampling is not supported for variable length inputs. "
"Please pad your data samples to the same size to use downsampling."
)
input_shape = (input_dim, ) if not isinstance(
input_dim, collections.Sequence) else input_dim
input_layer = Input(shape=input_shape)
last_layer = self.build(input_layer)
if num_indices is None:
last_layer = Dense(1, activation="linear")(last_layer)
last_layer = Flatten()(last_layer) # None * None outputs
last_layer = Lambda(
K.softmax, output_shape=K.int_shape(last_layer))(last_layer)
else:
last_layer = Flatten()(last_layer)
last_layer = Dense(num_indices, activation="softmax")(last_layer)
# Prepare extra inputs for causal loss.
all_auxiliary_outputs = Input(shape=(output_dim, ), name="all")
all_but_one_auxiliary_outputs_input = Input(shape=(num_indices,
output_dim),
name="all_but_one")
if num_indices is not None:
all_but_one_auxiliary_outputs = Lambda(lambda x: tf.unstack(
x, axis=1))(all_but_one_auxiliary_outputs_input)
if K.int_shape(all_but_one_auxiliary_outputs_input)[1] == 1:
all_but_one_auxiliary_outputs = [all_but_one_auxiliary_outputs]
else:
all_but_one_auxiliary_outputs = all_but_one_auxiliary_outputs_input
all_but_one_auxiliary_outputs = Concatenate()(
all_but_one_auxiliary_outputs)
causal_loss_fun = CausalLoss(num_indices=num_indices,
loss_function=loss)
if downsampling_factor != 1:
last_layer = Reshape(tuple(steps) + (1, ))(last_layer)
if len(steps) == 1:
# Add a dummy dimension to enable usage of __resize_images__.
last_layer = Reshape(tuple(steps) + (1, 1))(last_layer)
last_layer = Lambda(lambda x: resize_images(
x,
height_factor=downsample_factors[0],
width_factor=1,
data_format="channels_last"))(last_layer)
elif len(steps) == 2:
last_layer = Lambda(lambda x: resize_images(
x,
height_factor=downsample_factors[0],
width_factor=downsample_factors[1],
data_format="channels_last"))(last_layer)
elif len(steps) == 3:
last_layer = Lambda(lambda x: resize_volumes(
x,
depth_factor=downsample_factors[0],
height_factor=downsample_factors[1],
width_factor=downsample_factors[2],
data_format="channels_last"))(last_layer)
else:
raise ValueError(
"Attribution maps of larger dimensionality than 3D data are not currently supported. "
"Requested output dim was: {}.".format(len(steps)))
attribution_shape = Validation.get_attribution_shape_from_input_shape(
num_samples=1, input_dim=input_dim)[1:]
collapsed_attribution_shape = (int(np.prod(attribution_shape)), )
last_layer = Reshape(collapsed_attribution_shape)(last_layer)
# Re-normalise to sum = 1 after resizing (sum = __downsampling_factor__ after resizing).
last_layer = Lambda(lambda x: x / float(downsampling_factor))(
last_layer)
final_layer = Concatenate()(
[last_layer, all_but_one_auxiliary_outputs, all_auxiliary_outputs])
model = Model(inputs=[
input_layer, all_auxiliary_outputs,
all_but_one_auxiliary_outputs_input
],
outputs=final_layer)
model = self.compile_model(model,
main_losses=causal_loss_fun,
learning_rate=self.learning_rate,
optimizer=self.optimizer)
prediction_model = Model(input_layer, last_layer)
return model, prediction_model
def call(self, input_tensor, training=None):
input_transposed = tf.transpose(input_tensor, [3, 0, 1, 2, 4])
input_shape = K.shape(input_transposed)
input_tensor_reshaped = K.reshape(input_transposed, [
input_shape[1] * input_shape[0], self.input_height,
self.input_width, self.input_num_atoms
])
input_tensor_reshaped.set_shape(
(None, self.input_height, self.input_width, self.input_num_atoms))
if self.upsamp_type == 'resize':
upsamp = K.resize_images(input_tensor_reshaped, self.scaling,
self.scaling, 'channels_last')
outputs = K.conv2d(upsamp,
kernel=self.W,
strides=(1, 1),
padding=self.padding,
data_format='channels_last')
elif self.upsamp_type == 'subpix':
conv = K.conv2d(input_tensor_reshaped,
kernel=self.W,
strides=(1, 1),
padding='same',
data_format='channels_last')
outputs = tf.depth_to_space(conv, self.scaling)
else:
batch_size = input_shape[1] * input_shape[0]
# Infer the dynamic output shape:
out_height = deconv_output_length(input_length=self.input_height,
stride=self.scaling,
filter_size=self.kernel_size,
padding=self.padding)
out_width = deconv_output_length(input_length=self.input_width,
stride=self.scaling,
filter_size=self.kernel_size,
padding=self.padding)
output_shape = (batch_size, out_height, out_width,
self.num_capsule * self.num_atoms)
outputs = K.conv2d_transpose(input_tensor_reshaped,
self.W,
output_shape,
(self.scaling, self.scaling),
padding=self.padding,
data_format='channels_last')
votes_shape = K.shape(outputs)
_, conv_height, conv_width, _ = outputs.get_shape()
votes = K.reshape(outputs, [
input_shape[1], input_shape[0], votes_shape[1], votes_shape[2],
self.num_capsule, self.num_atoms
])
votes.set_shape((None, self.input_num_capsule, conv_height.value,
conv_width.value, self.num_capsule, self.num_atoms))
logit_shape = K.stack([
input_shape[1], input_shape[0], votes_shape[1], votes_shape[2],
self.num_capsule
])
biases_replicated = K.tile(self.b,
[votes_shape[1], votes_shape[2], 1, 1])
activations = update_routing(votes=votes,
biases=biases_replicated,
logit_shape=logit_shape,
num_dims=6,
input_dim=self.input_num_capsule,
output_dim=self.num_capsule,
num_routing=self.routings)
return activations
for i in range(1,5):
cloned_weights[index+i] = cloned_weights[index+i][active_weights_index]
if r != (len(conv_weights_index) - 1):
cloned_weights[index+5] = cloned_weights[index+5][:,:,active_weights_index,:]
else:
active_index = []
for j in active_weights_index:
active_index += list(range((j*6*6),((j+1)*6*6)))
cloned_weights[index+5] = cloned_weights[index+5][active_index,:]
input_shape = (32,32,3)
num_classes = 10
sparse_model = keras.models.Sequential([
layers.Lambda(lambda img: K.resize_images(img, 7, 7, data_format='channels_last'), input_shape=input_shape),
layers.ZeroPadding2D(padding=(2, 2)),
layers.Conv2D(filters=cloned_weights[conv_weights_index[0]].shape[3], kernel_size=(11,11), strides=(4,4), activation='relu', use_bias=False),
layers.BatchNormalization(),
layers.MaxPool2D(pool_size=(3,3), strides=(2,2)),
layers.Conv2D(filters=cloned_weights[conv_weights_index[1]].shape[3], kernel_size=(5,5), strides=(1,1), activation='relu', padding="same", use_bias=False),
layers.BatchNormalization(),
layers.MaxPool2D(pool_size=(3,3), strides=(2,2)),
layers.Conv2D(filters=cloned_weights[conv_weights_index[2]].shape[3], kernel_size=(3,3), strides=(1,1), activation='relu', padding="same", use_bias=False),
layers.BatchNormalization(),
layers.Conv2D(filters=cloned_weights[conv_weights_index[3]].shape[3], kernel_size=(3,3), strides=(1,1), activation='relu', padding="same", use_bias=False),
layers.BatchNormalization(),
layers.Conv2D(filters=cloned_weights[conv_weights_index[4]].shape[3], kernel_size=(3,3), strides=(1,1), activation='relu', padding="same", use_bias=False),
layers.BatchNormalization(),
layers.MaxPool2D(pool_size=(3,3), strides=(2,2)),
layers.Flatten(),