python类scatter_nd()的实例源码

yolo.py 文件源码 项目:num-seq-recognizer 作者: gmlove 项目源码 文件源码 阅读 36 收藏 0 点赞 0 评论 0
def build_export_output(net_out, H, W, max_number_length, C, threshold):
  B, threshold, sprs_output_box_count = max_number_length, threshold, 100
  net_out = tf.reshape(net_out, [H, W, B, -1])
  boxes, boxes_scores, classes_probs = net_out[:, :, :, :4], net_out[:, :, :, 4], net_out[:, :, :, 5:]
  row = np.concatenate([np.ones([1, W, B], dtype=np.float32) * i for i in range(H)], axis=0)
  col = np.concatenate([np.ones([H, 1, B], dtype=np.float32) * i for i in range(W)], axis=1)
  anchors_w = np.concatenate([np.ones([H, W, 1], dtype=np.float32) * anchors[2 * i + 0] for i in range(B)], axis=2)
  anchors_h = np.concatenate([np.ones([H, W, 1], dtype=np.float32) * anchors[2 * i + 1] for i in range(B)], axis=2)
  with ops.name_scope(None, 'calc_boxes_coordinates'):
    boxes = tf.concat([
      tf.expand_dims((tf.sigmoid(boxes[:, :, :, 0]) + col) / W, 3),
      tf.expand_dims((tf.sigmoid(boxes[:, :, :, 1]) + row) / H, 3),
      tf.expand_dims(tf.exp(boxes[:, :, :, 2]) * anchors_w / W, 3),
      tf.expand_dims(tf.exp(boxes[:, :, :, 3]) * anchors_h / H, 3),
    ], axis=3)
    boxes = tf.cast(boxes, tf.float32)

  with ops.name_scope(None, 'calc_boxes_scores'):
    boxes_scores = tf.sigmoid(boxes_scores)
    boxes_scores = tf.nn.softmax(classes_probs) * tf.expand_dims(boxes_scores, 3)
    boxes_scores = boxes_scores * tf.cast(boxes_scores > threshold, tf.float32)
    boxes_scores = tf.cast(boxes_scores, tf.float32)

  with ops.name_scope(None, 'non_max_suppression'):
    boxes = tf.reshape(boxes, [H * W * B, 4])
    sprs_boxes, sprs_boxes_scores = [], []
    for i in range(C):
      box_scores = tf.reshape(boxes_scores[:, :, :, i], [H * W * B])
      sprs_boxes_indices = tf.image.non_max_suppression(boxes, box_scores, sprs_output_box_count, iou_threshold=0.4)
      box_scores = box_scores * tf.scatter_nd(
        tf.reshape(sprs_boxes_indices, [-1, 1]),
        tf.ones(tf.shape(sprs_boxes_indices), dtype=tf.float32), [H * W * B])
      sprs_boxes_scores.append(tf.reshape(box_scores, [H * W * B, 1]))

  with ops.name_scope(None, 'select_boxes'):
    sprs_boxes_scores = tf.concat(sprs_boxes_scores, axis=1)
    classes = tf.argmax(sprs_boxes_scores, axis=1)
    classes_probs = tf.reduce_max(sprs_boxes_scores, axis=1)

    selected_box_mask = classes_probs > threshold

    selected_classes = tf.boolean_mask(classes, selected_box_mask)
    selected_boxes = tf.boolean_mask(boxes, selected_box_mask)
    selected_classes_probs = tf.boolean_mask(classes_probs, selected_box_mask)
    lefts = selected_boxes[:, 0] - selected_boxes[:, 2] / 2
    lefts = tf.where(lefts < 0, tf.zeros(tf.shape(lefts)), lefts)
    selected_boxes = tf.concat([
      tf.expand_dims(lefts, 1),
      tf.expand_dims(selected_boxes[:, 1] - selected_boxes[:, 3] / 2, 1),
      tf.expand_dims(selected_boxes[:, 2], 1),
      tf.expand_dims(selected_boxes[:, 3], 1),
    ], axis=1)
    selected_lefts = selected_boxes[:, 0]

  with ops.name_scope(None, 'sort_boxes'):
    sorted_lefts, sorted_lefts_indices = tf.nn.top_k(selected_lefts * -1, tf.shape(selected_lefts)[0])

    sorted_classes = tf.gather(selected_classes, sorted_lefts_indices)
    sorted_boxes = tf.gather(selected_boxes, sorted_lefts_indices)
    sorted_classes_probs = tf.gather(selected_classes_probs, sorted_lefts_indices)
  return sorted_lefts * -1, sorted_boxes, sorted_classes, sorted_classes_probs
mobilenetdet.py 文件源码 项目:MobileNet 作者: Zehaos 项目源码 文件源码 阅读 29 收藏 0 点赞 0 评论 0
def encode_annos(image, labels, bboxes, anchors, num_classes):
  """Encode annotations for losses computations.
  All the output tensors have a fix shape(none dynamic dimention).

  Args:
    image: 4-D with shape `[H, W, C]`.
    b_labels: 2-D with shape `[num_bounding_boxes]`.
    b_bboxes: 3-D with shape `[num_bounding_boxes, 4]`. Scaled.
    anchors: 4-D tensor with shape `[fea_h, fea_w, num_anchors, 4]`

  Returns:
    input_mask: 2-D with shape `[num_anchors, 1]`, indicate which anchor to be used to cal loss.
    labels_input: 2-D with shape `[num_anchors, num_classes]`, one hot encode for every anchor.
    box_delta_input: 2-D with shape `[num_anchors, 4]`.
    box_input: 2-D with shape '[num_anchors, 4]'.
  """
  anchors_shape = anchors.get_shape().as_list()
  fea_h = anchors_shape[0]
  fea_w = anchors_shape[1]
  num_anchors = anchors_shape[2] * fea_h * fea_w
  anchors = tf.reshape(anchors, [num_anchors, 4])  # reshape anchors

  # Cal iou, find the target anchor
  _anchors = xywh_to_yxyx(anchors)
  ious, indices = batch_iou_fast(_anchors, bboxes)
  indices = tf.reshape(indices, shape=[-1, 1])

  target_anchors = tf.gather(anchors, indices)
  target_anchors = tf.squeeze(target_anchors, axis=1)
  delta = batch_delta(yxyx_to_xywh_(bboxes), target_anchors)

  # bbox
  box_input = tf.scatter_nd(
    indices,
    bboxes,
    shape=[num_anchors, 4]
  )
  # label
  labels_input = tf.scatter_nd(
    indices,
    tf.one_hot(labels, num_classes),
    shape=[num_anchors, num_classes]
  )
  # anchor mask
  onehot_anchor = tf.one_hot(indices, num_anchors)
  onehot_anchor = tf.squeeze(onehot_anchor, axis=1)
  print("indices shape:", indices.get_shape().as_list())
  print("one hot anchors shape:", onehot_anchor.get_shape().as_list())
  input_mask = tf.reduce_sum(onehot_anchor, axis=0)
  input_mask = tf.reshape(input_mask, shape=[-1, 1])
  # delta
  box_delta_input = tf.scatter_nd(
    indices,
    delta,
    shape=[num_anchors, 4]
  )

  return input_mask, labels_input, box_delta_input, box_input


# TODO(shizehao): align anchor center to the grid
model.py 文件源码 项目:windbag 作者: tongda 项目源码 文件源码 阅读 25 收藏 0 点赞 0 评论 0
def create_loss(final_outputs, answers, answer_lens):
  '''
  Final outputs of the decoder may have different length with
  target answer. So we should pad the outputs if the outputs
  are shorter than target answer, and pad the target answers
  if outputs are longer than answers.
  :param answer_lens:
   `Tensor` that representing length of answers
  :param final_outputs: the output of decoder
  :param answers: the target answers
  :return: tuple of loss_op and train_op
  '''
  with tf.variable_scope('loss') as scope:
    answsers = tf.transpose(answers, (1, 0))
    print("target_tensor[0]: ", answsers[0])
    print("final_outputs: ", final_outputs.get_shape())
    print("decoder_inputs_tensor: ", answsers.get_shape())

    answer_max_len = tf.reduce_max(answer_lens)
    output_len = tf.shape(final_outputs)[0]

    def loss_with_padded_outputs():
      indexes = [[0, 1]]
      values = tf.expand_dims(answer_max_len - output_len - 1, axis=0)
      # because rank of final outputs tensor is 3, so the shape is (3, 2)
      shape = [3, 2]
      paddings = tf.scatter_nd(indexes, values, shape)
      padded_outputs = tf.pad(final_outputs, paddings)
      return tf.nn.sparse_softmax_cross_entropy_with_logits(
        logits=padded_outputs, labels=answsers[1:])

    def loss_with_padded_answers():
      indexes = [[0, 1]]
      values = tf.expand_dims(output_len - answer_max_len + 1, axis=0)
      # because rank of answers tensor is 2, so the shape is (2, 2)
      shape = [2, 2]
      paddings = tf.scatter_nd(indexes, values, shape)
      padded_answer = tf.pad(answsers, paddings)
      return tf.nn.sparse_softmax_cross_entropy_with_logits(
        logits=final_outputs, labels=padded_answer[1:])

    losses = tf.cond(output_len < answer_max_len, loss_with_padded_outputs, loss_with_padded_answers)

    losses_length = tf.shape(losses)[0]
    loss_mask = tf.sequence_mask(
      tf.to_int32(answer_lens), losses_length)

    losses = losses * tf.transpose(tf.to_float(loss_mask), [1, 0])
    # self.loss = tf.reduce_mean(losses)
    loss = tf.reduce_sum(losses) / tf.to_float(tf.reduce_sum(answer_lens - 1))

  return loss
bluenet.py 文件源码 项目:tensor2tensor 作者: tensorflow 项目源码 文件源码 阅读 27 收藏 0 点赞 0 评论 0
def make_subseparable_kernel(kernel_size, input_channels, filters, separability,
                             kernel_initializer, kernel_regularizer):
  """Make a kernel to do subseparable convolution wiht  `tf.nn.conv2d`.

  Args:
    kernel_size: (height, width) tuple.
    input_channels: Number of input channels.
    filters: Number of output channels.
    separability: Integer denoting separability.
    kernel_initializer: Initializer to use for the kernel.
    kernel_regularizer: Regularizer to use for the kernel.

  Returns:
    A 4D tensor.
  """
  if separability == 1:
    # Non-separable convolution
    return tf.get_variable(
        "kernel",
        kernel_size + (input_channels, filters),
        initializer=kernel_initializer,
        regularizer=kernel_regularizer)

  elif separability == 0 or separability == -1:
    # Separable convolution
    # TODO(rshin): Check initialization is as expected, as these are not 4D.
    depthwise_kernel = tf.get_variable(
        "depthwise_kernel",
        kernel_size + (input_channels,),
        initializer=kernel_initializer,
        regularizer=kernel_regularizer)

    pointwise_kernel = tf.get_variable(
        "pointwise_kernel", (input_channels, filters),
        initializer=kernel_initializer,
        regularizer=kernel_regularizer)

    expanded_depthwise_kernel = tf.transpose(
        tf.scatter_nd(
            indices=tf.tile(
                tf.expand_dims(tf.range(0, input_channels), axis=1), [1, 2]),
            updates=tf.transpose(depthwise_kernel, (2, 0, 1)),
            shape=(input_channels, input_channels) + kernel_size), (2, 3, 0, 1))

    return tf.reshape(
        tf.matmul(
            tf.reshape(expanded_depthwise_kernel, (-1, input_channels)),
            pointwise_kernel), kernel_size + (input_channels, filters))

  elif separability >= 2:
    assert filters % separability == 0, (filters, separability)
    assert input_channels % separability == 0, (filters, separability)

    raise NotImplementedError

  elif separability <= -2:
    separability *= -1
    assert filters % separability == 0, (filters, separability)
    assert input_channels % separability == 0, (filters, separability)

    raise NotImplementedError
tensorflow_backend.py 文件源码 项目:keras-rcnn 作者: broadinstitute 项目源码 文件源码 阅读 29 收藏 0 点赞 0 评论 0
def scatter_add_tensor(ref, indices, updates, name=None):
    """
    Adds sparse updates to a variable reference.

    This operation outputs ref after the update is done. This makes it
    easier to chain operations that need to use the reset value.

    Duplicate indices: if multiple indices reference the same location,
    their contributions add.

    Requires updates.shape = indices.shape + ref.shape[1:].

    :param ref: A Tensor. Must be one of the following types: float32,
    float64, int64, int32, uint8, uint16, int16, int8, complex64, complex128,
    qint8, quint8, qint32, half.

    :param indices: A Tensor. Must be one of the following types: int32,
    int64. A tensor of indices into the first dimension of ref.

    :param updates: A Tensor. Must have the same dtype as ref. A tensor of
    updated values to add to ref

    :param name: A name for the operation (optional).

    :return: Same as ref. Returned as a convenience for operations that want
    to use the updated values after the update is done.
    """
    with tensorflow.name_scope(name, 'scatter_add_tensor', [ref, indices, updates]) as scope:
        ref = tensorflow.convert_to_tensor(ref, name='ref')

        indices = tensorflow.convert_to_tensor(indices, name='indices')

        updates = tensorflow.convert_to_tensor(updates, name='updates')

        ref_shape = tensorflow.shape(ref, out_type=indices.dtype, name='ref_shape')

        scattered_updates = tensorflow.scatter_nd(indices, updates, ref_shape, name='scattered_updates')

        with tensorflow.control_dependencies([tensorflow.assert_equal(ref_shape, tensorflow.shape(scattered_updates, out_type=indices.dtype))]):
            output = tensorflow.add(ref, scattered_updates, name=scope)

        return output


问题


面经


文章

微信
公众号

扫码关注公众号