luci::sinf::Algorithm Class Reference

#include <CircleShapeInference.h>

Collaboration diagram for luci::sinf::Algorithm:

Public Member Functions
loco::TensorShape	visit (const luci::CircleNode *node) final
	Default fallback.
loco::TensorShape	visit (const luci::CircleAdd *node) final
loco::TensorShape	visit (const luci::CircleBatchMatMul *node) final
loco::TensorShape	visit (const luci::CircleConcatenation *node) final
loco::TensorShape	visit (const luci::CircleDiv *node) final
loco::TensorShape	visit (const luci::CircleFullyConnected *node) final
loco::TensorShape	visit (const luci::CircleLogistic *node) final
loco::TensorShape	visit (const luci::CircleMul *node) final
loco::TensorShape	visit (const luci::CircleNeg *node) final
loco::TensorShape	visit (const luci::CirclePad *node) final
loco::TensorShape	visit (const luci::CircleQuantize *node) final
loco::TensorShape	visit (const luci::CircleRange *node) final
loco::TensorShape	visit (const luci::CircleReshape *node) final
loco::TensorShape	visit (const luci::CircleRsqrt *node) final
loco::TensorShape	visit (const luci::CircleSoftmax *node) final
loco::TensorShape	visit (const luci::CircleStridedSlice *node) final
loco::TensorShape	visit (const luci::CircleIfOut *node) final
Public Member Functions inherited from luci::CircleNodeVisitor< loco::TensorShape >
virtual	~CircleNodeVisitor ()=default
Public Member Functions inherited from luci::CircleNodeVisitorBase< T >
virtual	~CircleNodeVisitorBase ()=default

Detailed Description

Definition at line 38 of file CircleShapeInference.h.

Member Function Documentation

visit() [1/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleAdd *  node )

final

Definition at line 40 of file CircleAdd.cpp.

{
  const auto x = loco::must_cast<luci::CircleNode *>(node->x());
  const auto y = loco::must_cast<luci::CircleNode *>(node->y());
 
  const auto x_shape = circle_shape(x);
  const auto y_shape = circle_shape(y);
 
  return broadcast_shape(x_shape, y_shape);
}

References luci::sinf::broadcast_shape(), luci::sinf::circle_shape(), luci::CircleAdd::x(), and luci::CircleAdd::y().

visit() [2/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleBatchMatMul *  node )

final

Definition at line 84 of file CircleBatchMatMul.cpp.

{
  const auto x = loco::must_cast<CircleNode *>(node->x());
  const auto y = loco::must_cast<CircleNode *>(node->y());
 
  const auto x_shape = circle_shape(x);
  const auto y_shape = circle_shape(y);
 
  uint32_t x_rank = x_shape.rank();
  uint32_t y_rank = y_shape.rank();
 
  // throw internal exception if condition not met
  throw_unless(x_rank >= 2, "x_rank shoud be >= 2");
  throw_unless(y_rank >= 2, "y_rank shoud be >= 2");
  throw_unless((not contain_zero(x_shape)), "x_shape should NOT have 0");
  throw_unless((not contain_zero(y_shape)), "y_shape should NOT have 0");
 
  // BatchMatMul shape inference rule works with two-part
  //
  // 1) Batch dimensions part
  //    - Batch dimensions correspond to the input_shape[:-2]
  //    - General broadcast rules are used to infer the shape of the output batch
  //
  // 2) Contracting dimensions part
  //    - Contracting dimensions correspond to the input_shape[-2:]
  //    - General matrix multiplication shape inference applied for this part,
  //      which means '(x_lhs, x_rhs) x (y_lhs, y_rhs) => (x_lhs, y_rhs)'
 
  uint32_t max_rank = x_rank > y_rank ? x_rank : y_rank;
  loco::TensorShape output_shape;
  output_shape.rank(max_rank);
 
  // broadcast in the batch dimensions
  if (x_rank > 2 || y_rank > 2)
  {
    const auto x_batch_dims = remove_last_two(x_shape);
    const auto y_batch_dims = remove_last_two(y_shape);
 
    const auto o_batch_dims = sinf::broadcast_shape(x_batch_dims, y_batch_dims);
 
    const auto o_batch_rank = o_batch_dims.rank();
    for (uint i = 0u; i < o_batch_rank; ++i)
    {
      output_shape.dim(i) = o_batch_dims.dim(i);
    }
  }
 
  // shape inference in contracting dimensions
  const auto adj_x = node->adj_x();
  const auto adj_y = node->adj_y();
 
  loco::Dimension x_lhs = adj_x ? x_shape.dim(x_rank - 1) : x_shape.dim(x_rank - 2);
  loco::Dimension x_rhs = adj_x ? x_shape.dim(x_rank - 2) : x_shape.dim(x_rank - 1);
  loco::Dimension y_lhs = adj_y ? y_shape.dim(y_rank - 1) : y_shape.dim(y_rank - 2);
  loco::Dimension y_rhs = adj_y ? y_shape.dim(y_rank - 2) : y_shape.dim(y_rank - 1);
 
  if (x_rhs.known() && y_lhs.known() && not(x_rhs == y_lhs))
    INTERNAL_EXN("x_rhs and y_lhs should be same");
 
  uint32_t out_rank = output_shape.rank();
  output_shape.dim(out_rank - 2) = x_lhs;
  output_shape.dim(out_rank - 1) = y_rhs;
 
  return output_shape;
}

References luci::CircleBatchMatMul::adj_x(), luci::CircleBatchMatMul::adj_y(), luci::sinf::broadcast_shape(), luci::sinf::circle_shape(), INTERNAL_EXN, loco::Dimension::known(), output_shape, luci::CircleBatchMatMul::x(), and luci::CircleBatchMatMul::y().

visit() [3/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleConcatenation *  node )

final

Definition at line 43 of file CircleConcatenation.cpp.

{
  // TODO Support when CircleConcatenation has 0 input
  assert(node->numValues() > 0);
 
  auto first_shape = luci::shape_get(node->values(0)).as<loco::TensorShape>();
  auto axis = node->axis();
  if (axis < 0)
    axis += first_shape.rank();
 
  assert(0 <= axis);
  assert(first_shape.rank() > static_cast<uint32_t>(axis));
 
  loco::TensorShape output_shape;
 
  output_shape.rank(first_shape.rank());
  for (uint32_t i = 0; i < output_shape.rank(); ++i)
    output_shape.dim(i) = first_shape.dim(i);
 
  for (uint32_t i = 1; i < node->numValues(); ++i)
  {
    auto input_shape = luci::shape_get(node->values(i)).as<loco::TensorShape>();
    if (input_shape.rank() != output_shape.rank())
      INTERNAL_EXN_V("Input has incompatible shape", node->name());
 
    for (uint32_t j = 0; j < output_shape.rank(); ++j)
    {
      if (j == static_cast<uint32_t>(axis))
      {
        if (output_shape.dim(j).known() and input_shape.dim(j).known())
        {
          output_shape.dim(j) = output_shape.dim(j).value() + input_shape.dim(j).value();
        }
        else
        {
          // If any of inputs is unknown, just mark it as unknown.
          output_shape.dim(j).unset();
        }
      }
      else
      {
        if (output_shape.dim(j).known() and input_shape.dim(j).known())
        {
          if (output_shape.dim(j).value() != input_shape.dim(j).value())
          {
            INTERNAL_EXN_V("Input has incompatible shape.", node->name());
          }
        }
        else
        {
          if (input_shape.dim(j).known())
          {
            assert(not output_shape.dim(j).known()); // FIX_ME_UNLESS
            output_shape.dim(j) = input_shape.dim(j);
          }
          // For unknown input_shape, leave output_shape as-is
        }
      }
    }
  }
 
  return output_shape;
}

References loco::NodeShape::as(), luci::CircleConcatenation::axis(), INTERNAL_EXN_V, luci::CircleNode::name(), luci::CircleConcatenation::numValues(), output_shape, loco::TensorShape::rank(), luci::shape_get(), and luci::CircleConcatenation::values().

visit() [4/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleDiv *  node )

final

Definition at line 40 of file CircleDiv.cpp.

{
  const auto x = loco::must_cast<luci::CircleNode *>(node->x());
  const auto y = loco::must_cast<luci::CircleNode *>(node->y());
 
  const auto x_shape = circle_shape(x);
  const auto y_shape = circle_shape(y);
 
  auto output_shape = broadcast_shape(x_shape, y_shape);
 
  return output_shape;
}

References luci::sinf::broadcast_shape(), luci::sinf::circle_shape(), output_shape, luci::CircleDiv::x(), and luci::CircleDiv::y().

visit() [5/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleFullyConnected *  node )

final

Definition at line 46 of file CircleFullyConnected.cpp.

{
  auto input_shape = circle_shape(loco::must_cast<CircleNode *>(node->input()));
  auto weights_shape = circle_shape(loco::must_cast<CircleNode *>(node->weights()));
 
  loco::TensorShape out_shape;
 
  // NOTE Some recipes in some repositories are using rank 4 input for FullyConnected.
  //      Until they are all fixed, disable following assert.
  // TODO Enable following assert after related fixes are applied
  // https://github.com/tensorflow/tensorflow/blob/ea33c1e7a25d8025e8ee405ad8ab7be261798d76/tensorflow/lite/kernels/fully_connected.cc#L194
  // LUCI_ASSERT(input_shape.rank() == 2 || input_shape.rank() == 3,
  //             "Input rank of FullyConnected should be 2 or 3");
 
  // https://github.com/tensorflow/tensorflow/blob/ea33c1e7a25d8025e8ee405ad8ab7be261798d76/tensorflow/lite/kernels/fully_connected.cc#L225
  LUCI_ASSERT(weights_shape.rank() == 2, "Weights of FullyConnected should be 2");
  LUCI_ASSERT(weights_shape.dim(0).known() && weights_shape.dim(1).known(),
              "Weights of FullyConnected should be known")
  // https://github.com/tensorflow/tensorflow/blob/ea33c1e7a25d8025e8ee405ad8ab7be261798d76/tensorflow/lite/kernels/fully_connected.cc#L353-L367
 
  /*
   * **Pre-conditions:**
   *    input_shape.rank() <= 4
   *      * remark: TFLite allows <=3 ranks, but there are rank 4 input recipes in ONE
   *    weights_shape.rank() == 2 and all dimensions are known.
   *    When runtime(input_shape[-1] and weights_shape[-1] are both known), it should be same value.
   *
   * **Shape Inference Rule:**
   *    **Input Shape:**
   *      input_shape : (A, B, C, D)
   *      weights_shape : (E, F)
   *      A, B, C, D are "positive numbers" or "unknown".
   *      E, F are always "positive numbers".
   *
   *    **Output Shape:**
   *      If keep_dims = True : (A, B, C, E)
   *      If keep_dims = False : (G, E)
   *       * G = unknown (if any of A, B, or C is unknown.)
   *       * G = A * B * C  (otherwise.)
   */
 
  if (node->keep_num_dims())
  {
    out_shape.rank(input_shape.rank());
    for (uint32_t i = 0; i < input_shape.rank(); ++i)
      out_shape.dim(i) = input_shape.dim(i);
    out_shape.dim(out_shape.rank() - 1) = weights_shape.dim(0);
  }
  else
  {
    bool is_dynamic_shape = false;
 
    for (uint32_t i = 0; i < input_shape.rank() - 1; i++)
    {
      if (not input_shape.dim(i).known())
      {
        is_dynamic_shape = true;
        break;
      }
    }
 
    uint32_t batch_size = 1;
 
    for (uint32_t i = 0; i < input_shape.rank() - 1; i++)
    {
      batch_size *= input_shape.dim(i).value();
    }
 
    out_shape.rank(2);
    if (is_dynamic_shape)
      out_shape.dim(0).unset();
    else
      out_shape.dim(0) = batch_size;
    out_shape.dim(1) = weights_shape.dim(0);
  }
 
  return out_shape;
}

References luci::sinf::circle_shape(), loco::TensorShape::dim(), luci::CircleFullyConnected::input(), luci::CircleFullyConnected::keep_num_dims(), LUCI_ASSERT, loco::TensorShape::rank(), loco::Dimension::unset(), loco::Dimension::value(), and luci::CircleFullyConnected::weights().

visit() [6/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleIfOut *  node )

final

Definition at line 79 of file CircleIfOut.cpp.

{
  auto graphs = get_out_graphs(node);
  assert(*graphs.then_graph_output->shape() == *graphs.else_graph_output->shape());
  return *graphs.then_graph_output->shape();
}

visit() [7/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleLogistic *  node )

final

Definition at line 33 of file CircleLogistic.cpp.

{
  const auto input_x = loco::must_cast<luci::CircleNode *>(node->x());
  const auto input_shape = circle_shape(input_x);
  return input_shape;
}

References luci::sinf::circle_shape(), and luci::CircleLogistic::x().

visit() [8/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleMul *  node )

final

Definition at line 39 of file CircleMul.cpp.

{
  const auto x = loco::must_cast<luci::CircleNode *>(node->x());
  const auto y = loco::must_cast<luci::CircleNode *>(node->y());
 
  const auto x_shape = circle_shape(x);
  const auto y_shape = circle_shape(y);
 
  return broadcast_shape(x_shape, y_shape);
}

References luci::sinf::broadcast_shape(), luci::sinf::circle_shape(), luci::CircleMul::x(), and luci::CircleMul::y().

visit() [9/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleNeg *  node )

final

Definition at line 32 of file CircleNeg.cpp.

{
  const auto input_x = loco::must_cast<CircleNode *>(node->x());
  const auto input_shape = circle_shape(input_x);
  return input_shape;
}

References luci::sinf::circle_shape(), and luci::CircleNeg::x().

visit() [10/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleNode *  )

inlinefinalvirtual

Default fallback.

Reimplemented from luci::CircleNodeVisitor< loco::TensorShape >.

Definition at line 42 of file CircleShapeInference.h.

  {
    loco::NodeShape shape;
    luci::CircleShapeInferenceRule().infer(node, shape);
    return shape.as<loco::TensorShape>();
  }

References loco::NodeShape::as(), and luci::CircleShapeInferenceRule::infer().

visit() [11/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CirclePad *  node )

final

Definition at line 33 of file CirclePad.cpp.

{
  auto paddings = loco::must_cast<const luci::CircleNode *>(node->paddings());
  auto circle_input = loco::must_cast<const luci::CircleNode *>(node->input());
  auto input_shape = circle_shape(circle_input);
  return pad_shape(input_shape, paddings);
}

References luci::sinf::circle_shape(), luci::CirclePad::input(), luci::sinf::pad_shape(), and luci::CirclePad::paddings().

visit() [12/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleQuantize *  node )

final

Definition at line 33 of file CircleQuantize.cpp.

{
  const auto input = loco::must_cast<CircleNode *>(node->input());
  const auto input_shape = circle_shape(input);
  return input_shape;
}

References luci::sinf::circle_shape(), and luci::CircleQuantize::input().

visit() [13/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleRange *  node )

final

Definition at line 35 of file CircleRange.cpp.

{
  loco::TensorShape output_shape;
  output_shape.rank(1);
 
  auto start_node = dynamic_cast<luci::CircleConst *>(node->start());
  auto limit_node = dynamic_cast<luci::CircleConst *>(node->limit());
  auto delta_node = dynamic_cast<luci::CircleConst *>(node->delta());
 
  if (start_node == nullptr || limit_node == nullptr || delta_node == nullptr)
  {
    return output_shape;
  }
 
  double start = 0, limit = 0, delta = 0;
 
#define GET_RANGE_PARAM(DT)         \
  start = start_node->scalar<DT>(); \
  limit = limit_node->scalar<DT>(); \
  delta = delta_node->scalar<DT>();
 
  switch (start_node->dtype())
  {
    case loco::DataType::FLOAT32:
      GET_RANGE_PARAM(loco::DataType::FLOAT32)
      break;
    case loco::DataType::S32:
      GET_RANGE_PARAM(loco::DataType::S32)
      break;
    default:
      INTERNAL_EXN("Range data type not supported");
  }
 
#undef GET_RANGE_PARAM
 
  if (delta == 0)
    INTERNAL_EXN("Delta can not be zero");
 
  /*
   * Pre-condition
   *    'limit - start' and 'delta' have the same sign.
   *       c1. '(limit - start) >= 0' -> 'delta > 0'
   *       c2. '(limit - start) < 0' -> 'delta < 0'
   * https://github.com/tensorflow/tensorflow/blob/da82fa9/tensorflow/lite/kernels/range.cc#L49-L50
   */
  assert((start >= limit && delta < 0) || (start <= limit && delta > 0));
  output_shape.dim(0) = ceil((limit - start) / delta);
 
  return output_shape;
}

References luci::CircleRange::delta(), GET_RANGE_PARAM, INTERNAL_EXN, luci::CircleRange::limit(), output_shape, and luci::CircleRange::start().

visit() [14/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleReshape *  node )

final

Definition at line 70 of file CircleReshape.cpp.

{
  LOGGER(l);
 
  const loco::DataType S32 = loco::DataType::S32;
 
  bool is_static_shape = true;
 
  loco::TensorShape shape_by_input;
  {
    LUCI_ASSERT(node->shape(), "2nd input shape() should not be nullptr");
 
    // Only support node's shape() is CircleConst with S32
    // TODO support other node with other types
    auto const_shape_node = dynamic_cast<luci::CircleConst *>(node->shape());
    if (const_shape_node != nullptr)
    {
      LUCI_ASSERT(const_shape_node->dtype() == S32, "Only support int32 CircleConst");
 
      shape_by_input.rank(const_shape_node->size<S32>());
 
      for (uint32_t axis = 0; axis < shape_by_input.rank(); ++axis)
      {
        if (const_shape_node->at<S32>(axis) < 0)
        {
          shape_by_input.dim(axis).unset();
        }
        else if (const_shape_node->at<S32>(axis) == 0)
        {
          const auto node_tensor = loco::must_cast<luci::CircleNode *>(node->tensor());
          // set dim value to input
          if (node_tensor->shape_status() == luci::ShapeStatus::VALID && axis < node_tensor->rank())
            shape_by_input.dim(axis) = node_tensor->dim(axis);
          else
          {
            // stop to check if this case exist for debugging
            INTERNAL_EXN("Check Reshape shape with 0");
          }
        }
        else
        {
          shape_by_input.dim(axis).set(const_shape_node->at<S32>(axis));
        }
        // check valid or stop for debugging
        LUCI_ASSERT(shape_by_input.dim(axis).value() > 0 || !shape_by_input.dim(axis).known(),
                    "Reshape infer shape is invalid.");
      }
    }
    else
    {
      // NOTE assumption is that `shape` and `newShape` having same value.
      // for non-existing `shape`, we can use `newShape` if it's valid
      auto new_shape = node->newShape();
      auto rank = new_shape->rank();
      auto shape_dummy = dynamic_cast<luci::CircleOutputDummy *>(node->shape());
      if (shape_dummy && rank > 0)
      {
        is_static_shape = true;
        shape_by_input.rank(rank);
        for (uint32_t i = 0; i < rank; ++i)
        {
          if (new_shape->dim(i) > 0)
            shape_by_input.dim(i) = static_cast<uint32_t>(new_shape->dim(i));
          else
          {
            is_static_shape = false;
            shape_by_input.dim(i).unset();
          }
        }
      }
      else
      {
        auto shape_node = loco::must_cast<luci::CircleNode *>(node->shape());
        assert(shape_node->rank() == 1);
        // shape_node tensor values will provide new shape, like [2, 3, 4]
        auto num_elements = shape_node->dim(0).value(); // above example will give 3
        shape_by_input.rank(num_elements);
        is_static_shape = false;
      }
    }
  }
 
  loco::TensorShape shape_by_attr;
  {
    shape_by_attr.rank(node->newShape()->rank());
 
    for (uint32_t axis = 0; axis < shape_by_attr.rank(); ++axis)
    {
      shape_by_attr.dim(axis) = node->newShape()->dim(axis);
    }
  }
 
  if (!(shape_by_input == shape_by_attr))
  {
    INFO(l) << "CircleReshape: Two new shape information mismatched : " << std::endl;
    INFO(l) << "   shape_by_input : " << shape_by_input << std::endl;
    INFO(l) << "   shape_by_attr : " << shape_by_attr << std::endl;
  }
 
  loco::TensorShape output_shape = shape_by_input;
 
  // One of the dimensions can have special value -1, meaning its actual value should be inferred.
  const auto input = loco::must_cast<luci::CircleNode *>(node->tensor());
  const auto input_shape = circle_shape(input);
  uint32_t input_element_count = 1;
  uint32_t output_element_count = 1;
  uint32_t unknown_dim_index = UINT32_MAX;
  for (uint32_t i = 0; i < input_shape.rank(); ++i)
  {
    if (input_shape.dim(i).known())
      input_element_count *= input_shape.dim(i).value();
    else
      is_static_shape = false;
  }
 
  if (is_static_shape)
  {
    for (uint32_t dim_index = 0; dim_index < output_shape.rank(); ++dim_index)
    {
      uint32_t dim_value = output_shape.dim(dim_index).value();
      if (not output_shape.dim(dim_index).known())
      {
        LUCI_ASSERT(unknown_dim_index == UINT32_MAX, "More than one unknown dimension");
        unknown_dim_index = dim_index;
      }
      else
      {
        if (!dim_value)
        {
          // refer https://github.com/Samsung/ONE/issues/14074#issuecomment-2370795003
          // set dim value to follow input
          if (dim_index < input_shape.rank())
            dim_value = input_shape.dim(dim_index).value();
          else
          {
            // stop to check if this case exist for debugging
            INTERNAL_EXN("Check Reshape shape with 0");
          }
        }
        output_element_count *= dim_value;
      }
    }
    if (unknown_dim_index != UINT32_MAX)
    {
      output_shape.dim(unknown_dim_index) = input_element_count / output_element_count;
    }
  }
 
  return output_shape;
}

References luci::sinf::circle_shape(), loco::TensorShape::dim(), luci::CircleReshape::Shape::dim(), INFO, INTERNAL_EXN, loco::Dimension::known(), LOGGER, LUCI_ASSERT, luci::CircleReshape::newShape(), output_shape, loco::TensorShape::rank(), luci::CircleReshape::Shape::rank(), luci::sinf::S32, loco::Dimension::set(), luci::CircleReshape::shape(), luci::CircleReshape::tensor(), loco::Dimension::unset(), luci::VALID, and loco::Dimension::value().

visit() [15/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleRsqrt *  node )

final

Definition at line 33 of file CircleRsqrt.cpp.

{
  const auto input_x = loco::must_cast<CircleNode *>(node->x());
  const auto input_shape = circle_shape(input_x);
  return input_shape;
}

References luci::sinf::circle_shape(), and luci::CircleRsqrt::x().

visit() [16/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleSoftmax *  node )

final

Definition at line 36 of file CircleSoftmax.cpp.

{
  const auto logits = loco::must_cast<luci::CircleNode *>(node->logits());
 
  return sinf::circle_shape(logits);
}

References luci::sinf::circle_shape(), and luci::CircleSoftmax::logits().

visit() [17/17]

loco::TensorShape luci::sinf::Algorithm::visit ( const luci::CircleStridedSlice *  node )

final

Definition at line 385 of file CircleStridedSlice.cpp.

{
  loco::TensorShape output_shape;
 
  auto input_node = loco::must_cast<luci::CircleNode *>(node->input());
 
  auto begin_node = loco::must_cast<luci::CircleNode *>(node->begin());
  auto end_node = loco::must_cast<luci::CircleNode *>(node->end());
  auto strides_node = loco::must_cast<luci::CircleNode *>(node->strides());
 
  LUCI_ASSERT(begin_node->dtype() == S32, "Only support S32 for begin_node");
  LUCI_ASSERT(end_node->dtype() == S32, "Only support S32 for end_node");
  LUCI_ASSERT(strides_node->dtype() == S32, "Only support S32 for strides_node");
 
  LUCI_ASSERT(begin_node->rank() == 1, "Only support rank 1 for begin_node");
  LUCI_ASSERT(end_node->rank() == 1, "Only support rank 1 for end_node");
  LUCI_ASSERT(strides_node->rank() == 1, "Only support rank 1 for strides_node");
 
  auto begin_const = dynamic_cast<luci::CircleConst *>(node->begin());
  auto end_const = dynamic_cast<luci::CircleConst *>(node->end());
  auto strides_const = dynamic_cast<luci::CircleConst *>(node->strides());
  // TODO support non-const strides_node
  if (strides_const == nullptr)
  {
    INTERNAL_EXN("StridedSlice strides node is not Constant");
  }
  if (begin_const == nullptr || end_const == nullptr)
  {
    // The dimensions of the output shape are all set to unknown.
    output_shape.rank(input_node->rank());
    return output_shape;
  }
 
  loco::TensorShape input_shape = circle_shape(input_node);
 
  assert(begin_const->size<S32>() <= input_shape.rank());
  assert(end_const->size<S32>() <= input_shape.rank());
  assert(strides_const->size<S32>() <= input_shape.rank());
 
  StridedSliceContext op_context(node);
  auto op_params = BuildStridedSliceParams(&op_context);
  auto &effective_input_shape = op_context.effective_input_shape;
  std::vector<int64_t> output_shape_vector;
  std::vector<bool> output_known_vector;
 
  for (int32_t idx = effective_input_shape.rank() - 1; idx >= 0; --idx)
  {
    int32_t stride = op_params.strides[idx];
    LUCI_ASSERT(stride != 0, "stride value has to be non-zero");
 
    int64_t begin = StartForAxis(op_params, effective_input_shape, idx);
    int64_t end = StopForAxis(op_params, effective_input_shape, idx, begin);
 
    // When shrinking an axis, the end position does not matter (and can be
    // incorrect when negative indexing is used, see Issue #19260). Always use
    // begin + 1 to generate a length 1 slice, since begin has
    // already been adjusted for negative indices by GetBeginValueAtIndex.
    const bool shrink_axis = op_params.shrink_axis_mask & (1 << idx);
    if (shrink_axis)
    {
      end = begin + 1;
    }
 
    // This is valid for both positive and negative strides
    int64_t dim_shape = std::ceil((end - begin) / static_cast<float>(stride));
    dim_shape = dim_shape < 0 ? 0 : dim_shape;
    if (!shrink_axis)
    {
      output_shape_vector.push_back(dim_shape);
      output_known_vector.push_back(effective_input_shape.dim(idx).known());
    }
  }
 
  auto shape_size = output_shape_vector.size();
  output_shape.rank(shape_size);
  for (uint32_t idx = 0; idx < shape_size; ++idx)
  {
    bool known = output_known_vector[shape_size - 1u - idx];
    if (not known)
      continue;
    int64_t dim = output_shape_vector.at(shape_size - 1u - idx);
    LUCI_ASSERT(0 <= dim && dim < 0xfffffffL, "Dimension size exceeds limit");
    // reverse copy
    output_shape.dim(idx) = static_cast<uint32_t>(dim);
  }
 
  return output_shape;
}

References luci::CircleStridedSlice::begin(), begin, luci::sinf::BuildStridedSliceParams(), luci::sinf::circle_shape(), luci::sinf::StridedSliceContext::effective_input_shape, luci::CircleStridedSlice::end(), luci::CircleStridedSlice::input(), luci::input_node(), INTERNAL_EXN, LUCI_ASSERT, output_shape, loco::TensorShape::rank(), luci::sinf::S32, luci::sinf::StartForAxis(), luci::sinf::StopForAxis(), and luci::CircleStridedSlice::strides().

---

The documentation for this class was generated from the following files:

• compiler/luci/service/include/luci/Service/CircleShapeInference.h
• compiler/luci/service/src/Nodes/CircleAdd.cpp
• compiler/luci/service/src/Nodes/CircleBatchMatMul.cpp
• compiler/luci/service/src/Nodes/CircleConcatenation.cpp
• compiler/luci/service/src/Nodes/CircleDiv.cpp
• compiler/luci/service/src/Nodes/CircleFullyConnected.cpp
• compiler/luci/service/src/Nodes/CircleIfOut.cpp
• compiler/luci/service/src/Nodes/CircleLogistic.cpp
• compiler/luci/service/src/Nodes/CircleMul.cpp
• compiler/luci/service/src/Nodes/CircleNeg.cpp
• compiler/luci/service/src/Nodes/CirclePad.cpp
• compiler/luci/service/src/Nodes/CircleQuantize.cpp
• compiler/luci/service/src/Nodes/CircleRange.cpp
• compiler/luci/service/src/Nodes/CircleReshape.cpp
• compiler/luci/service/src/Nodes/CircleRsqrt.cpp
• compiler/luci/service/src/Nodes/CircleSoftmax.cpp
• compiler/luci/service/src/Nodes/CircleStridedSlice.cpp