def call(self, inputs): """ inputs [batch, seq, windows_size, 1, filters ] """ values = inputs[:, :(self.seq - 1), :, :, :] query = inputs[:, (self.seq - 1), :, :, :] values = tf.reshape(values, [-1, self.windows_size, 1, self.filters_in]) values_out = K.conv2d( values, self.weight_value, strides=(1, 1), padding='valid', data_format="channels_last" ) # [ batch*(seq-1) , rest_window, 1, self.filters_out 1] temp_shape = values_out.get_shape().as_list() values_out = tf.reshape(values_out, [-1, temp_shape[1] * temp_shape[3]]) values_out = tf.reshape( values_out, [-1, (self.seq - 1), temp_shape[1] * temp_shape[3]]) query_out = K.conv2d(query, self.weight_query, strides=(1, 1), padding='valid', data_format="channels_last" ) # [ batch , rest_window, 1, self.filters_out 1] query_out = tf.reshape(query_out, [-1, temp_shape[1] * temp_shape[3]]) query_out = tf.expand_dims(query_out, 1) score = self.V(tf.nn.tanh(values_out + query_out)) attention_weights = tf.nn.softmax(score, axis=1) #[batch , seq-1, 1] values = tf.reshape( values, [-1, (self.seq - 1), self.windows_size * self.filters_in]) context_vector = attention_weights * values context_vector = tf.reduce_sum(context_vector, axis=1) query = tf.reshape(query, [-1, self.windows_size * self.filters_in]) out = tf.concat([context_vector, query], axis=-1) return out
def check_the_config_valid(para, window_size, feature): initial_state = np.zeros((1, window_size, feature, 1)) initial_state = tf.cast(initial_state, 'float32') initial_state = K.zeros_like(initial_state) channel = 1 try: for i in range(para["preprocessing_layers"]): shape = (para["pre_kernel_width"], 1, channel, para["pre_number_filters"]) channel = para["pre_number_filters"] initial_state = K.conv2d( initial_state, array_ops.zeros(tuple(shape)), (para["pre_strides"], 1)) #,dilation_rate=(para["pre_dilation_rate"],1)) for i in range(1, 4): assert len(para["eclstm_{}_recurrent_activation".format(i)]) == len(para["eclstm_{}_conv_activation".format(i)]) == \ len(para["eclstm_{}_number_filters".format(i)]) == len(para["eclstm_{}_kernel_width".format(i)])== \ len(para["eclstm_{}_fusion".format(i)]), "Archtecture Parameters of {} layer should be in same length".format(i) for j in range( len(para["eclstm_{}_recurrent_activation".format(i)])): if para["eclstm_{}_recurrent_activation".format(i)][0] is None: break if para["eclstm_{}_fusion".format(i)][j] == "early": shape = (para["eclstm_{}_kernel_width".format(i)][j], feature, channel, para["eclstm_{}_number_filters".format(i)][j]) feature = 1 channel = para["eclstm_{}_number_filters".format(i)][j] else: shape = (para["eclstm_{}_kernel_width".format(i)][j], 1, channel, para["eclstm_{}_number_filters".format(i)][j]) channel = para["eclstm_{}_number_filters".format(i)][j] initial_state = K.conv2d( initial_state, array_ops.zeros(tuple(shape)), (para["eclstm_{}_strides".format(i)], 1)) print("valid Configuration!") return True except: print( "Invalid Configuration! Try smaller strides or kernel size or greater window size!" ) return False
def call(self, inputs): _, kernel_b = xnorize(self.kernel, self.H) _, inputs_b = xnorize(inputs) outputs = K.conv2d(inputs_b, kernel_b, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) # calculate Wa and xa # kernel_a mask = K.reshape( self.kernel, (-1, self.filters)) # self.nb_row * self.nb_col * channels, filters kernel_a = K.stop_gradient(K.mean(K.abs(mask), axis=0)) # filters # inputs_a if self.data_format == 'channels_first': channel_axis = 1 else: channel_axis = -1 mask = K.mean(K.abs(inputs), axis=channel_axis, keepdims=True) ones = K.ones(self.kernel_size + (1, 1)) inputs_a = K.conv2d(mask, ones, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate ) # nb_sample, 1, new_nb_row, new_nb_col if self.data_format == 'channels_first': outputs = outputs * K.stop_gradient(inputs_a) * K.expand_dims( K.expand_dims(K.expand_dims(kernel_a, 0), -1), -1) else: outputs = outputs * K.stop_gradient(inputs_a) * K.expand_dims( K.expand_dims(K.expand_dims(kernel_a, 0), 0), 0) if self.use_bias: outputs = K.bias_add(outputs, self.bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def call(self, inputs, training=None): def _l2normalize(v, eps=1e-12): return v / (K.sum(v**2)**0.5 + eps) def power_iteration(W, u): _u = u _v = _l2normalize(K.dot(_u, K.transpose(W))) _u = _l2normalize(K.dot(_v, W)) return _u, _v if self.spectral_normalization: W_shape = self.kernel.shape.as_list() # Flatten the Tensor W_reshaped = K.reshape(self.kernel, [-1, W_shape[-1]]) _u, _v = power_iteration(W_reshaped, self.u) # Calculate Sigma sigma = K.dot(_v, W_reshaped) sigma = K.dot(sigma, K.transpose(_u)) # normalize it W_bar = W_reshaped / sigma # reshape weight tensor if training in {0, False}: W_bar = K.reshape(W_bar, W_shape) else: with tf.control_dependencies([self.u.assign(_u)]): W_bar = K.reshape(W_bar, W_shape) # update weitht self.kernel = W_bar if self.rank == 1: outputs = K.conv1d(inputs, self.kernel, strides=self.strides[0], padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate[0]) if self.rank == 2: outputs = K.conv2d(inputs, self.kernel, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.rank == 3: outputs = K.conv3d(inputs, self.kernel, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.use_bias: outputs = K.bias_add(outputs, self.bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def recurrent_conv_u(self, x, w): conv_out = K.conv2d(x, w, strides=(1, 1), padding='same', data_format='channels_last') return conv_out
def recurrent_conv(self, x, w): conv_out = K.conv2d(x, w, strides=(1, 1), padding='same', data_format=self.data_format) return conv_out
def call(self, inputs, **kwargs): if type(inputs) is list: features = inputs[0] else: features = inputs if self.weightnorm: norm = tf.sqrt( tf.reduce_sum(tf.square(self.kernel), (0, 1, 2)) + self.eps) kernel = self.kernel / norm * self.wn_g else: kernel = self.kernel features = K.conv2d(features, kernel, strides=self.strides, padding=self.padding, dilation_rate=self.dilation_rate) if self.use_bias: features = tf.add(features, self.bias) if self.activation is not None: features = self.activation(features) return features
def soft_min_reg(cv, axis=None, min_disp=None, max_disp=None, labels=None): if axis == 1: cv = Lambda(lambda x: K.squeeze(x, axis=-1))(cv) disp_map = K.reshape( K.arange(min_disp, max_disp - 0.000001, (max_disp - min_disp) / labels, dtype="float32"), (1, 1, labels, 1)) if axis == 1: output = K.conv2d(cv, disp_map, strides=(1, 1), padding='valid', data_format="channels_first") x = K.expand_dims(K.squeeze(output, axis=1), axis=-1) else: x = K.conv2d(cv, disp_map, strides=(1, 1), padding='valid') return x
def input_conv_u(self, x, w, b=None, padding='same'): conv_out = K.conv2d(x, w, strides=self.strides, padding=padding, data_format='channels_last', dilation_rate=self.dilation_rate) if b is not None: conv_out = K.bias_add(conv_out, b, data_format='channels_last') return conv_out
def _conv(self, x, w, b=None, padding='same'): conv_out = K.conv2d(x, w, strides=(1, 1), padding=padding, data_format='channels_last') if b is not None: conv_out = K.bias_add(conv_out, b, data_format='channels_last') return conv_out
def input_conv(self, x, w, b=None, padding='valid'): conv_out = backend.conv2d(x, w, strides=self.strides, padding=padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if b is not None: conv_out = backend.bias_add(conv_out, b, data_format=self.data_format) return conv_out
def input_conv(self, x, w, b=None, padding='valid'): conv_out = K.conv2d(x, w, strides=self.strides, padding=padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if b is not None: conv_out = K.bias_add(conv_out, b, data_format=self.data_format) return conv_out
def call(self, inputs): #? scaled_kernel = self.kernel * self.runtime_coeff if self.rank == 1: kernel = Ke.pad(scaled_kernel , [[1,1], [0,0], [0,0]]) fused_kernel = Ke.add_n([kernel[1:] , kernel[:-1]]) / 2.0 outputs = K.conv1d(inputs , fused_kernel , strides=self.strides[0] , padding=self.padding , data_format=self.data_format , dilation_rate=self.dilation_rate[0]) if self.rank == 2: kernel = Ke.pad(scaled_kernel , [[1,1], [1,1], [0,0], [0,0]]) fused_kernel = Ke.add_n([kernel[1:, 1:] , kernel[:-1, 1:] , kernel[1:, :-1] , kernel[:-1, :-1]]) / 4.0 outputs = K.conv2d(inputs , fused_kernel , strides=self.strides , padding=self.padding , data_format=self.data_format , dilation_rate=self.dilation_rate) if self.rank == 3: kernel = Ke.pad(scaled_kernel , [[1,1], [1,1], [1,1], [0,0], [0,0]]) fused_kernel = Ke.add_n([kernel[1:, 1:, 1:] , kernel[1:, 1:, :-1] , kernel[1:, :-1, 1:] , kernel[1:, :-1, :-1] , kernel[:-1, 1:, 1:] , kernel[:-1, 1:, :-1] , kernel[:-1, :-1, 1:] , kernel[:-1, :-1, :-1]]) / 8.0 outputs = K.conv3d(inputs , fused_kernel , strides=self.strides , padding=self.padding , data_format=self.data_format , dilation_rate=self.dilation_rate) if self.use_bias: outputs = K.bias_add(outputs , self.bias , data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def do_2d_convolution(feature_matrix, kernel_matrix, pad_edges=False, stride_length_px=1): """Convolves 2-D feature maps with 2-D kernel. m = number of rows in kernel n = number of columns in kernel c = number of output feature maps (channels) :param feature_matrix: Input feature maps (numpy array). Dimensions must be M x N x C or 1 x M x N x C. :param kernel_matrix: Kernel as numpy array. Dimensions must be m x n x C x c. :param pad_edges: Boolean flag. If True, edges of input feature maps will be zero-padded during convolution, so spatial dimensions of the output feature maps will be the same (M x N). If False, dimensions of the output maps will be (M - m + 1) x (N - n + 1). :param stride_length_px: Stride length (pixels). The kernel will move by this many rows or columns at a time as it slides over each input feature map. :return: feature_matrix: Output feature maps (numpy array). Dimensions will be 1 x M x N x c or 1 x (M - m + 1) x (N - n + 1) x c, depending on whether or not edges are padded. """ error_checking.assert_is_numpy_array_without_nan(feature_matrix) error_checking.assert_is_numpy_array_without_nan(kernel_matrix) error_checking.assert_is_numpy_array(kernel_matrix, num_dimensions=4) error_checking.assert_is_boolean(pad_edges) error_checking.assert_is_integer(stride_length_px) error_checking.assert_is_geq(stride_length_px, 1) if len(feature_matrix.shape) == 3: feature_matrix = numpy.expand_dims(feature_matrix, axis=0) error_checking.assert_is_numpy_array(feature_matrix, num_dimensions=4) if pad_edges: padding_string = 'same' else: padding_string = 'valid' feature_tensor = K.conv2d(x=K.variable(feature_matrix), kernel=K.variable(kernel_matrix), strides=(stride_length_px, stride_length_px), padding=padding_string, data_format='channels_last') return feature_tensor.numpy()
def apply_separate_filter_for_each_batch(inputs): kernel = inputs[1] x = K.expand_dims(inputs[0], axis=0) outputs = K.conv2d( x, kernel, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.bias is not None: bias = inputs[2] outputs = K.bias_add(outputs, bias, data_format=self.data_format) return K.squeeze(outputs, axis=0)
def context_gating(self, x, w, rx, rw, b=None, padding='valid'): input_shape = x.get_shape().as_list() if self.data_format == 'channels_first': x = K.pool2d(x, (input_shape[2], input_shape[3]), pool_mode='avg') rx = K.pool2d(rx, (input_shape[2], input_shape[3]), pool_mode='avg') elif self.data_format == 'channels_last': x = K.pool2d(x, (input_shape[1], input_shape[2]), pool_mode='avg') rx = K.pool2d(rx, (input_shape[1], input_shape[2]), pool_mode='avg') conv_out1 = K.conv2d( x, w, strides=self.strides, padding=padding, data_format=self.data_format) conv_out2 = K.conv2d( rx, rw, strides=self.strides, padding=padding, data_format=self.data_format) conv_out = conv_out1 + conv_out2 if b is not None: conv_out = K.bias_add(conv_out, b, data_format=self.data_format) return conv_out
def call(self, inputs): outputs = K.conv2d(inputs, self.W_bar(), strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.use_bias: outputs = K.bias_add(outputs, self.bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def correlation(self, displace, kernel): """ Do the actual convolution==correlation. """ # Given an input tensor of shape [batch, in_height, in_width, in_channels] displace = K.expand_dims(displace, 0) # 在开头增加一维 # a kernel tensor of shape [filter_height, filter_width, in_channels, out_channels] kernel = K.expand_dims(kernel, 3) # 在末尾增加一维 # kernal去水平扫padding这一长条 out = K.conv2d(displace, kernel, padding='valid', data_format='channels_last') out = K.squeeze(out, 0) # 扒掉开头的维度 # print(K.int_shape(out)) # (1,360,1) return out
def call(self, inputs): binary_kernel = binarize(self.kernel, H=self.H) outputs = K.conv2d(inputs, binary_kernel, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.use_bias: outputs = K.bias_add(outputs, self.bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def call(self, inputs, training=None): input_transposed = tf.transpose(inputs, [3, 0, 1, 2, 4]) input_shape = tf.shape(input_transposed) input_tensor_reshaped = tf.reshape(input_transposed, [ input_shape[0] * input_shape[1], 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)) conv = K.conv2d(input_tensor_reshaped, self.W, (self.strides, self.strides), padding=self.padding, data_format='channels_last') votes_shape = tf.shape(conv) _, conv_height, conv_width, _ = conv.get_shape() votes = tf.reshape(conv, [ 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 = tf.stack([ input_shape[1], input_shape[0], votes_shape[1], votes_shape[2], self.num_capsule ]) biases_replicated = tf.tile( self.b, [conv_height.value, conv_width.value, 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
def call(self, inputs, training=None): outputs = K.conv2d( inputs, self.compute_spectral_normal(training), strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.bias is not None: outputs = K.bias_add( outputs, self.bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def call(self, inputs): # Mask kernel with connection matrix masked_kernel = self.kernel * self.connections # Apply convolution if self.rank == 1: outputs = K.conv1d( inputs, masked_kernel, strides=self.strides[0], padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate[0]) if self.rank == 2: outputs = K.conv2d( inputs, masked_kernel, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.rank == 3: outputs = K.conv3d( inputs, masked_kernel, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.use_bias: outputs = K.bias_add( outputs, self.bias, data_format=self.data_format) if self.activation is not None: return self.activation(outputs) return outputs
def max_singular_val_for_convolution(w, u, fully_differentiable=False, ip=1, padding='same', strides=(1, 1), data_format='channels_last'): assert ip >= 1 if not fully_differentiable: w_ = K.stop_gradient(w) else: w_ = w u_bar = u for _ in range(ip): v_bar = K.conv2d(u_bar, w_, strides=strides, data_format=data_format, padding=padding) v_bar = K.l2_normalize(v_bar) u_bar_raw = K.conv2d_transpose(v_bar, w_, output_shape=K.int_shape(u), strides=strides, data_format=data_format, padding=padding) u_bar = K.l2_normalize(u_bar_raw) u_bar_raw_diff = K.conv2d_transpose(v_bar, w, output_shape=K.int_shape(u), strides=strides, data_format=data_format, padding=padding) sigma = K.sum(u_bar * u_bar_raw_diff) return sigma, u_bar
def call(self, inputs, training=None): scaled_kernel = self.kernel * self.runtime_coeff if self.rank == 1: outputs = K.conv1d( inputs, scaled_kernel, strides=self.strides[0], padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate[0]) if self.rank == 2: outputs = K.conv2d( inputs, scaled_kernel, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.rank == 3: outputs = K.conv3d( inputs, scaled_kernel, strides=self.strides, padding=self.padding, data_format=self.data_format, dilation_rate=self.dilation_rate) if self.use_bias: outputs = K.bias_add( outputs, self.bias, data_format=self.data_format) if self.activation is not None: outputs = self.activation(outputs) return outputs
def offset_conv2d_eval(depth, padding, x): """Perform a conv2d on x with a given padding""" kernel = K.variable(value=np.array([[[[1]] + [[0]] * (depth - 1)]]), dtype='float32') return K.conv2d(x, kernel, strides=(3, 3), padding=padding)
def call(self, features): ni = features.shape[-1] no = self.filters if self.group == 'C4': nt = 4 elif self.group == 'D4': nt = 8 nti = 1 if self.first else nt nto = nt k = self.kernel_size[0] t = np.reshape(np.arange(nti * k * k), (nti, k, k)) trafos = [np.rot90(t, k, axes=(1, 2)) for k in range(4)] if nt == 8: trafos = trafos + [np.flip(t, 1) for t in trafos] self.trafos = trafos = np.array(trafos) # index magic happens here if nti == 1: indices = trafos elif nti == 4: indices = [[trafos[l, (m - l) % 4, :, :] for m in range(4)] for l in range(4)] elif nti == 8: indices = [[ trafos[l, (m - l) % 4 if ((m < 4) == (l < 4)) else (m + l) % 4 + 4, :, :] for m in range(8) ] for l in range(8)] self.indices = indices = np.reshape(indices, (nto, nti, k, k)) # transform the kernel kernel = self.kernel kernel = tf.reshape(kernel, (nti * k * k, ni, no)) kernel = tf.gather(kernel, indices, axis=0) kernel = tf.reshape(kernel, (nto, nti, k, k, ni, no)) kernel = tf.transpose(kernel, (2, 3, 1, 4, 0, 5)) kernel = tf.reshape(kernel, (k, k, nti * ni, nto * no)) self.transformed_kernel = kernel if self.first: x = features else: s = features.shape x = tf.reshape(features, (-1, s[1], s[2], s[3] * s[4])) x = K.conv2d(x, kernel, strides=self.strides, padding=self.padding, dilation_rate=self.dilation_rate) s = x.shape x = tf.reshape(x, (-1, s[1], s[2], nto, no)) if self.use_bias: features = tf.add(features, self.bias) if self.activation is not None: features = self.activation(features) return x
def offset_conv2d_eval(depth, padding, x): """Perform a conv2d on x with a given padding""" kernel = K.variable(value=np.array([[[[1]] + [[0]] * (depth - 1)]]), dtype='float32') return K.conv2d(x, kernel, strides=(3, 3), padding=padding)
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
def recurrent_conv(self, x, w): conv_out = K.conv2d(x, w, strides=(1, 1), padding='same', data_format=self.data_format) return conv_out
def find_patch_matches(a, a_norm, b): '''For each patch in A, find the best matching patch in B''' # we want cross-correlation here so flip the kernels convs = K.conv2d(a, b[:, :, ::-1, ::-1], border_mode='valid') argmax = K.argmax(convs / a_norm, axis=1) return argmax