def call(self, inputs):
input_shape = self.in_shape
if self.data_format == 'channels_first':
x = K.arange(0, input_shape[1], dtype=K.floatx())
y = K.arange(0, input_shape[2], dtype=K.floatx())
else:
x = K.arange(0, input_shape[0], dtype=K.floatx())
y = K.arange(0, input_shape[1], dtype=K.floatx())
x = x / K.max(x)
y = y / K.max(y)
loc_x, loc_y = tf.meshgrid(x, y, indexing='ij')
if self.data_format == 'channels_first':
loc = K.stack([loc_x, loc_y], axis=0)
else:
loc = K.stack([loc_x, loc_y], axis=-1)
location = K.expand_dims(loc, axis=0)
if self.data_format == 'channels_first':
location = K.permute_dimensions(location, pattern=[0, 2, 3, 1])
location = tf.tile(location, [K.shape(inputs)[0], 1, 1, 1])
if self.data_format == 'channels_first':
location = K.permute_dimensions(location, pattern=[0, 3, 1, 2])
return location
def call(self, input):
input_shape = backend.shape(input)
num_rows = input_shape[1]
num_cols = input_shape[2]
row_length = backend.cast(num_rows,
'float32') / (2 * self.circle_number)
col_length = backend.cast(num_cols,
'float32') / (2 * self.circle_number)
outputs = []
pool_circle = []
for jy in range(self.circle_number * 2):
for ix in range(self.circle_number * 2):
x1 = ix * col_length
x2 = ix * col_length + col_length
y1 = jy * row_length
y2 = jy * row_length + row_length
x1 = backend.cast(backend.round(x1), 'int32')
x2 = backend.cast(backend.round(x2), 'int32')
y1 = backend.cast(backend.round(y1), 'int32')
y2 = backend.cast(backend.round(y2), 'int32')
new_shape = [input_shape[0], y2 - y1, x2 - x1, input_shape[3]]
x_crop = input[:, y1:y2, x1:x2, :]
xm = backend.reshape(x_crop, new_shape)
if self.pool_mode == 'avg':
pooled_val = backend.mean(xm, axis=(1, 2))
else:
pooled_val = backend.max(xm, axis=(1, 2))
pool_circle.append(
backend.reshape(xm, (input_shape[0], -1, input_shape[3])))
circle_index = self._circle_index(self.circle_number)
for cidx in circle_index:
circle_val = [pool_circle[idx] for idx in cidx]
if self.pool_mode == 'avg':
pooled_val = backend.mean(backend.concatenate(circle_val,
axis=1),
axis=1)
else:
pooled_val = backend.max(backend.concatenate(circle_val,
axis=1),
axis=1)
outputs.append(pooled_val)
outputs = backend.concatenate(outputs)
outputs = backend.reshape(
outputs,
(input_shape[0], self.nb_channels * self.num_outputs_per_channel))
return outputs
def filter_boxes(box_confidence, boxes, box_class_probs, threshold=.6):
""" Filter YOLO boxes based on object and class confidence.
Parameters
----------
box_confidence: tf.Tensor
Probability estimate for whether each box contains any object.
boxes: tf.Tensor
Bounding boxes
box_class_probs: tf.Tensor
Probability distribution estimate for each box over class labels.
threshold: float
Threshold value
Returns
-------
_boxes, scores, classes: (tf.Tensor, tf.Tensor, tf.Tensor)
"""
box_scores = box_confidence * box_class_probs
box_classes = K.argmax(box_scores, axis=-1)
box_class_scores = K.max(box_scores, axis=-1)
prediction_mask = box_class_scores >= threshold
_boxes = tf.boolean_mask(boxes, prediction_mask)
scores = tf.boolean_mask(box_class_scores, prediction_mask)
classes = tf.boolean_mask(box_classes, prediction_mask)
return _boxes, scores, classes
def call(self, input_feature):
kernel_size = 3
# if K.image_data_format() == "channels_first":
# channel = input_feature._keras_shape[1]
# cbam_feature = Permute((2, 3, 1))(input_feature)
# else:
# channel = input_feature._keras_shape[-1]
cbam_feature = input_feature
print(input_feature.shape)
avg_pool = Lambda(lambda x: K.mean(x, axis=3, keepdims=True))(cbam_feature)
# # assert avg_pool._keras_shape[-1] == 1
#print(avg_pool.shape)
max_pool = Lambda(lambda x: K.max(x, axis=3, keepdims=True))(cbam_feature)
#print(max_pool.shape)
# assert max_pool._keras_shape[-1] == 1
concat = Concatenate(axis=3)([avg_pool, max_pool])
#print(concat.shape)
# assert concat._keras_shape[-1] == 2
cbam_feature = Conv2D(filters=1,
kernel_size=kernel_size,
strides=1,
padding='same',
kernel_initializer='he_normal',
use_bias=False)(concat)
# assert cbam_feature._keras_shape[-1] == 1
# if K.image_data_format() == "channels_first":
# cbam_feature = Permute((3, 1, 2))(cbam_feature)
print(cbam_feature.shape)
res = K.sigmoid(cbam_feature)
#print(res.shape)
return res
def compile_saliency_function(model, act_num):
input_sig = model.get_input_at(0)
layer_dict = dict([(layer.name, layer) for layer in model.layers[1:]])
layer_output = layer_dict[act_num].output
max_output = K.max(layer_output, axis=2)
saliency = K.gradients(K.sum(max_output), input_sig)[0]
return K.function([input_sig, K.learning_phase()], [saliency])
def call(self, inputs, **kwargs):
backend = retina_net_tensorflow_backend()
boxes, classification, detections = inputs
# TODO: support batch size > 1.
boxes = boxes[0]
classification = classification[0]
detections = detections[0]
scores = K.max(classification, axis=1)
# selecting best anchors theoretically improves speed at the cost of minor performance
if self.top_k:
scores, indices = backend.top_k(scores, self.top_k, sorted=False)
boxes = K.gather(boxes, indices)
classification = K.gather(classification, indices)
detections = K.gather(detections, indices)
indices = backend.non_max_suppression(boxes,
scores,
max_output_size=self.max_boxes,
iou_threshold=self.nms_threshold)
detections = K.gather(detections, indices)
return K.expand_dims(detections, axis=0)
def call(self, inputs, mask=None, training=None):
inputs, relatives, memories, bias_context, bias_relative = inputs
full = K.concatenate([memories, inputs], axis=1) # (batch, prev_len + seq_len, units)
w_q = K.dot(inputs, self.kernel_q) # (batch, seq_len, units)
w_kv = K.dot(full, self.kernel_kv) # (batch, prev_len + seq_len, units * 2)
w_r = K.dot(relatives, self.kernel_r) # (batch, prev_len + seq_len, units)
if self.use_bias:
w_q = K.bias_add(w_q, self.bias_q)
w_kv = K.bias_add(w_kv, self.bias_kv)
w_r = K.bias_add(w_r, self.bias_r)
if self.activation is not None:
w_q = self.activation(w_q)
w_kv = self.activation(w_kv)
w_r = self.activation(w_r)
w_k = w_kv[:, :, :self.units] # (batch, prev_len + seq_len, units)
w_v = w_kv[:, :, self.units:] # (batch, prev_len + seq_len, units)
w_qc = K.bias_add(w_q, bias_context)
w_qc = self._reshape_to_batches(w_qc) # (batch * n_head, seq_len, units_head)
w_k = self._reshape_to_batches(w_k) # (batch * n_head, prev_len + seq_len, units_head)
a_context = K.batch_dot(w_qc, w_k, axes=2) # (batch * n_head, seq_len, prev_len + seq_len)
w_qr = K.bias_add(w_q, bias_relative)
w_qr = self._reshape_to_batches(w_qr) # (batch * n_head, seq_len, units_head)
w_r = self._reshape_to_batches(w_r) # (batch * n_head, prev_len + seq_len, units_head)
a_relative = K.batch_dot(w_qr, w_r, axes=2) # (batch * n_head, seq_len, prev_len + seq_len)
a_relative = self._relative_shift(a_relative) # (batch * n_head, seq_len, prev_len + seq_len)
att = (a_context + a_relative) / K.sqrt(K.constant(self.units_head, dtype=K.floatx()))
exp = K.exp(att - K.max(att, axis=-1, keepdims=True))
q_len, k_len = K.shape(w_q)[1], K.shape(w_k)[1]
indices = K.expand_dims(K.arange(0, k_len), axis=0)
upper = K.expand_dims(K.arange(k_len - q_len, k_len), axis=-1)
exp *= K.expand_dims(K.cast(indices <= upper, K.floatx()), axis=0)
if mask is not None and mask[0] is not None:
mask = K.cast(mask[0], K.floatx())
mask = K.concatenate([K.ones_like(memories[:, :, 0]), mask], axis=1)
exp *= K.expand_dims(self._reshape_mask(mask), axis=1)
att = exp / K.sum(exp, axis=-1, keepdims=True)
if self.att_drop_layer is not None:
att = self.att_drop_layer(att, training=training)
w_v = self._reshape_to_batches(w_v) # (batch * n_head, prev_len + seq_len, units_head)
w_o = K.batch_dot(att, w_v) # (batch * n_head, seq_len, units_head)
w_o = self._reshape_from_batches(w_o) # (batch, seq_len, units)
w_o = K.dot(w_o, self.kernel_o) # (batch, seq_len, units)
if self.use_bias:
w_o = K.bias_add(w_o, self.bias_o)
if self.activation is not None:
w_o = self.activation(w_o)
# Add shape information to tensor when using `tf.keras`
input_shape = K.int_shape(inputs)
if input_shape[1] is not None:
w_o = K.reshape(w_o, (-1,) + input_shape[1:])
return w_o
def build_loss(self):
# Infinity norm
if np.isinf(self.p):
value = K.max(self.img)
else:
value = K.pow(K.sum(K.pow(K.abs(self.img), self.p)), 1. / self.p)
return normalize(self.img, value)
def layer(x):
x_mean = K.expand_dims(K.mean(x, axis=1), axis=1)
x_max = K.expand_dims(K.max(x, axis=1), axis=1)
x = concatenate([x, x_mean, x_max], axis=1)
x = building_block(filters)(x)
x = Conv3D(classes, 1, data_format=DATA_FORMAT)(x)
return x
def loop_body(b, ignore_mask):
true_box = tf.boolean_mask(y_true[l][b, ..., 0:4],
object_mask_bool[b, ..., 0])
iou = box_iou(pred_box[b], true_box)
best_iou = K.max(iou, axis=-1)
ignore_mask = ignore_mask.write(
b, K.cast(best_iou < ignore_thresh, K.dtype(true_box)))
return b + 1, ignore_mask
def compile_saliency_function(net, activation_layer):
input_img = net.input
layer_dict = dict([(layer.name, layer) for layer in net.layers[1:]])
layer_output = layer_dict[activation_layer].output
max_output = K.max(layer_output, axis=3)
saliency = K.gradients(K.sum(max_output), input_img)[0]
return K.function([input_img, K.learning_phase()], [saliency])
def _softmax(x):
"""
Softmax that works on ND inputs.
"""
channel_axis = get_channel_axis(K.ndim(x) - 2)
e = K.exp(x - K.max(x, axis=channel_axis, keepdims=True))
s = K.sum(e, axis=channel_axis, keepdims=True)
return e / s
def mystockloss(y_true, y_pred, e=0.1):
# return (1-e) * abs(y_true - y_pred) * K.max([K.max([y_true, y_pred]) - 0.0, 0.0])
# return (1-e) * abs(y_true - y_pred) * K.pow(1.2, K.max([y_true, y_pred])) / 100.0
# max_y = K.max([y_true, y_pred]) / 10.0 # predict_day_count
# return (1-e) * abs(y_true - y_pred) * tf.where(tf.greater(max_y, 5.0), max_y / 5.0, K.pow(1.584893, max_y) / 10.0)
# max_y = K.max([y_true, y_pred]) / 10.0 # predict_day_count
# return (1-e) * abs(y_true - y_pred) * K.pow(2.0, max_y) / 10.0
return abs(y_true - y_pred) / 10.0 * K.max([y_true, y_pred, y_true * 0.0])
def _view_pool(views):
"""
this is the ViewPooling in the paper
:param views: the NUM_VIEWS outputs of CNN1
"""
expanded = [K.expand_dims(view, 0) for view in views]
concated = K.concatenate(expanded, 0)
reduced = K.max(concated, 0)
return reduced
def softmax_with_mask(tensor_and_mask):
input_tensor, mask_tensor = tensor_and_mask
min_tensor = K.min(input_tensor, axis=1, keepdims=True)
positive_tensor = (min_tensor - input_tensor) * mask_tensor
max_tensor = K.max(positive_tensor, axis=1, keepdims=True)
exp_tensor = K.exp(positive_tensor - max_tensor)
masked_tensor = exp_tensor * mask_tensor
summed_tensor = K.sum(masked_tensor, axis=1, keepdims=True)
return masked_tensor / (summed_tensor + 1e-10)
def compute_mask_loss(boxes,
masks,
annotations,
masks_target,
width,
height,
iou_threshold=0.5,
mask_size=(28, 28)):
"""compute overlap of boxes with annotations"""
iou = overlap(boxes, annotations)
argmax_overlaps_inds = K.argmax(iou, axis=1)
max_iou = K.max(iou, axis=1)
# filter those with IoU > 0.5
indices = tf.where(K.greater_equal(max_iou, iou_threshold))
boxes = tf.gather_nd(boxes, indices)
masks = tf.gather_nd(masks, indices)
argmax_overlaps_inds = K.cast(tf.gather_nd(argmax_overlaps_inds, indices), 'int32')
labels = K.cast(K.gather(annotations[:, 4], argmax_overlaps_inds), 'int32')
# make normalized boxes
x1 = boxes[:, 0]
y1 = boxes[:, 1]
x2 = boxes[:, 2]
y2 = boxes[:, 3]
boxes = K.stack([
y1 / (K.cast(height, dtype=K.floatx()) - 1),
x1 / (K.cast(width, dtype=K.floatx()) - 1),
(y2 - 1) / (K.cast(height, dtype=K.floatx()) - 1),
(x2 - 1) / (K.cast(width, dtype=K.floatx()) - 1),
], axis=1)
# crop and resize masks_target
# append a fake channel dimension
masks_target = K.expand_dims(masks_target, axis=3)
masks_target = tf.image.crop_and_resize(
masks_target,
boxes,
argmax_overlaps_inds,
mask_size
)
masks_target = masks_target[:, :, :, 0] # remove fake channel dimension
# gather the predicted masks using the annotation label
masks = tf.transpose(masks, (0, 3, 1, 2))
label_indices = K.stack([tf.range(K.shape(labels)[0]), labels], axis=1)
masks = tf.gather_nd(masks, label_indices)
# compute mask loss
mask_loss = K.binary_crossentropy(masks_target, masks)
normalizer = K.shape(masks)[0] * K.shape(masks)[1] * K.shape(masks)[2]
normalizer = K.maximum(K.cast(normalizer, K.floatx()), 1)
mask_loss = K.sum(mask_loss) / normalizer
return mask_loss
def softmax(x, axis=1):
ndim = K.ndim(x)
if ndim == 2:
return K.softmax(x)
elif ndim > 2:
e = K.exp(x - K.max(x, axis=axis, keepdims=True))
s = K.sum(e, axis=axis, keepdims=True)
return e / s
else:
raise ValueError('Cannot apply softmax to a tensor that is 1D')
def fallback_metric(self, y_true, y_pred):
#grab the most confident prediction
predictions = K.max(y_pred, axis=-1)
#fill a tensor with our threshold_value
threshold_tensor = tf.fill(tf.shape(predictions), self.threshold)
#Are we confident in our prediction?
threshold_high = predictions > threshold_tensor
threshold_high = tf.cast(threshold_high, tf.int32)
#Do we have low confidence in our prediction?
threshold_low = predictions <= threshold_tensor
threshold_low = tf.cast(threshold_low, tf.int32)
idx_true = K.argmax(y_true, -1)
idx_pred = K.argmax(y_pred, -1)
#For our confident predictions, compare the top prediction to the label of the true value
high_correct = math_ops.equal(idx_true, idx_pred)
high_correct = tf.cast(high_correct, tf.int32)
#For our less confident predictions, grab the top 2 most confident predictions
_, max_pred = tf.math.top_k(y_pred, k=2)
#Gather the lineages of those top 2 predictions using the transpose of the hierarchy's adjaency matrix because the adjacency only points from ancestor to descendant
lineages = tf.gather(K.transpose(self.hierarchy.A), max_pred)
lineages = K.cast(lineages, tf.int32)
#Grab the first two columns of this matrix
fallback = tf.bitwise.bitwise_and(lineages[:, 0], lineages[:, 1])
#Gather the lineage of the true value
actual = tf.gather(K.transpose(self.hierarchy.A), K.argmax(y_true))
actual = K.cast(actual, tf.int32)
#Multiply the two together
overlap_score = K.batch_dot(fallback, actual)
#Are either of the top 2 predictions in the lineage of the true value? If so, overlap_score should be >1 and we count the result as correct
low_correct = overlap_score > 1
low_correct = tf.cast(low_correct, tf.int32)
low_correct = tf.squeeze(low_correct)
#results for the high confidence predictions
high_accuracy = tf.math.multiply(threshold_high, high_correct)
#results for the low confidence predictions
low_accuracy = tf.math.multiply(threshold_low, low_correct)
# total accuracy vector
correct = high_accuracy + low_accuracy
#return batch accuracy value
return K.mean(K.cast(correct, tf.float32))
def call(self, x, mask=None):
""" The actual processing in the layer: Normalize, padd, then convolution.
"""
input_1, input_2 = x
input_shape = input_1.shape
# assert input_shape == input_2._keras_shape
self.H = input_shape[1]
self.W = input_shape[2]
self.C = input_shape[3]
# normalization
if self.use_norm is 'euclidean':
input_1 = K.l2_normalize(input_1, axis=2)
input_2 = K.l2_normalize(input_2, axis=2)
if self.use_norm is 'scaling':
input_1_min = K.min(input_1, axis=2, keepdims=True)
input_1_max = K.max(input_1, axis=2, keepdims=True)
input_1 = (input_1 - input_1_min) / (input_1_max - input_1_min + 0.000001)
input_2_min = K.min(input_2, axis=2, keepdims=True)
input_2_max = K.max(input_2, axis=2, keepdims=True)
input_2 = (input_2 - input_2_min) / (input_2_max - input_2_min + 0.000001)
if self.use_norm is 'standardization':
input_1 = (input_1 - K.mean(input_1, axis=2, keepdims=True)) + 0.00001
input_1 = K.l2_normalize(input_1, axis=2)
input_2 = (input_2 - K.mean(input_2, axis=2, keepdims=True)) + 0.00001
input_2 = K.l2_normalize(input_2, axis=2)
# Pad the first input1 circular, so that a correlation can be computed for
# every horizontal position
padding1 = RangePadding2D(padding=self.W // 2)(input_1)
# tf.scan的原理解析：https://zhuanlan.zhihu.com/p/96503559
out = tf.scan(self.single_sample_corr,
elems=[padding1, input_2],
initializer=(K.zeros((int(self.H), int(self.W), int(self.output_dim))))
)
return out
def call(self, inputs, **kwargs):
batch_size, input_len, _ = inputs.shape
q = K.expand_dims(K.dot(inputs, self.Wq), 2)
k = K.expand_dims(K.dot(inputs, self.Wk), 1)
h = tf.tanh(q + k + self.bh)
e = K.dot(h, self.Wv) + self.ba
# e = K.reshape(e, shape=(batch_size, input_len, input_len))
e = tf.reshape(e, shape=(batch_size, input_len, input_len))
e = K.exp(e - K.max(e, axis=-1, keepdims=True))
s = K.sum(e, axis=-1, keepdims=True)
a = e / (s + K.epsilon())
v = K.batch_dot(a, inputs)
return v
def process_yolo_layer_output(feats, anchors, num_classes, input_shape, image_shape):
"""Process Conv layer output"""
box_xy, box_wh, box_confidence, box_class_probs = yolo_head(feats, anchors, num_classes, input_shape)
box_scores = box_confidence * box_class_probs
highest_score_indexes = K.argmax(box_scores, axis=-1)
box_classes = K.reshape(highest_score_indexes, [-1])
highest_scores = K.max(box_scores, axis=-1)
highest_box_scores = K.reshape(highest_scores, [-1])
boxes = scale_boxes_to_original_image_size(box_xy, box_wh, image_shape)
boxes = K.reshape(boxes, [-1, 4])
return boxes, highest_box_scores, box_classes
def compute_fd_loss(boxes, scores, annotations, iou_threshold=0.75):
"""compute the overlap of boxes with annotations"""
iou = overlap(boxes, annotations)
max_iou = K.max(iou, axis=1, keepdims=True)
targets = K.cast(K.greater_equal(max_iou, iou_threshold), K.floatx())
# compute the loss
loss = focal(targets, scores) # alpha=self.alpha, gamma=self.gamma)
# compute the normalizer: the number of cells present in the image
normalizer = K.cast(K.shape(annotations)[0], K.floatx())
normalizer = K.maximum(K.cast_to_floatx(1.0), normalizer)
return K.sum(loss) / normalizer
def call(self, inputs):
# inputs_trans = (batch_size, the number of filters, sentence_length)
inputs_trans = tf.transpose(inputs, [0, 2, 1])
# at = (batch_size, the number of classes, sentence_length)
at = tf.matmul(self.Wa, inputs_trans)
# Softmax
at = K.exp(at - K.max(at, axis=-1, keepdims=True))
at = at / K.sum(at, axis=-1, keepdims=True)
# weighted sum
# v = (batch_size, the number of classes, the number of filters)
v = K.batch_dot(at, inputs)
return v
def call(self, h, mask=None):
h_shape = K.shape(h)
d_w, T = h_shape[0], h_shape[1]
logits = K.dot(h, self.w) # w^T h
logits = K.reshape(logits, (d_w, T))
alpha = K.exp(logits - K.max(logits, axis=-1, keepdims=True)) # exp
# masked timesteps have zero weight
if mask is not None:
mask = K.cast(mask, K.floatx())
alpha = alpha * mask
alpha = alpha / K.sum(alpha, axis=1, keepdims=True) # softmax
r = K.sum(h * K.expand_dims(alpha), axis=1) # r = h*alpha^T
h_star = K.tanh(r) # h^* = tanh(r)
if self.return_attention:
return [h_star, alpha]
return h_star
def call(self, seq_value_len_list, **kwargs):
uiseq_embed_list, user_behavior_length = seq_value_len_list
embedding_size = uiseq_embed_list.shape[-1]
mask = tf.sequence_mask(user_behavior_length,
self.seq_len_max, dtype=tf.float32)
mask = K.permute_dimensions(mask, [0, 2, 1])
mask = tf.tile(mask, [1, 1, embedding_size])
uiseq_embed_list *= mask
hist = uiseq_embed_list
if self.mode == "max":
return K.max(hist, 1, keepdims=True)
hist = K.sum(hist, 1, keepdims=False)
if self.mode == "mean":
hist = tf.div(hist, user_behavior_length)
hist = tf.expand_dims(hist, axis=1)
return hist
def call(self, x, mask=None):
# computes a probability distribution over the timesteps
# uses 'max trick' for numerical stability
# reshape is done to avoid issue with Tensorflow
# and 1-dimensional weights
logits = K.dot(x, self.W)
x_shape = K.shape(x)
logits = K.reshape(logits, (x_shape[0], x_shape[1]))
ai = K.exp(logits - K.max(logits, axis=-1, keepdims=True))
# masked timesteps have zero weight
if mask is not None:
mask = K.cast(mask, K.floatx())
ai = ai * mask
att_weights = ai / (K.sum(ai, axis=1, keepdims=True) + K.epsilon())
weighted_input = x * K.expand_dims(att_weights)
result = K.sum(weighted_input, axis=1)
if self.return_attention:
return [result, att_weights]
return result
def call(self, inputs):
if not self.norm_method:
outputs = inputs
elif self.norm_method == 'whole_image':
axes = [3, 4] if self.channel_axis == 1 else [2, 3]
outputs = inputs - K.mean(inputs, axis=axes, keepdims=True)
outputs = outputs / K.std(inputs, axis=axes, keepdims=True)
elif self.norm_method == 'std':
outputs = inputs - self._average_filter(inputs)
outputs = outputs / self._window_std_filter(outputs)
elif self.norm_method == 'max':
outputs = inputs / K.max(inputs)
outputs = outputs - self._average_filter(outputs)
else:
raise NotImplementedError('"{}" is not a valid norm_method'.format(
self.norm_method))
return outputs
def call(self, inputs):
if self.data_format == 'channels_last':
return backend.max(inputs, axis=[1, 2])
else:
return backend.max(inputs, axis=[2, 3])
def call(self, inputs):
steps_axis = 1 if self.data_format == 'channels_last' else 2
return backend.max(inputs, axis=steps_axis)
def call(self, inputs):
if self.data_format == 'channels_last':
return backend.max(inputs, axis=[1, 2, 3])
else:
return backend.max(inputs, axis=[2, 3, 4])
def call(self, inputs): steps_axis = 1 if self.data_format == 'channels_last' else 2 return backend.max(inputs, axis=steps_axis)
def call(self, inputs):
return backend.max(inputs, axis=1)
def call(self, inputs): return backend.max(inputs, axis=1)