void add_functions()

in nestedtensor/csrc/python_functions.cpp [129:286]

• 145 lines of code
• 16 McCabe index (conditional complexity)

void add_functions(pybind11::module m) {
  m.def(
      "interpolate",
      [](at::Tensor input,
         c10::optional<std::vector<std::vector<int64_t>>> size,
         c10::optional<THPArrayRef<double>> scale_factor,
         c10::optional<std::string> mode,
         c10::optional<bool> align_corners,
         c10::optional<bool> recompute_scale_factor,
         bool antialias) {
        if (scale_factor.has_value() && size.has_value()) {
          throw std::runtime_error(
              "only one of size or scale_factor should be defined");
        }
        if (antialias) {
          throw std::runtime_error("Antialias is not yet supported");
        }

        if (size.has_value()) {
          return interpolate(
              input, size.value(), c10::nullopt, mode, align_corners);
        }

        if (scale_factor.has_value()) {
          return interpolate(
              input,
              c10::nullopt,
              scale_factor.value().extract<2>(),
              mode,
              align_corners);
        }

        throw std::runtime_error(
            "Either size or scale factor have to be passed.");
      },
      py::arg("input"),
      py::arg("size") = nullptr,
      py::arg("scale_factor") = nullptr,
      py::arg("mode") = "nearest",
      py::arg("align_corners") = false,
      py::arg("recompute_scale_factor") = false,
      py::arg("antialias") = false);

  m.def(
      "interpolate",
      [](at::Tensor input,
         c10::optional<std::vector<int64_t>> size,
         c10::optional<THPArrayRef<double>> scale_factor,
         c10::optional<std::string> mode,
         c10::optional<bool> align_corners,
         c10::optional<bool> recompute_scale_factor,
         bool antialias) {
        if (scale_factor.has_value() && size.has_value()) {
          throw std::runtime_error(
              "only one of size or scale_factor should be defined");
        }
        if (antialias) {
          throw std::runtime_error("Antialias is not yet supported");
        }

        if (size.has_value()) {
          std::vector<std::vector<int64_t>> sizes{size.value()};
          return interpolate(input, sizes, c10::nullopt, mode, align_corners);
        }

        if (scale_factor.has_value()) {
          return interpolate(
              input,
              c10::nullopt,
              scale_factor.value().extract<2>(),
              mode,
              align_corners);
        }

        throw std::runtime_error(
            "Either size or scale factor have to be passed.");
      },
      py::arg("input"),
      py::arg("size") = nullptr,
      py::arg("scale_factor") = nullptr,
      py::arg("mode") = "nearest",
      py::arg("align_corners") = false,
      py::arg("recompute_scale_factor") = false,
      py::arg("antialias") = false);

  m.def(
      "interpolate",
      [](at::Tensor input,
         c10::optional<int64_t> size,
         c10::optional<THPArrayRef<double>> scale_factor,
         c10::optional<std::string> mode,
         c10::optional<bool> align_corners,
         c10::optional<bool> recompute_scale_factor,
         bool antialias) {
        if (scale_factor.has_value() && size.has_value()) {
          throw std::runtime_error(
              "only one of size or scale_factor should be defined");
        }
        if (antialias) {
          throw std::runtime_error("Antialias is not yet supported");
        }

        if (size.has_value()) {
          std::vector<std::vector<int64_t>> sizes{
              std::vector<int64_t>{size.value(), size.value()}};

          return interpolate(input, sizes, c10::nullopt, mode, align_corners);
        }

        if (scale_factor.has_value()) {
          return interpolate(
              input,
              c10::nullopt,
              scale_factor.value().extract<2>(),
              mode,
              align_corners);
        }

        throw std::runtime_error(
            "Either size or scale factor have to be passed.");
      },
      py::arg("input"),
      py::arg("size") = nullptr,
      py::arg("scale_factor") = nullptr,
      py::arg("mode") = "nearest",
      py::arg("align_corners") = false,
      py::arg("recompute_scale_factor") = false,
      py::arg("antialias") = false);

  m.def(
      "cross_entropy",
      [](at::Tensor input,
         at::Tensor target,
         c10::optional<at::Tensor> weight,
         c10::optional<bool> size_average, // TODO: use
         c10::optional<int64_t> ignore_index,
         c10::optional<bool> reduce, // TODO: use
         c10::optional<std::string> reduction,
         c10::optional<double> label_smoothing) {
        return cross_entropy(
            input,
            target,
            weight,
            size_average,
            ignore_index,
            reduce,
            reduction,
            label_smoothing);
      },
      py::arg("input"),
      py::arg("target"),
      py::arg("weight") = nullptr,
      py::arg("size_average") = true,
      py::arg("ignore_index") = -100,
      py::arg("reduce") = true,
      py::arg("reduction") = "mean",
      py::arg("label_smoothing") = 0.0);
}