我们从Python开源项目中，提取了以下37个代码示例，用于说明如何使用keras.backend.repeat_elements()。
def call(self, x, mask=None): if K.image_dim_ordering == "th": _, f, r, c = self.shape else: _, r, c, f = self.shape half_n = self.n // 2 squared = K.square(x) pooled = K.pool2d(squared, (half_n, half_n), strides=(1, 1), padding="same", pool_mode="avg") if K.image_dim_ordering == "th": summed = K.sum(pooled, axis=1, keepdims=True) averaged = (self.alpha / self.n) * K.repeat_elements(summed, f, axis=1) else: summed = K.sum(pooled, axis=3, keepdims=True) averaged = (self.alpha / self.n) * K.repeat_elements(summed, f, axis=3) denom = K.pow(self.k + averaged, self.beta) return x / denom
def call(self, inputs, mask=None): input_shape = K.int_shape(inputs) outputs = self.layer.call(inputs) outputs = K.permute_dimensions( outputs, self.permute_pattern + [len(input_shape) - 1] ) outputs_shape = self.compute_output_shape(input_shape) outputs = K.reshape( outputs, (-1, outputs_shape[1], outputs_shape[2]) ) mask_tensor = self.compute_mask( inputs, mask ) mask_tensor = K.cast(mask_tensor, K.floatx()) mask_tensor = K.expand_dims(mask_tensor) mask_output = K.repeat_elements( mask_tensor, outputs_shape[2], 2 ) return outputs * mask_output
def step(self, inputs, states): h_tm1 = states[0] # previous memory #B_U = states[1] # dropout matrices for recurrent units #B_W = states[2] h_tm1a = K.dot(h_tm1, self.Wa) eij = K.dot(K.tanh(h_tm1a + K.dot(inputs[:, :self.h_dim], self.Ua)), self.Va) eijs = K.repeat_elements(eij, self.h_dim, axis=1) #alphaij = K.softmax(eijs) # batchsize * lenh h batchsize * lenh * ndim #ci = K.permute_dimensions(K.permute_dimensions(self.h, [2,0,1]) * alphaij, [1,2,0]) #cisum = K.sum(ci, axis=1) cisum = eijs*inputs[:, :self.h_dim] #print(K.shape(cisum), cisum.shape, ci.shape, self.h.shape, alphaij.shape, x.shape) zr = K.sigmoid(K.dot(inputs[:, self.h_dim:], self.Wzr) + K.dot(h_tm1, self.Uzr) + K.dot(cisum, self.Czr)) zi = zr[:, :self.units] ri = zr[:, self.units: 2 * self.units] si_ = K.tanh(K.dot(inputs[:, self.h_dim:], self.W) + K.dot(ri*h_tm1, self.U) + K.dot(cisum, self.C)) si = (1-zi) * h_tm1 + zi * si_ return si, [si] #h_tm1, [h_tm1]
def setup_output(self): """ Setup output tensor """ coordinates = get_coordinates(self.output_shape, input_channels=self.input_channels, num_filters=self.num_filters) num_parameters = np.prod(self.output_shape) * self.num_filters * \ self.input_channels print (num_parameters) # self.z_r = K.repeat_elements(self.z, rep=num_parameters, axis=0) self.z_r = self.init((num_parameters, 4)) # coordinates = K.concatenate([self.z_r, coordinates], axis=1) output = K.tanh(K.dot(self.z_r, self.weights[0]) + self.biases[0]) for i in range(1, len(self.weights) - 1): output = K.tanh(K.dot(output, self.weights[i]) + self.biases[i]) output = K.sigmoid(K.dot(output, self.weights[-1]) + self.biases[-1]) self.output = K.reshape(output, (self.num_filters, self.input_channels, *self.output_shape))
def get_output(self, train=False): X = self.get_input(train) if self.dim_ordering == 'th': output = K.repeat_elements(X, self.size[0], axis=2) output = K.repeat_elements(output, self.size[1], axis=3) elif self.dim_ordering == 'tf': output = K.repeat_elements(X, self.size[0], axis=1) output = K.repeat_elements(output, self.size[1], axis=2) else: raise Exception('Invalid dim_ordering: ' + self.dim_ordering) f = T.grad(T.sum(self._pool2d_layer.get_output(train)), wrt=self._pool2d_layer.get_input(train)) * output return f # 1D Bilinear interpolation for even size filters
def mix_gaussian_loss(x, mu, log_sig, w): ''' Combine the mixture of gaussian distribution and the loss into a single function so that we can do the log sum exp trick for numerical stability... ''' if K.backend() == "tensorflow": x.set_shape([None, 1]) gauss = log_norm_pdf(K.repeat_elements(x=x, rep=mu.shape[1], axis=1), mu, log_sig) # TODO: get rid of clipping. gauss = K.clip(gauss, -40, 40) max_gauss = K.maximum((0.), K.max(gauss)) # log sum exp trick... gauss = gauss - max_gauss out = K.sum(w * K.exp(gauss), axis=1) loss = K.mean(-K.log(out) + max_gauss) return loss
def QRNcell(): xq = Input(batch_shape=(batch_size, embedding_dim * 2)) # Split into context and query xt = Lambda(lambda x, dim: x[:, :dim], arguments={'dim': embedding_dim}, output_shape=lambda s: (s[0], s[1] / 2))(xq) qt = Lambda(lambda x, dim: x[:, dim:], arguments={'dim': embedding_dim}, output_shape=lambda s: (s[0], s[1] / 2))(xq) h_tm1 = Input(batch_shape=(batch_size, embedding_dim)) zt = Dense(1, activation='sigmoid', bias_initializer=Constant(2.5))(multiply([xt, qt])) zt = Lambda(lambda x, dim: K.repeat_elements(x, dim, axis=1), arguments={'dim': embedding_dim})(zt) ch = Dense(embedding_dim, activation='tanh')(concatenate([xt, qt], axis=-1)) rt = Dense(1, activation='sigmoid')(multiply([xt, qt])) rt = Lambda(lambda x, dim: K.repeat_elements(x, dim, axis=1), arguments={'dim': embedding_dim})(rt) ht = add([multiply([zt, ch, rt]), multiply([Lambda(lambda x: 1 - x, output_shape=lambda s: s)(zt), h_tm1])]) return RecurrentModel(input=xq, output=ht, initial_states=[h_tm1], final_states=[ht], return_sequences=True) # # Load data #
def call(self, x, mask=None): if self.mode == 'max': return K.max(x, axis=self.axis) elif self.mode == 'mean': return K.mean(x, axis=self.axis) elif self.mode == 'sum': return K.sum(x, axis=self.axis) elif self.mode == 'concat': assert len(x) >= 2 assert x[0].ndim == 3 def _transform(target): # Expand first dimension in any case target = K.expand_dims(target, dim=1) if self.axis == 2: # Repeat target along the time dimension target = K.repeat_elements( target, x[0].shape[1], axis=1) return target targets = map(lambda t: _transform(t) if t.ndim == 2 else t, x[1:]) return K.concatenate([x[0]] + targets, axis=self.axis) else: raise NotImplemented
def get_split_averages(input_tensor, input_mask, indices): # Splits input tensor into three parts based on the indices and # returns average of values prior to index, values at the index and # average of values after the index. # input_tensor: (batch_size, input_length, input_dim) # input_mask: (batch_size, input_length) # indices: (batch_size, 1) # (1, input_length) length_range = K.expand_dims(K.arange(K.shape(input_tensor)[1]), dim=0) # (batch_size, input_length) batched_range = K.repeat_elements(length_range, K.shape(input_tensor)[0], 0) tiled_indices = K.repeat_elements(indices, K.shape(input_tensor)[1], 1) # (batch_size, input_length) greater_mask = K.greater(batched_range, tiled_indices) # (batch_size, input_length) lesser_mask = K.lesser(batched_range, tiled_indices) # (batch_size, input_length) equal_mask = K.equal(batched_range, tiled_indices) # (batch_size, input_length) # We also need to mask these masks using the input mask. # (batch_size, input_length) if input_mask is not None: greater_mask = switch(input_mask, greater_mask, K.zeros_like(greater_mask)) lesser_mask = switch(input_mask, lesser_mask, K.zeros_like(lesser_mask)) post_sum = K.sum(switch(K.expand_dims(greater_mask), input_tensor, K.zeros_like(input_tensor)), axis=1) # (batch_size, input_dim) pre_sum = K.sum(switch(K.expand_dims(lesser_mask), input_tensor, K.zeros_like(input_tensor)), axis=1) # (batch_size, input_dim) values_at_indices = K.sum(switch(K.expand_dims(equal_mask), input_tensor, K.zeros_like(input_tensor)), axis=1) # (batch_size, input_dim) post_normalizer = K.expand_dims(K.sum(greater_mask, axis=1) + K.epsilon(), dim=1) # (batch_size, 1) pre_normalizer = K.expand_dims(K.sum(lesser_mask, axis=1) + K.epsilon(), dim=1) # (batch_size, 1) return K.cast(pre_sum / pre_normalizer, 'float32'), values_at_indices, K.cast(post_sum / post_normalizer, 'float32')
def repeat_channels(rep): def funct(x): return K.repeat_elements(x, rep, axis=4) return funct
def repeat_slices(rep): def funct(x): return K.repeat_elements(x, rep, axis=3) return funct
def mask_tensor(x): tensor, mask = x rep = K.int_shape(tensor)[4] return tensor*K.repeat_elements(mask, rep, axis=4)
def fill_background_mask(x): tensor, mask = x rep = K.int_shape(tensor)[4] - 1 full_mask = K.ones_like(mask) - mask K.repeat_elements(mask, rep, axis=4) return tensor + full_mask
def call(self, inputs): inputs_shape = K.int_shape(inputs) channel_axis = len(inputs_shape) - 1 masked_tensor = self.compute_mask(inputs) masked_tensor = K.expand_dims(masked_tensor) masked_tensor = K.repeat_elements( masked_tensor, inputs_shape[channel_axis], channel_axis ) return inputs * K.cast(masked_tensor, K.floatx())
def call(self, inputs, mask=None): inputs_tensor = inputs mask_inputs = K.expand_dims(mask) inputs_shape = K.int_shape(inputs) channel_axis = len(inputs_shape) - 1 if self.pool_mode == 'max': mask_inv = tf.logical_not(mask_inputs) negative_mask = K.cast(mask_inv, K.floatx()) * -1e20 negative_mask = K.repeat_elements( negative_mask, inputs_shape[channel_axis], channel_axis ) inputs_tensor = inputs + negative_mask output = self.layer._pooling_function( inputs_tensor, self.layer.pool_size, self.layer.strides, self.layer.padding, self.layer.data_format, ) mask_inputs = K.cast(mask_inputs, K.floatx()) mask_output = self.layer._pooling_function( mask_inputs, self.layer.pool_size, self.layer.strides, self.layer.padding, self.layer.data_format, ) mask_output = K.repeat_elements( mask_output, inputs_shape[channel_axis], channel_axis ) return output * mask_output
def call(self, inputs, mask=None): outputs = self.layer.call(inputs) channel_axis = K.ndim(inputs) - 1 mask_tensor = K.cast(mask, K.floatx()) mask_tensor = K.expand_dims(mask_tensor) mask_output = self._compute_mask_output(mask_tensor) mask_output = K.repeat_elements( mask_output, self.layer.filters, channel_axis ) return outputs * mask_output
def step(self, x, states): h, [h, c] = super(AttentionLSTM, self).step(x, states) attention = states[4] m = self.attn_activation(K.dot(h, self.U_a) * attention + self.b_a) # Intuitively it makes more sense to use a sigmoid (was getting some NaN problems # which I think might have been caused by the exponential function -> gradients blow up) s = K.sigmoid(K.dot(m, self.U_s) + self.b_s) if self.single_attention_param: h = h * K.repeat_elements(s, self.output_dim, axis=1) else: h = h * s return h, [h, c]
def step(self, x, states): h, [h, c] = self.layer.step(x, states) attention = states[4] m = self.attn_activation(K.dot(h, self.U_a) * attention + self.b_a) s = K.sigmoid(K.dot(m, self.U_s) + self.b_s) if self.single_attention_param: h = h * K.repeat_elements(s, self.layer.output_dim, axis=1) else: h = h * s return h, [h, c]
def weighted_with_attention(self, inputs): """Define a function for a lambda layer of a model.""" inp, inp_cont = inputs val = np.eye(self.max_sequence_length) kcon = K.constant(value=val, dtype='float32') diag = K.repeat_elements(inp_cont, self.max_sequence_length, 2) * kcon return K.batch_dot(diag, K.permute_dimensions(inp, (0,2,1)), axes=[1,2])
def attention_control(args): x,dense_2 = args find_att = K.reshape(x,(15,15,10)) find_att = K.transpose(find_att[:,:,:]) find_att = K.mean(find_att,axis=0) find_att = find_att/K.sum(find_att,axis=0) find_att = K.repeat_elements(find_att,32,axis=0) find_att = K.reshape(find_att,(1,32,15,15)) return find_att
def get_output(self, z): """ Return output using the given z z has shape (batch_size, z_dim) """ assert len(z.shape) == 2 assert self.z_dim == z.shape[1] total_values = np.prod(self.output_shape) batch_total = total_values * z.shape[0] z_rep = K.repeat_elements(K.expand_dims(z, 1), total_values, 1) coords_rep = K.repeat_elements( K.expand_dims(self.coordinates, 0), z.shape[0], 0) coords_rep = K.reshape(coords_rep, (batch_total, self.coordinates.shape[1])) z_rep = K.reshape(z_rep, (batch_total, z.shape[1])) # Add z and coords to first layer output = K.sin(K.dot(coords_rep, self.weights[0]) + self.biases[0] + K.dot(z_rep, self.weights[-1])) for i in range(1, len(self.layer_sizes)): output = K.tanh(K.dot(output, self.weights[i]) + self.biases[i]) # Using -2 for weights since -1 is z vector weight output = K.sigmoid(K.dot(output, self.weights[-2]) + self.biases[-1]) return K.reshape(output, (z.shape[0], *self.output_shape))
def setup_weights(self): """ Setup trainable weights and biases """ # Generate feature maps for each pixel self.kernel1 = self.init((10, self.filters_in, 5, 5)) self.coordinates_weights = self.init((4, 5)) # self.w1 = self.init((15, 20)) # self.b1 = self.b_init((20,)) self.w2 = self.init((15, self.filter_size**2)) self.b2 = self.b_init((self.filter_size**2, )) self.weights = [self.kernel1, self.coordinates_weights, self.w2] self.biases = [self.b2] # (rows * columns, 3) coordinates = get_coordinates_2D(self.input_shape) # (rows * columns, 5) coordinates = K.dot(coordinates, self.coordinates_weights) coordinates = K.sin(coordinates) # (1, 5, rows, columns) coordinates = K.reshape(coordinates, (1, 5, *self.input_shape)) # (batch, 5, rows, columns) coordinates = K.repeat_elements(coordinates, self.batch_size, 0) self.coordinates = coordinates
def setup_weights(self): """ Setup trainable weights and biases """ self.coordinates_weights = self.init((4, 10)) self.w2 = self.init((10, self.filter_size**2)) self.b2 = self.b_init((self.filter_size**2, )) self.weights = [self.coordinates_weights, self.w2] self.biases = [self.b2] # (rows * columns, 4) coordinates = get_coordinates_2D(self.input_shape) # (rows * columns, 10) coordinates = K.dot(coordinates, self.coordinates_weights) coordinates = K.sin(coordinates) coordinates = K.dot(coordinates, self.w2) + self.b2 # (1, fs**2, rows, columns) coordinates = K.reshape(coordinates, (1, self.filter_size**2, *self.input_shape)) # (batch, fs**2, rows, columns) coordinates = K.repeat_elements(coordinates, self.batch_size, 0) self.coordinates = coordinates
def MaskingHack(x): #mask = K.repeat_elements( K.any(x[:,:,0:-2], axis=-1), rep=x.shape[-1], axis=-1 ) mask = K.any(x[:,:,0:-2], axis=-1, keepdims=True) return x*mask
def step(self, x, states): h, params = self.layer.step(x, states) attention = states[-1] m = self.attn_activation(K.dot(h, self.U_a) * attention + self.b_a) s = K.sigmoid(K.dot(m, self.U_s) + self.b_s) if self.single_attention_param: h = h * K.repeat_elements(s, self.layer.units, axis=1) else: h = h * s return h, params
def step(self, x, states): h, [h, c] = super(AttentionLSTM, self).step(x, states) attention = states[4] m = self.attn_inner_activation(K.dot(h, self.U_a) * attention + self.b_a) # Intuitively it makes more sense to use a sigmoid (was getting some NaN problems # which I think might have been caused by the exponential function -> gradients blow up) s = self.attn_activation(K.dot(m, self.U_s) + self.b_s) if self.single_attention_param: h = h * K.repeat_elements(s, self.output_dim, axis=1) else: h = h * s return h, [h, c]
def get_output(self, train=False): X = self.get_input(train) if self.dim_ordering == 'th': output = K.repeat_elements(X, self.size[0], axis=2) output = K.repeat_elements(output, self.size[1], axis=3) elif self.dim_ordering == 'tf': output = K.repeat_elements(X, self.size[0], axis=1) output = K.repeat_elements(output, self.size[1], axis=2) else: raise Exception('Invalid dim_ordering: ' + self.dim_ordering) f = T.grad(T.sum(self._pool2d_layer.get_output(train)), wrt=self._pool2d_layer.get_input(train)) * output return f
def loss(y_true, y_pred): max_y = K.repeat_elements(K.expand_dims(K.repeat_elements(K.expand_dims(K.max(K.max(y_pred, axis=2), axis=2)), shape_r_gt, axis=-1)), shape_c_gt, axis=-1) return K.mean(K.square((y_pred / max_y) - y_true) / (1 - y_true + 0.1))
def call(self, x, mask=None): stride_row, stride_col = self.subsample nb_filter,_,_,_ = self.W_shape if self.dim_ordering == 'th': if K._backend == 'theano': x = x.reshape([x.shape[0],1,x.shape[1],x.shape[2],x.shape[3]]) # x has shape (batchsize,1,input_nbfilter,input_rows,input_cols) W = K.repeat_elements(self.W, self.shared_pool[0], axis=2) W = K.repeat_elements(W, self.shared_pool[1], axis=3) # W has shape (nb_filter , input_nbfilter,input_rows,input_cols) output = K.sum(x*W,axis = 2) # uses broadcasting, sums over input filters else: raise Exception('Invalid dim_ordering: ' + self.dim_ordering) if self.bias: if self.dim_ordering == 'th': b = K.repeat_elements(self.b, self.shared_pool[0], axis=1) b = K.repeat_elements(b, self.shared_pool[1], axis=2) output += K.reshape(b, (1, nb_filter, self.output_row, self.output_col)) elif self.dim_ordering == 'tf': output += K.reshape(self.b, (1, self.output_row, self.output_col, nb_filter)) else: raise Exception('Invalid dim_ordering: ' + self.dim_ordering) output = self.activation(output) return output
def call(self, x, mask=None): # b,n,f -> b,f via b,n broadcasted p_vectors = K.expand_dims(super(SoftAttention, self).call(x, mask), 2) expanded_p = K.repeat_elements(p_vectors, K.shape(x)[2], axis=2) attended = K.sum(expanded_p * x, axis=1) if self.return_probabilities: return [attended, p_vectors] return attended
def call(self, target_tensor, mask=None): last_dim = K.ndim(self.p_tensor) expanded_p = K.repeat_elements(K.expand_dims(self.p_tensor, last_dim), K.shape(target_tensor)[last_dim], axis=last_dim) return K.sum(expanded_p * target_tensor, axis=last_dim-1)
def build(self, input_shape): # The composition types are taken from Belinkov et al.'s TACL 2014 paper: # HC: Head-Child; HPC: Head-Prep-Child; HPCT: Head-Prep-Child-Ternary. assert self.composition_type in self.allowed_compositions, "Unknown composition type: %s" % self.composition_type if isinstance(input_shape[0], tuple): # This layer has multiple inputs (RelationPredictor). input_dim = input_shape[0][-1] input_length = input_shape[0][1] else: input_dim = input_shape[-1] input_length = input_shape[1] if self.proj_dim is None: self.proj_dim = int(input_dim / 2) if self.composition_type == 'HPCD': max_num_heads = input_length - 2 # Clipping number of distance based projection matrices to 5. num_head_projectors = min(max_num_heads, 5) self.proj_head = self.init((num_head_projectors, input_dim, self.proj_dim)) if max_num_heads > num_head_projectors: diff = max_num_heads - num_head_projectors farthest_head_proj = K.expand_dims(self.proj_head[0, :, :], dim=0) # (1, input_dim, proj_dim) # (diff, input_dim, proj_dim) tiled_farthest_head_proj = K.repeat_elements(farthest_head_proj, diff, 0) # (head_size, input_dim, proj_dim) self.dist_proj_head = K.concatenate([tiled_farthest_head_proj, self.proj_head], axis=0) else: self.dist_proj_head = self.proj_head else: self.proj_head = self.init((input_dim, self.proj_dim), name='{}_proj_head'.format(self.name)) self.proj_prep = self.init((input_dim, self.proj_dim), name='{}_proj_prep'.format(self.name)) self.proj_child = self.init((input_dim, self.proj_dim), name='{}_proj_child'.format(self.name)) self.trainable_weights = [self.proj_head, self.proj_prep, self.proj_child] self.hidden_layers = [] if self.num_hidden_layers > 0: # This means we have to pass the composed representation through an MLP instead of directly computing # scores. for i in range(self.num_hidden_layers): hidden_layer = self.init((self.proj_dim, self.proj_dim), name='%s_hidden_layer_%d' % (self.name, i)) self.hidden_layers.append(hidden_layer) self.trainable_weights.extend(self.hidden_layers) self.scorer = self.init((self.proj_dim, self.score_dim), name='{}_scorer'.format(self.name)) self.trainable_weights.append(self.scorer)
def step(self, inputs, states): h_tm1 = states[0] # previous memory #B_U = states[1] # dropout matrices for recurrent units #B_W = states[2] h_tm1a = K.dot(h_tm1, self.Wa) eij = K.dot(K.tanh(h_tm1a + self.ha), self.Va) eijs = K.repeat_elements(eij, self.h_dim, axis=1) #alphaij = K.softmax(eijs) # batchsize * lenh h batchsize * lenh * ndim #ci = K.permute_dimensions(K.permute_dimensions(self.h, [2,0,1]) * alphaij, [1,2,0]) #cisum = K.sum(ci, axis=1) cisum = eijs*self.h #print(K.shape(cisum), cisum.shape, ci.shape, self.h.shape, alphaij.shape, x.shape) zr = K.sigmoid(K.dot(inputs, self.Wzr) + K.dot(h_tm1, self.Uzr) + K.dot(cisum, self.Czr)) zi = zr[:, :self.units] ri = zr[:, self.units: 2 * self.units] si_ = K.tanh(K.dot(inputs, self.W) + K.dot(ri*h_tm1, self.U) + K.dot(cisum, self.C)) si = (1-zi) * h_tm1 + zi * si_ return si, [si] #h_tm1, [h_tm1] '''if self.consume_less == 'gpu': matrix_x = K.dot(x * B_W[0], self.W) + self.b matrix_inner = K.dot(h_tm1 * B_U[0], self.U[:, :2 * self.units]) x_z = matrix_x[:, :self.units] x_r = matrix_x[:, self.units: 2 * self.units] inner_z = matrix_inner[:, :self.units] inner_r = matrix_inner[:, self.units: 2 * self.units] z = self.inner_activation(x_z + inner_z) r = self.inner_activation(x_r + inner_r) x_h = matrix_x[:, 2 * self.units:] inner_h = K.dot(r * h_tm1 * B_U[0], self.U[:, 2 * self.units:]) hh = self.activation(x_h + inner_h) else: if self.consume_less == 'cpu': x_z = x[:, :self.units] x_r = x[:, self.units: 2 * self.units] x_h = x[:, 2 * self.units:] elif self.consume_less == 'mem': x_z = K.dot(x * B_W[0], self.W_z) + self.b_z x_r = K.dot(x * B_W[1], self.W_r) + self.b_r x_h = K.dot(x * B_W[2], self.W_h) + self.b_h else: raise ValueError('Unknown `consume_less` mode.') z = self.inner_activation(x_z + K.dot(h_tm1 * B_U[0], self.U_z)) r = self.inner_activation(x_r + K.dot(h_tm1 * B_U[1], self.U_r)) hh = self.activation(x_h + K.dot(r * h_tm1 * B_U[2], self.U_h)) h = z * h_tm1 + (1 - z) * hh return h, [h]'''
