def yolo_head(feats, anchors, num_classes):
# convert anchors to shape 1 , 1 , 1 , len of anchors , 2
num_anchors = len(anchors)
anchors_tensor = K.reshape(K.variable(anchors), [1, 1, 1, num_anchors, 2])
# conv_dims , width and hight of the grid
_, conv_height, conv_width, _ = K.int_shape(feats)
conv_dims = K.variable([conv_width, conv_height])
# reshape yolo network output to None , grid_width , grid_hight , num of amnchors , num of classes + 5
feats = K.reshape(
feats, [-1, conv_dims[0], conv_dims[1], num_anchors, num_classes + 5])
# convert conv_dims after casting it to feats datatype to 1 , 1 , 1 , 2
conv_dims = K.cast(K.reshape(conv_dims, [1, 1, 1, 1, 2]), K.dtype(feats))
# create grid from (0 , 0 ) to (width , hight)
conv_index = np.array([_ for _ in np.ndindex(conv_width, conv_height)])
conv_index = conv_index[:, [1, 0]] # swap columns for YOLO ordering.
conv_index = K.variable(
conv_index.reshape(1, conv_height, conv_width, 1, 2))
box_confidence = K.sigmoid(feats[..., 4:5])
box_xy = K.sigmoid(feats[..., :2])
box_wh = K.exp(feats[..., 2:4])
box_class_probs = K.softmax(feats[..., 5:])
box_xy = (box_xy + conv_index) / conv_dims
box_wh = box_wh * anchors_tensor / conv_dims
return box_confidence, box_xy, box_wh, box_class_probs
def get_activations(activation_function, batch_gen):
"""
Computes the activations of a data set at one layer of the model in a
"delayed" way (for memory and computation efficiency) and return them as a
dask array.
See: https://docs.dask.org/en/latest/delayed.html
"""
layer_shape = K.int_shape(activation_function.outputs[0])[1:]
layer_dim = np.prod(K.int_shape(activation_function.outputs[0])[1:])
n_images = batch_gen.n_images
n_aug = batch_gen.aug_per_im
batch_size = batch_gen.batch_size
# Delayed computation of the activations of a batch
@dask.delayed
def batch_activation():
batch_images, _ = next(batch_gen())
return activation_function([batch_images, 0])[0]
# Delayed iteration over the data set
activations_delayed = [batch_activation() for _
in range(batch_gen.n_batches)]
activations_da_list = [da.from_delayed(
activation_delayed,
shape=(batch_size * n_aug, ) + layer_shape,
dtype=K.floatx())
for activation_delayed in activations_delayed]
activations_da = da.concatenate(activations_da_list, axis=0)
# The last batch can be smaller
activations_da = activations_da[:n_images * n_aug]
# Reshape the activations such that
# shape = (n_diff_images, layer_dim, n_aug)
activations_da = da.reshape(activations_da,
(activations_da.shape[0], layer_dim))
activations_da = da.transpose(da.reshape(activations_da.T,
(layer_dim, n_images, n_aug)),
(1, 0, 2))
return activations_da
def highway(value, activation="tanh", transform_gate_bias=-1.0):
dim = K.int_shape(value)[-1]
transform_gate_bias_initializer = initializers.Constant(
transform_gate_bias)
transform_gate = Dense(
units=dim, bias_initializer=transform_gate_bias_initializer)(value)
transform_gate = Activation("sigmoid")(transform_gate)
carry_gate = Lambda(lambda x: 1.0 - x,
output_shape=(dim, ))(transform_gate)
transformed_data = Dense(units=dim)(value)
transformed_data = Activation(activation)(transformed_data)
transformed_gated = Multiply()([transform_gate, transformed_data])
identity_gated = Multiply()([carry_gate, value])
value = Add()([transformed_gated, identity_gated])
return value
def orthonorm_op(x, epsilon=1e-7):
'''
Computes a matrix that orthogonalizes the input matrix x
x: an n x d input matrix
eps: epsilon to prevent nonzero values in the diagonal entries of x
returns: a d x d matrix, ortho_weights, which orthogonalizes x by
right multiplication
'''
x_2 = K.dot(K.transpose(x), x)
x_2 += K.eye(K.int_shape(x)[1]) * epsilon
L = tf.cholesky(x_2)
ortho_weights = tf.transpose(tf.matrix_inverse(L)) * tf.sqrt(
tf.cast(tf.shape(x)[0], dtype=K.floatx()))
return ortho_weights
def call(self, inputs, **kwargs):
in_shape = K.int_shape(inputs)
combined_values = []
total_size = in_shape[1] * self.size
j = 0
for i in range(total_size):
if i == total_size - 1:
combined_values.append(2 * inputs[:, j - 1:j, :] -
combined_values[-1])
elif i % 2 == 0:
combined_values.append(inputs[:, j:j + 1, :])
j += 1
else:
combined_values.append(0.5 * inputs[:, j:j + 1, :] +
0.5 * inputs[:, j - 1:j, :])
output = K.concatenate(combined_values, axis=1)
return output
def activations_norm(images, labels, batch_size, model, layer_regex,
daug_params, norms=['fro']):
"""
Computes the norm of the activation of all feature maps
Parameters
----------
images : h5py Dataset
The set of images
labels : h5py Dataset
The ground truth labels
batch_size : int
Batch size
model : Keras Model
The model
daug_params : dict
Dictionary of data augmentation parameters
Returns
-------
results_dict : dict
Dictionary containing some performance metrics
"""
def _update_stats(mean_norm, std_norm, norm):
mean_norm_batch = np.mean(norm, axis=0)
std_norm_batch = np.std(norm, axis=0)
mean_norm = init / float(end) * mean_norm + \
batch_size / float(end) * mean_norm_batch
std_norm = init / float(end) * std_norm ** 2 + \
batch_size / float(end) * std_norm_batch ** 2 + \
(init * batch_size) / float(end ** 2) * \
(mean_norm - mean_norm_batch) ** 2
std_norm = np.sqrt(std_norm)
return mean_norm, std_norm
def _frobenius_norm(activations):
norm = np.linalg.norm(
activations, ord='fro',
axis=tuple(range(1, len(activations.shape) - 1)))
return norm
def _inf_norm(activations):
norm = np.max(np.abs(activations),
axis=tuple(range(1, len(activations.shape) - 1)))
return norm
n_images = images.shape[0]
n_batches_per_epoch = int(np.ceil(float(n_images) / batch_size))
# Create batch generator
image_gen = get_generator(images, **daug_params)
batch_gen = batch_generator(image_gen, images, labels, batch_size,
aug_per_im=1, shuffle=False)
# Initialize list to store the mean norm of the activations
results_dict = {'activations_norm': {}, 'summary': {}}
# Iterate over the layers
model = del_extra_nodes(model)
for layer in model.layers:
if re.match(layer_regex, layer.name):
layer_name = layer.name.encode('utf-8')
print('\nLayer {}'.format(layer_name))
output = model.get_layer(layer_name)\
.outbound_nodes[0].input_tensors[0]
get_output = K.function([model.input, K.learning_phase()],
[output])
n_channels = K.int_shape(output)[-1]
results_dict['activations_norm'].update({layer_name:
{n: {'mean': np.zeros(n_channels),
'std': np.zeros(n_channels)} for n in norms}})
layer_dict = results_dict['activations_norm'][layer_name]
init = 0
batch_gen.image_gen.reset()
for _ in tqdm(range(n_batches_per_epoch)):
batch_images, _ = next(batch_gen())
batch_size = batch_images.shape[0]
end = init + batch_size
activations = get_output([batch_images, 0])[0]
for norm_key in norms:
mean_norm = layer_dict[norm_key]['mean']
std_norm = layer_dict[norm_key]['std']
if norm_key == 'fro':
norm = _frobenius_norm(activations)
elif norm_key == 'inf':
norm = _inf_norm(activations)
else:
raise NotImplementedError('Implemented norms are fro '
'and inf')
mean_norm, std_norm = _update_stats(mean_norm, std_norm,
norm)
layer_dict[norm_key]['mean'] = mean_norm
layer_dict[norm_key]['std'] = std_norm
init = end
# Compute summary statistics across the channels
for layer, layer_dict in results_dict['activations_norm'].items():
results_dict['summary'].update({layer: {}})
for norm_key, norm_dict in layer_dict.items():
results_dict['summary'][layer].update({norm_key: {
'mean': np.mean(norm_dict['mean']),
'std': np.mean(norm_dict['std'])}})
return results_dict
def sample_z(args): z_mu, z_sigma = args eps = K.random_normal(shape=(K.shape(z_mu)[0], K.int_shape(z_mu)[1])) return z_mu + K.exp(z_sigma / 2) * eps
# BUILD THE MODEL # # ================= ############# # # Encoder #Let us define 4 conv2D, flatten and then dense # # ================= ############ latent_dim = 2 # Number of latent dim parameters input_img = Input(shape=input_shape, name='encoder_input') x = Conv2D(32, 3, padding='same', activation='relu')(input_img) x = Conv2D(64, 3, padding='same', activation='relu',strides=(2, 2))(x) x = Conv2D(64, 3, padding='same', activation='relu')(x) x = Conv2D(64, 3, padding='same', activation='relu')(x) conv_shape = K.int_shape(x) #Shape of conv to be provided to decoder #Flatten x = Flatten()(x) x = Dense(32, activation='relu')(x) # Two outputs, for latent mean and log variance (std. dev.) #Use these to sample random variables in latent space to which inputs are mapped. z_mu = Dense(latent_dim, name='latent_mu')(x) #Mean values of encoded input z_sigma = Dense(latent_dim, name='latent_sigma')(x) #Std dev. (variance) of encoded input #REPARAMETERIZATION TRICK # Define sampling function to sample from the distribution # Reparameterize sample based on the process defined by Gunderson and Huang # into the shape of: mu + sigma squared x eps #This is to allow gradient descent to allow for gradient estimation accurately. def sample_z(args):