def call(self, inputs): if self._reshape_required: reshaped_inputs = [] input_ndims = list(map(K.ndim, inputs)) if None not in input_ndims: # If ranks of all inputs are available, # we simply expand each of them at axis=1 # until all of them have the same rank. max_ndim = max(input_ndims) for x in inputs: x_ndim = K.ndim(x) for _ in range(max_ndim - x_ndim): x = K.expand_dims(x, 1) reshaped_inputs.append(x) return self._merge_function(reshaped_inputs) else: # Transpose all inputs so that batch size is the last dimension. # (batch_size, dim1, dim2, ... ) -> (dim1, dim2, ... , batch_size) transposed = False for x in inputs: x_ndim = K.ndim(x) if x_ndim is None: x_shape = K.shape(x) batch_size = x_shape[0] new_shape = K.concatenate([x_shape[1:], K.expand_dims(batch_size)]) x_transposed = K.reshape(x, K.stack([batch_size, K.prod(x_shape[1:])])) x_transposed = K.permute_dimensions(x_transposed, (1, 0)) x_transposed = K.reshape(x_transposed, new_shape) reshaped_inputs.append(x_transposed) transposed = True elif x_ndim > 1: dims = list(range(1, x_ndim)) + [0] reshaped_inputs.append(K.permute_dimensions(x, dims)) transposed = True else: # We don't transpose inputs if they are 1D vectors or scalars. reshaped_inputs.append(x) y = self._merge_function(reshaped_inputs) y_ndim = K.ndim(y) if transposed: # If inputs have been transposed, we have to transpose the output too. if y_ndim is None: y_shape = K.shape(y) y_ndim = K.shape(y_shape)[0] batch_size = y_shape[y_ndim - 1] new_shape = K.concatenate( [K.expand_dims(batch_size), y_shape[:y_ndim - 1]]) y = K.reshape(y, (-1, batch_size)) y = K.permute_dimensions(y, (1, 0)) y = K.reshape(y, new_shape) elif y_ndim > 1: dims = [y_ndim - 1] + list(range(y_ndim - 1)) y = K.permute_dimensions(y, dims) return y else: return self._merge_function(inputs)
def call(self, inputs, training=None, mask=None): kwargs = {} func_args = inspect.getargspec(self.layer.call).args if 'training' in func_args: kwargs['training'] = training if 'mask' in func_args: kwargs['mask'] = mask y = self.forward_layer.call(inputs, **kwargs) y_rev = self.backward_layer.call(inputs, **kwargs) if self.return_sequences: y_rev = K.reverse(y_rev, 1) if self.merge_mode == 'concat': output = K.concatenate([y, y_rev]) elif self.merge_mode == 'sum': output = y + y_rev elif self.merge_mode == 'ave': output = (y + y_rev) / 2 elif self.merge_mode == 'mul': output = y * y_rev elif self.merge_mode is None: output = [y, y_rev] # Properly set learning phase if 0 < self.layer.dropout + self.layer.recurrent_dropout: if self.merge_mode is None: for out in output: out._uses_learning_phase = True else: output._uses_learning_phase = True return output
def call(self, inputs, training=None, mask=None): kwargs = {} func_args = tf_inspect.getargspec(self.layer.call).args if 'training' in func_args: kwargs['training'] = training if 'mask' in func_args: kwargs['mask'] = mask y = self.forward_layer.call(inputs, **kwargs) y_rev = self.backward_layer.call(inputs, **kwargs) if self.return_sequences: y_rev = K.reverse(y_rev, 1) if self.merge_mode == 'concat': output = K.concatenate([y, y_rev]) elif self.merge_mode == 'sum': output = y + y_rev elif self.merge_mode == 'ave': output = (y + y_rev) / 2 elif self.merge_mode == 'mul': output = y * y_rev elif self.merge_mode is None: output = [y, y_rev] # Properly set learning phase if 0 < self.layer.dropout + self.layer.recurrent_dropout: if self.merge_mode is None: for out in output: out._uses_learning_phase = True else: output._uses_learning_phase = True return output
def compute_mask(self, inputs, mask=None): if mask is None: return None if not isinstance(mask, list): raise ValueError('`mask` should be a list.') if not isinstance(inputs, list): raise ValueError('`inputs` should be a list.') if len(mask) != len(inputs): raise ValueError('The lists `inputs` and `mask` ' 'should have the same length.') if all([m is None for m in mask]): return None # Make a list of masks while making sure # the dimensionality of each mask # is the same as the corresponding input. masks = [] for input_i, mask_i in zip(inputs, mask): if mask_i is None: # Input is unmasked. Append all 1s to masks, # but cast it to bool first masks.append(K.cast(K.ones_like(input_i), 'bool')) elif K.ndim(mask_i) < K.ndim(input_i): # Mask is smaller than the input, expand it masks.append(K.expand_dims(mask_i)) else: masks.append(mask_i) concatenated = K.concatenate(masks, axis=self.axis) return K.all(concatenated, axis=-1, keepdims=False)
def yolo_boxes_to_corners(box_xy, box_wh): """Convert YOLO box predictions to bounding box corners.""" box_mins = box_xy - (box_wh / 2.) box_maxes = box_xy + (box_wh / 2.) return K.concatenate([ box_mins[..., 1:2], # y_min box_mins[..., 0:1], # x_min box_maxes[..., 1:2], # y_max box_maxes[..., 0:1] # x_max ])
def compute_mask(self, inputs, mask=None): if mask is None: return None if not isinstance(mask, list): raise ValueError('`mask` should be a list.') if not isinstance(inputs, list): raise ValueError('`inputs` should be a list.') if len(mask) != len(inputs): raise ValueError('The lists `inputs` and `mask` ' 'should have the same length.') if all([m is None for m in mask]): return None masks = [K.expand_dims(m, 0) for m in mask if m is not None] return K.all(K.concatenate(masks, axis=0), axis=0, keepdims=False)
def call(self, inputs, mask=None): y = self.forward_layer.call(inputs, mask) y_rev = self.backward_layer.call(inputs, mask) if self.return_sequences: y_rev = K.reverse(y_rev, 1) if self.merge_mode == 'concat': return K.concatenate([y, y_rev]) elif self.merge_mode == 'sum': return y + y_rev elif self.merge_mode == 'ave': return (y + y_rev) / 2 elif self.merge_mode == 'mul': return y * y_rev elif self.merge_mode is None: return [y, y_rev]
def preprocess_input(self, inputs, training=None): if self.implementation == 0: input_shape = inputs.get_shape().as_list() input_dim = input_shape[2] timesteps = input_shape[1] x_i = _time_distributed_dense( inputs, self.kernel_i, self.bias_i, self.dropout, input_dim, self.units, timesteps, training=training) x_f = _time_distributed_dense( inputs, self.kernel_f, self.bias_f, self.dropout, input_dim, self.units, timesteps, training=training) x_c = _time_distributed_dense( inputs, self.kernel_c, self.bias_c, self.dropout, input_dim, self.units, timesteps, training=training) x_o = _time_distributed_dense( inputs, self.kernel_o, self.bias_o, self.dropout, input_dim, self.units, timesteps, training=training) return K.concatenate([x_i, x_f, x_c, x_o], axis=2) else: return inputs
def call(self, inputs): stride = self.strides[0] output_length, feature_dim, filters = self.kernel_shape xs = [] for i in range(output_length): slice_length = slice(i * stride, i * stride + self.kernel_size[0]) xs.append(K.reshape(inputs[:, slice_length, :], (1, -1, feature_dim))) x_aggregate = K.concatenate(xs, axis=0) # Shape: `(output_length, batch_size, filters)`. output = K.batch_dot(x_aggregate, self.kernel) output = K.permute_dimensions(output, (1, 0, 2)) if self.use_bias: output += K.reshape(self.bias, (1, output_length, filters)) if self.activation is not None: output = self.activation(output) return output
def preprocess_input(self, inputs, training=None): if self.implementation == 0: input_shape = inputs.get_shape().as_list() input_dim = input_shape[2] timesteps = input_shape[1] x_z = _time_distributed_dense( inputs, self.kernel_z, self.bias_z, self.dropout, input_dim, self.units, timesteps, training=training) x_r = _time_distributed_dense( inputs, self.kernel_r, self.bias_r, self.dropout, input_dim, self.units, timesteps, training=training) x_h = _time_distributed_dense( inputs, self.kernel_h, self.bias_h, self.dropout, input_dim, self.units, timesteps, training=training) return K.concatenate([x_z, x_r, x_h], axis=2) else: return inputs
def call(self, inputs): stride_row, stride_col = self.strides _, feature_dim, filters = self.kernel_shape if self.data_format == 'channels_first': if K.backend() == 'theano': output = [] for i in range(self.output_row): for j in range(self.output_col): slice_row = slice(i * stride_row, i * stride_row + self.kernel_size[0]) slice_col = slice(j * stride_col, j * stride_col + self.kernel_size[1]) x_flatten = K.reshape(inputs[:, :, slice_row, slice_col], (1, -1, feature_dim)) output.append( K.dot(x_flatten, self.kernel[i * self.output_col + j, :, :])) output = K.concatenate(output, axis=0) else: xs = [] for i in range(self.output_row): for j in range(self.output_col): slice_row = slice(i * stride_row, i * stride_row + self.kernel_size[0]) slice_col = slice(j * stride_col, j * stride_col + self.kernel_size[1]) xs.append( K.reshape(inputs[:, :, slice_row, slice_col], (1, -1, feature_dim))) x_aggregate = K.concatenate(xs, axis=0) output = K.batch_dot(x_aggregate, self.kernel) output = K.reshape(output, (self.output_row, self.output_col, -1, filters)) output = K.permute_dimensions(output, (2, 3, 0, 1)) elif self.data_format == 'channels_last': xs = [] for i in range(self.output_row): for j in range(self.output_col): slice_row = slice(i * stride_row, i * stride_row + self.kernel_size[0]) slice_col = slice(j * stride_col, j * stride_col + self.kernel_size[1]) xs.append( K.reshape(inputs[:, slice_row, slice_col, :], (1, -1, feature_dim ))) x_aggregate = K.concatenate(xs, axis=0) output = K.batch_dot(x_aggregate, self.kernel) output = K.reshape(output, (self.output_row, self.output_col, -1, filters)) output = K.permute_dimensions(output, (2, 0, 1, 3)) if self.use_bias: if self.data_format == 'channels_first': output += K.reshape(self.bias, (1, filters, self.output_row, self.output_col)) elif self.data_format == 'channels_last': output += K.reshape(self.bias, (1, self.output_row, self.output_col, filters)) output = self.activation(output) return output
def bias_initializer(_, *args, **kwargs): return K.concatenate([ self.bias_initializer((self.units,), *args, **kwargs), initializers.Ones()((self.units,), *args, **kwargs), self.bias_initializer((self.units * 2,), *args, **kwargs), ])
def call(self, inputs): if not isinstance(inputs, list): raise ValueError('A `Concatenate` layer should be called ' 'on a list of inputs.') return K.concatenate(inputs, axis=self.axis)