Method Apply

oneflow/core/functional/tensor_processor.cpp:104–143

}

Maybe<void> TensorProcessor::Apply() {
  if (promote_inputs_to_common_dtype_) {
    bool has_different_input_dtype = CheckHasDifferentInputDType(tensor_tuple_);
    if (has_different_input_dtype) {
      if (promote_dtype_.has_value()) {
        common_dtype_ = CHECK_JUST(promote_dtype_);
      } else {
        common_dtype_ = ComputeCommonDType(tensor_tuple_);
      }
      if (promote_integer_inputs_to_float_ && common_dtype_->is_integer()) {
        // Promotes common dtype to the default float scalar type, if needed.
        // same to pytorch's computeTypes() in torch/csrc/jit/codegen/cuda/type_promotion.cpp
        common_dtype_ = DType::Float();
      }
      JUST(CastToSameType(tensor_tuple_, common_dtype_));
    } else {
      if (tensor_tuple_.size() == 1
          && !((tensor_tuple_[0]->dtype()->is_floating_point())
               || tensor_tuple_[0]->dtype()->is_complex())) {
        Symbol<DType> cast_dtype = (inputs_lowest_dtype_vec_[0] == DType::InvalidDataType())
                                       ? DType::Float()
                                       : inputs_lowest_dtype_vec_[0];
        JUST(CastToSameType(tensor_tuple_, cast_dtype));
      }
    }
  } else {
    for (int i = 0; i < tensor_tuple_.size(); ++i) {
      // Cast all the inputs to it's attribute `lowest_dtype` if the input tensor dtype is lower
      // than attribute `lowest_dtype`.
      Symbol<DType> base_dtype = inputs_lowest_dtype_vec_.at(i);
      if (base_dtype->data_type()
          && DType::priority_order[base_dtype->data_type()]
                 > DType::priority_order[tensor_tuple_.at(i)->dtype()->data_type()]) {
        tensor_tuple_[i] =
            JUST(one::functional::Cast(tensor_tuple_[i], base_dtype, /*pin_memory=*/false));
      }
    }
  }
  return Maybe<void>::Ok();
}

static bool IsAllContiguous(const TensorTuple& tensors) {
  for (const auto& t : tensors) {