我们从Python开源项目中，提取了以下12个代码示例，用于说明如何使用keras.backend.stack()。
def yolo_eval(yolo_outputs, image_shape, max_boxes=10, score_threshold=.6, iou_threshold=.5): """Evaluate YOLO model on given input batch and return filtered boxes.""" box_xy, box_wh, box_confidence, box_class_probs = yolo_outputs boxes = yolo_boxes_to_corners(box_xy, box_wh) boxes, scores, classes = yolo_filter_boxes(boxes, box_confidence, box_class_probs, threshold=score_threshold) # Scale boxes back to original image shape. height = image_shape[0] width = image_shape[1] image_dims = K.stack([height, width, height, width]) image_dims = K.reshape(image_dims, [1, 4]) boxes = boxes * image_dims max_boxes_tensor = K.variable(max_boxes, dtype='int32') K.get_session().run(tf.variables_initializer([max_boxes_tensor])) nms_index = tf.image.non_max_suppression(boxes, scores, max_boxes_tensor, iou_threshold=iou_threshold) boxes = K.gather(boxes, nms_index) scores = K.gather(scores, nms_index) classes = K.gather(classes, nms_index) return boxes, scores, classes
def time_distributed_dense(x, w, b=None, dropout=None, input_dim=None, units=None, timesteps=None): """Apply `y . w + b` for every temporal slice y of x. # Arguments x: input tensor. w: weight matrix. b: optional bias vector. dropout: wether to apply dropout (same dropout mask for every temporal slice of the input). input_dim: integer; optional dimensionality of the input. units: integer; optional dimensionality of the output. timesteps: integer; optional number of timesteps. # Returns Output tensor. """ if not input_dim: input_dim = K.shape(x)[2] if not timesteps: timesteps = K.shape(x)[1] if not units: units = K.shape(w)[1] if dropout is not None and 0. < dropout < 1.: # apply the same dropout pattern at every timestep ones = K.ones_like(K.reshape(x[:, 0, :], (-1, input_dim))) dropout_matrix = K.dropout(ones, dropout) expanded_dropout_matrix = K.repeat(dropout_matrix, timesteps) x = K.in_train_phase(x * expanded_dropout_matrix, x) # collapse time dimension and batch dimension together x = K.reshape(x, (-1, input_dim)) x = K.dot(x, w) if b: x += b # reshape to 3D tensor if K.backend() == 'tensorflow': x = K.reshape(x, K.stack([-1, timesteps, units])) x.set_shape([None, None, units]) else: x = K.reshape(x, (-1, timesteps, units)) return x
def _max_attentive_vectors(self, x2, cosine_matrix): """Max attentive vectors. Calculate max attentive vector for the entire sentence by picking the contextual embedding with the highest cosine similarity as the attentive vector. # Arguments x2: sequence vectors, (batch_size, x2_timesteps, embedding_size) cosine_matrix: cosine similarities matrix of x1 and x2, (batch_size, x1_timesteps, x2_timesteps) # Output shape (batch_size, x1_timesteps, embedding_size) """ # (batch_size, x1_timesteps) max_x2_step = K.argmax(cosine_matrix, axis=-1) embedding_size = K.int_shape(x2)[-1] timesteps = K.int_shape(max_x2_step)[-1] if timesteps is None: timesteps = K.shape(max_x2_step)[-1] # collapse time dimension and batch dimension together # collapse x2 to (batch_size * x2_timestep, embedding_size) x2 = K.reshape(x2, (-1, embedding_size)) # collapse max_x2_step to (batch_size * h1_timesteps) max_x2_step = K.reshape(max_x2_step, (-1,)) # (batch_size * x1_timesteps, embedding_size) max_x2 = K.gather(x2, max_x2_step) # reshape max_x2, (batch_size, x1_timesteps, embedding_size) attentive_vector = K.reshape(max_x2, K.stack([-1, timesteps, embedding_size])) return attentive_vector
def _time_distributed_multiply(self, x, w): """Element-wise multiply vector and weights. # Arguments x: sequence of hidden states, (batch_size, ?, embedding_size) w: weights of one matching strategy of one direction, (mp_dim, embedding_size) # Output shape (?, mp_dim, embedding_size) """ # dimension of vector n_dim = K.ndim(x) embedding_size = K.int_shape(x)[-1] timesteps = K.int_shape(x)[1] if timesteps is None: timesteps = K.shape(x)[1] # collapse time dimension and batch dimension together x = K.reshape(x, (-1, embedding_size)) # reshape to (?, 1, embedding_size) x = K.expand_dims(x, axis=1) # reshape weights to (1, mp_dim, embedding_size) w = K.expand_dims(w, axis=0) # element-wise multiply x = x * w # reshape to original shape if n_dim == 3: x = K.reshape(x, K.stack([-1, timesteps, self.mp_dim, embedding_size])) x.set_shape([None, None, None, embedding_size]) elif n_dim == 2: x = K.reshape(x, K.stack([-1, self.mp_dim, embedding_size])) x.set_shape([None, None, embedding_size]) return x
def call(self, inputs, output_shape=None): """ Seen on https://github.com/tensorflow/tensorflow/issues/2169 Replace with unpool op when/if issue merged Add theano backend """ updates, mask = inputs[0], inputs[1] with K.tf.variable_scope(self.name): mask = K.cast(mask, 'int32') input_shape = K.tf.shape(updates, out_type='int32') # calculation new shape if output_shape is None: output_shape = (input_shape[0], input_shape[1] * self.size[0], input_shape[2] * self.size[1], input_shape[3]) self.output_shape1 = output_shape # calculation indices for batch, height, width and feature maps one_like_mask = K.ones_like(mask, dtype='int32') batch_shape = K.concatenate([[input_shape[0]], [1], [1], [1]], axis=0) batch_range = K.reshape(K.tf.range(output_shape[0], dtype='int32'), shape=batch_shape) b = one_like_mask * batch_range y = mask // (output_shape[2] * output_shape[3]) x = (mask // output_shape[3]) % output_shape[2] feature_range = K.tf.range(output_shape[3], dtype='int32') f = one_like_mask * feature_range # transpose indices & reshape update values to one dimension updates_size = K.tf.size(updates) indices = K.transpose(K.reshape(K.stack([b, y, x, f]), [4, updates_size])) values = K.reshape(updates, [updates_size]) ret = K.tf.scatter_nd(indices, values, output_shape) return ret
def gram_matrix(x, norm_by_channels=False): ''' Returns the Gram matrix of the tensor x. ''' if K.ndim(x) == 3: features = K.batch_flatten(K.permute_dimensions(x, (2, 0, 1))) shape = K.shape(x) C, H, W = shape[0], shape[1], shape[2] gram = K.dot(features, K.transpose(features)) elif K.ndim(x) == 4: # Swap from (H, W, C) to (B, C, H, W) x = K.permute_dimensions(x, (0, 3, 1, 2)) shape = K.shape(x) B, C, H, W = shape[0], shape[1], shape[2], shape[3] # Reshape as a batch of 2D matrices with vectorized channels features = K.reshape(x, K.stack([B, C, H*W])) # This is a batch of Gram matrices (B, C, C). gram = K.batch_dot(features, features, axes=2) else: raise ValueError('The input tensor should be either a 3d (H, W, C) or 4d (B, H, W, C) tensor.') # Normalize the Gram matrix if norm_by_channels: denominator = C * H * W # Normalization from Johnson else: denominator = H * W # Normalization from Google gram = gram / K.cast(denominator, x.dtype) return gram
def test_keras_unstack_hack(): y_true_np = np.random.random([1, 3, 2]) y_true_np[:, :, 0] = 0 y_true_np[:, :, 1] = 1 y_true_keras = K.variable(y_true_np) y, u = wtte._keras_unstack_hack(y_true_keras) y_true_keras_new = K.stack([y, u], axis=-1) np.testing.assert_array_equal(K.eval(y_true_keras_new), y_true_np) # SANITY CHECK: Use pure Weibull data censored at C(ensoring point). # Should converge to the generating A(alpha) and B(eta) for each timestep
def yolo_eval(yolo_outputs, image_shape, max_boxes=10, score_threshold=.6, iou_threshold=.5): """Evaluate YOLO model on given input batch and return filtered boxes.""" box_xy, box_wh, box_confidence, box_class_probs = yolo_outputs boxes = yolo_boxes_to_corners(box_xy, box_wh) boxes, scores, classes = yolo_filter_boxes( boxes, box_confidence, box_class_probs, threshold=score_threshold) # Scale boxes back to original image shape. height = image_shape[0] width = image_shape[1] image_dims = K.stack([height, width, height, width]) image_dims = K.reshape(image_dims, [1, 4]) boxes = boxes * image_dims # TODO: Something must be done about this ugly hack! max_boxes_tensor = K.variable(max_boxes, dtype='int32') K.get_session().run(tf.variables_initializer([max_boxes_tensor])) nms_index = tf.image.non_max_suppression( boxes, scores, max_boxes_tensor, iou_threshold=iou_threshold) boxes = K.gather(boxes, nms_index) scores = K.gather(scores, nms_index) classes = K.gather(classes, nms_index) return boxes, scores, classes
def step(self, layer_input, states): # As a step function MUST return its regular output as the first element in the list of states, # we have _ here. _, M, weights_read_tm1, weights_write_tm1 = states[:4] # reshaping (TODO: figure out how save n-dimensional state) weights_read_tm1 = K.reshape(weights_read_tm1, (self.batch_size, self.read_heads, self.n_slots)) weights_write_tm1 = K.reshape(weights_write_tm1, (self.batch_size, self.write_heads, self.n_slots)) # We have the old memory M, and a read weighting w_read_tm1 calculated in the last # step. This is enough to calculate the read_vector we feed into the controller: memory_read_input = K.concatenate([self._read_from_memory(weights_read_tm1[:,i], M) for i in range(self.read_heads)]) # Now feed the controller and let it run a single step, implemented by calling the step function directly, # which we have to provide with the actual input from outside, the information we've read an the states which # are relevant to the controller. controller_output = self._run_controller(layer_input, memory_read_input) # We take the big chunk of unactivated controller output and subdivide it into actual output, reading and # writing instructions. Also specific activions for each parameter are applied. ntm_output, controller_instructions_read, controller_instructions_write = \ self._split_and_apply_activations(controller_output) # Now we want to write to the memory for each head. We have to be carefull about concurrency, otherwise there is # a chance the write heads will interact with each other in unintended ways! # We first calculate all the weights, then perform all the erasing and only after that the adding is done. # addressing: weights_write = [] for i in range(self.write_heads): write_head = controller_instructions_write[i] old_weight_vector = weights_write_tm1[:,i] weight_vector = self._get_weight_vector(M, old_weight_vector, *tuple(write_head[:5])) weights_write.append(weight_vector) # erasing: for i in range(self.write_heads): M = self._write_to_memory_erase(M, weights_write[i], controller_instructions_write[i][5]) # adding: for i in range(self.write_heads): M = self._write_to_memory_add(M, weights_write[i], controller_instructions_write[i][6]) # Only one thing left until this step is complete: Calculate the read weights we save in the state and use next # round: # As reading is side-effect-free, we dont have to worry about concurrency. weights_read = [] for i in range(self.read_heads): read_head = controller_instructions_read[i] old_weight_vector = weights_read_tm1[:,i] weight_vector = self._get_weight_vector(M, old_weight_vector, *read_head) weights_read.append(weight_vector) # M = tf.Print(M, [K.mean(M), K.max(M), K.min(M)], message="Memory overview") # Now lets pack up the state in a list and call it a day. return ntm_output, [ntm_output, M, K.stack(weights_read, axis=1), K.stack(weights_write, axis=1)]
def yolo_head(feats, anchors, num_classes): """Convert final layer features to bounding box parameters. Parameters ---------- feats : tensor Final convolutional layer features. anchors : array-like Anchor box widths and heights. num_classes : int Number of target classes. Returns ------- box_xy : tensor x, y box predictions adjusted by spatial location in conv layer. box_wh : tensor w, h box predictions adjusted by anchors and conv spatial resolution. box_conf : tensor Probability estimate for whether each box contains any object. box_class_pred : tensor Probability distribution estimate for each box over class labels. """ num_anchors = len(anchors) # Reshape to batch, height, width, num_anchors, box_params. anchors_tensor = K.reshape(K.variable(anchors), [1, 1, 1, num_anchors, 2]) # Dynamic implementation of conv dims for fully convolutional model. conv_dims = K.shape(feats)[1:3] # assuming channels last # In YOLO the height index is the inner most iteration. conv_height_index = K.arange(0, stop=conv_dims[0]) conv_width_index = K.arange(0, stop=conv_dims[1]) conv_height_index = K.tile(conv_height_index, [conv_dims[1]]) conv_width_index = K.tile(K.expand_dims(conv_width_index, 0), [conv_dims[0], 1]) conv_width_index = K.flatten(K.transpose(conv_width_index)) conv_index = K.transpose(K.stack([conv_height_index, conv_width_index])) conv_index = K.reshape(conv_index, [1, conv_dims[0], conv_dims[1], 1, 2]) conv_index = K.cast(conv_index, K.dtype(feats)) feats = K.reshape(feats, [-1, conv_dims[0], conv_dims[1], num_anchors, num_classes + 5]) conv_dims = K.cast(K.reshape(conv_dims, [1, 1, 1, 1, 2]), K.dtype(feats)) box_xy = K.sigmoid(feats[..., :2]) box_wh = K.exp(feats[..., 2:4]) box_confidence = K.sigmoid(feats[..., 4:5]) box_class_probs = K.softmax(feats[..., 5:]) # Adjust preditions to each spatial grid point and anchor size. # Note: YOLO iterates over height index before width index. box_xy = (box_xy + conv_index) / conv_dims box_wh = box_wh * anchors_tensor / conv_dims return box_xy, box_wh, box_confidence, box_class_probs
def _time_distributed_dense(x, w, b=None, dropout=None, input_dim=None, output_dim=None, timesteps=None, training=None): """Apply `y . w + b` for every temporal slice y of x. # Arguments x: input tensor. w: weight matrix. b: optional bias vector. dropout: wether to apply dropout (same dropout mask for every temporal slice of the input). input_dim: integer; optional dimensionality of the input. output_dim: integer; optional dimensionality of the output. timesteps: integer; optional number of timesteps. training: training phase tensor or boolean. # Returns Output tensor. """ if not input_dim: input_dim = K.shape(x)[2] if not timesteps: timesteps = K.shape(x)[1] if not output_dim: output_dim = K.shape(w)[1] if dropout is not None and 0. < dropout < 1.: # apply the same dropout pattern at every timestep ones = K.ones_like(K.reshape(x[:, 0, :], (-1, input_dim))) dropout_matrix = K.dropout(ones, dropout) expanded_dropout_matrix = K.repeat(dropout_matrix, timesteps) x = K.in_train_phase(x * expanded_dropout_matrix, x, training=training) # collapse time dimension and batch dimension together x = K.reshape(x, (-1, input_dim)) x = K.dot(x, w) if b is not None: x = K.bias_add(x, b) # reshape to 3D tensor if K.backend() == 'tensorflow': x = K.reshape(x, K.stack([-1, timesteps, output_dim])) x.set_shape([None, None, output_dim]) else: x = K.reshape(x, (-1, timesteps, output_dim)) return x
