Make all non-input arguments to functionals part of its options (#29404)
Summary:
Pull Request resolved: https://github.com/pytorch/pytorch/pull/29404
This PR makes all non-input arguments to functionals part of its options parameters, so that we won't break backward compatibility even if we add or reorder some of the non-input arguments to functionals in the future.
Test Plan: Imported from OSS
Differential Revision: D18378526
Pulled By: yf225
fbshipit-source-id: f5cf6bdfb844e75bf94fdee58c121e0955631b6e
diff --git a/test/cpp/api/functional.cpp b/test/cpp/api/functional.cpp
index ef1d298..0b1d2ae 100644
--- a/test/cpp/api/functional.cpp
+++ b/test/cpp/api/functional.cpp
@@ -550,7 +550,7 @@
x = torch::tensor({{{2, 4, 5}}}, torch::dtype(torch::kFloat).requires_grad(true));
indices = torch::tensor({{{1, 3, 4}}}, torch::kLong);
y = F::max_unpool1d(
- x, indices, F::MaxUnpool1dFuncOptions(3), std::vector<int64_t>({1, 1, 9}));
+ x, indices, F::MaxUnpool1dFuncOptions(3).output_size(std::vector<int64_t>({1, 1, 9})));
ASSERT_EQ(y.ndimension(), 3);
ASSERT_TRUE(torch::allclose(
@@ -1037,7 +1037,7 @@
auto input = torch::tensor({{{0, 1, 2, 3, 4}, {5, 6, 7, 8, 9}}}, torch::dtype(torch::kFloat));
auto output = torch::randn({1,2,5}, torch::dtype(torch::kFloat));
// non-null output argument
- F::normalize(input, F::NormalizeFuncOptions().p(1).dim(-1), output);
+ F::normalize(input, F::NormalizeFuncOptions().p(1).dim(-1).out(output));
// default options
F::normalize(input);
@@ -1371,8 +1371,7 @@
auto bias = torch::zeros({num_features});
auto output = F::batch_norm(
input, mean, variance,
- F::BatchNormFuncOptions().weight(weight).bias(bias).momentum(momentum).eps(eps),
- /*training=*/false);
+ F::BatchNormFuncOptions().weight(weight).bias(bias).momentum(momentum).eps(eps).training(false));
auto expected = (input - mean) / torch::sqrt(variance + eps);
ASSERT_TRUE(output.allclose(expected));
}
@@ -1398,8 +1397,7 @@
auto bias = torch::zeros({num_features});
auto output = F::batch_norm(
input, mean, variance,
- F::BatchNormFuncOptions().weight(weight).bias(bias).momentum(momentum).eps(eps),
- /*training=*/false);
+ F::BatchNormFuncOptions().weight(weight).bias(bias).momentum(momentum).eps(eps).training(false));
auto expected = torch::transpose((torch::transpose(input, 1, 3) - mean) / torch::sqrt(variance + eps), 1, 3);
ASSERT_TRUE(output.allclose(expected));
}
@@ -1428,8 +1426,7 @@
auto bias = torch::zeros({num_features});
auto output = F::batch_norm(
input, mean, variance,
- F::BatchNormFuncOptions().weight(weight).bias(bias).momentum(momentum).eps(eps),
- /*training=*/false);
+ F::BatchNormFuncOptions().weight(weight).bias(bias).momentum(momentum).eps(eps).training(false));
auto expected = torch::transpose((torch::transpose(input, 1, 4) - mean) / torch::sqrt(variance + eps), 1, 4);
ASSERT_TRUE(output.allclose(expected));
}
diff --git a/test/cpp/api/modules.cpp b/test/cpp/api/modules.cpp
index 2293424..623a6e9 100644
--- a/test/cpp/api/modules.cpp
+++ b/test/cpp/api/modules.cpp
@@ -646,7 +646,7 @@
input = torch::tensor({{{1, 2, 3, 4, 5, 6, 7, 8, 9}}}, torch::kFloat);
std::tie(output, indices) = pool->forward_with_indices(input);
ASSERT_TRUE(torch::allclose(
- unpool(output, indices, input.sizes()),
+ unpool(output, indices, input.sizes().vec()),
torch::tensor({{{0, 2, 0, 4, 0, 6, 0, 8, 0}}} , torch::kFloat)));
ASSERT_TRUE(torch::allclose(
unpool(output, indices),
diff --git a/torch/csrc/api/include/torch/arg.h b/torch/csrc/api/include/torch/arg.h
index 4b041d8..5ed7742 100644
--- a/torch/csrc/api/include/torch/arg.h
+++ b/torch/csrc/api/include/torch/arg.h
@@ -15,5 +15,8 @@
inline const T& name() const noexcept { /* NOLINT */ \
return this->name##_; \
} \
+ inline T& name() noexcept { /* NOLINT */ \
+ return this->name##_; \
+ } \
private: \
T name##_ /* NOLINT */
diff --git a/torch/csrc/api/include/torch/nn/functional/activation.h b/torch/csrc/api/include/torch/nn/functional/activation.h
index 517f76d..4b15e2d 100644
--- a/torch/csrc/api/include/torch/nn/functional/activation.h
+++ b/torch/csrc/api/include/torch/nn/functional/activation.h
@@ -17,7 +17,7 @@
}
} // namespace detail
-inline Tensor elu(Tensor& input, ELUFuncOptions options = {}) {
+inline Tensor elu(Tensor& input, const ELUFuncOptions& options = {}) {
return detail::elu(input, options.alpha(), options.inplace());
}
@@ -33,7 +33,7 @@
}
} // namespace detail
-inline Tensor selu(Tensor& input, SELUFuncOptions options = {}) {
+inline Tensor selu(Tensor& input, const SELUFuncOptions& options = {}) {
return detail::selu(input, options.inplace());
}
@@ -47,7 +47,7 @@
} // namespace detail
inline Tensor hardshrink(const Tensor& input,
- HardshrinkFuncOptions options = {}) {
+ const HardshrinkFuncOptions& options = {}) {
return detail::hardshrink(input, options.lambda());
}
@@ -66,7 +66,7 @@
}
} // namespace detail
-inline Tensor hardtanh(Tensor& input, HardtanhFuncOptions options = {}) {
+inline Tensor hardtanh(Tensor& input, const HardtanhFuncOptions& options = {}) {
return detail::hardtanh(input, options.min_val(), options.max_val(), options.inplace());
}
@@ -84,7 +84,7 @@
}
} // namespace detail
-inline Tensor leaky_relu(Tensor& input, LeakyReLUFuncOptions options = {}) {
+inline Tensor leaky_relu(Tensor& input, const LeakyReLUFuncOptions& options = {}) {
return detail::leaky_relu(input, options.negative_slope(), options.inplace());
}
@@ -118,7 +118,7 @@
}
} // namespace detail
-inline Tensor gumbel_softmax(const Tensor& logits, GumbelSoftmaxFuncOptions options = {}) {
+inline Tensor gumbel_softmax(const Tensor& logits, const GumbelSoftmaxFuncOptions& options = {}) {
return detail::gumbel_softmax(logits, options.tau(), options.hard(), options.dim());
}
@@ -139,9 +139,8 @@
}
} // namespace detail
-inline Tensor softmax(const Tensor& input, SoftmaxFuncOptions options,
- c10::optional<torch::Dtype> dtype = c10::nullopt) {
- return detail::softmax(input, options.dim(), dtype);
+inline Tensor softmax(const Tensor& input, const SoftmaxFuncOptions& options) {
+ return detail::softmax(input, options.dim(), options.dtype());
}
// ============================================================================
@@ -161,9 +160,8 @@
}
} // namespace detail
-inline Tensor softmin(const Tensor& input, SoftminFuncOptions options,
- c10::optional<torch::Dtype> dtype = c10::nullopt) {
- return detail::softmin(input, options.dim(), dtype);
+inline Tensor softmin(const Tensor& input, const SoftminFuncOptions& options) {
+ return detail::softmin(input, options.dim(), options.dtype());
}
// ============================================================================
@@ -183,9 +181,8 @@
}
} // namespace detail
-inline Tensor log_softmax(const Tensor& input, LogSoftmaxFuncOptions options,
- c10::optional<torch::Dtype> dtype = c10::nullopt) {
- return detail::log_softmax(input, options.dim(), dtype);
+inline Tensor log_softmax(const Tensor& input, const LogSoftmaxFuncOptions& options) {
+ return detail::log_softmax(input, options.dim(), options.dtype());
}
// ============================================================================
@@ -212,7 +209,7 @@
}
} // namespace detail
-inline Tensor relu(Tensor& input, ReLUFuncOptions options = {}) {
+inline Tensor relu(Tensor& input, const ReLUFuncOptions& options = {}) {
return detail::relu(input, options.inplace());
}
@@ -224,18 +221,19 @@
}
} // namespace detail
-inline Tensor relu6(Tensor& input, ReLU6FuncOptions options = {}) {
+inline Tensor relu6(Tensor& input, const ReLU6FuncOptions& options = {}) {
return detail::relu6(input, options.inplace());
}
// ============================================================================
namespace detail {
+
inline Tensor rrelu(Tensor& input,
double lower,
double upper,
- bool inplace,
- bool training) {
+ bool training,
+ bool inplace) {
if (inplace) {
return torch::rrelu_(input, lower, upper, training);
} else {
@@ -244,9 +242,8 @@
}
} // namespace detail
-inline Tensor rrelu(Tensor& input, RReLUFuncOptions options = {},
- bool training = false) {
- return detail::rrelu(input, options.lower(), options.upper(), options.inplace(), training);
+inline Tensor rrelu(Tensor& input, const RReLUFuncOptions& options = {}) {
+ return detail::rrelu(input, options.lower(), options.upper(), options.training(), options.inplace());
}
// ============================================================================
@@ -263,7 +260,7 @@
}
} // namespace detail
-inline Tensor celu(Tensor& input, CELUFuncOptions options = {}) {
+inline Tensor celu(Tensor& input, const CELUFuncOptions& options = {}) {
return detail::celu(input, options.alpha(), options.inplace());
}
@@ -278,7 +275,7 @@
} // namespace detail
inline Tensor softplus(const Tensor& input,
- SoftplusFuncOptions options = {}) {
+ const SoftplusFuncOptions& options = {}) {
return detail::softplus(input, options.beta(), options.threshold());
}
@@ -293,7 +290,7 @@
} // namespace detail
inline Tensor softshrink(const Tensor& input,
- SoftshrinkFuncOptions options = {}) {
+ const SoftshrinkFuncOptions& options = {}) {
return detail::softshrink(input, options.lambda());
}
@@ -324,7 +321,7 @@
}
} // namespace detail
-inline Tensor threshold(Tensor& input, ThresholdFuncOptions options) {
+inline Tensor threshold(Tensor& input, const ThresholdFuncOptions& options) {
return detail::threshold(input, options.threshold(), options.value(), options.inplace());
}
diff --git a/torch/csrc/api/include/torch/nn/functional/batchnorm.h b/torch/csrc/api/include/torch/nn/functional/batchnorm.h
index 44995c7..0728d55 100644
--- a/torch/csrc/api/include/torch/nn/functional/batchnorm.h
+++ b/torch/csrc/api/include/torch/nn/functional/batchnorm.h
@@ -40,14 +40,14 @@
} // namespace detail
inline Tensor batch_norm(const Tensor& input, const Tensor& running_mean,
- const Tensor& running_var, BatchNormFuncOptions options = {}, bool training = false) {
+ const Tensor& running_var, const BatchNormFuncOptions& options = {}) {
return detail::batch_norm(
input,
running_mean,
running_var,
options.weight(),
options.bias(),
- training,
+ options.training(),
options.momentum(),
options.eps());
}
diff --git a/torch/csrc/api/include/torch/nn/functional/distance.h b/torch/csrc/api/include/torch/nn/functional/distance.h
index d340c47..3ecd5bf 100644
--- a/torch/csrc/api/include/torch/nn/functional/distance.h
+++ b/torch/csrc/api/include/torch/nn/functional/distance.h
@@ -23,7 +23,7 @@
inline Tensor cosine_similarity(
const Tensor& x1,
const Tensor& x2,
- CosineSimilarityFuncOptions options = {}) {
+ const CosineSimilarityFuncOptions& options = {}) {
return detail::cosine_similarity(x1, x2, options.dim(), options.eps());
}
@@ -48,7 +48,7 @@
inline Tensor pairwise_distance(
const Tensor& x1,
const Tensor& x2,
- PairwiseDistanceFuncOptions options = {}) {
+ const PairwiseDistanceFuncOptions& options = {}) {
return detail::pairwise_distance(x1, x2, options.p(), options.eps(), options.keepdim());
}
diff --git a/torch/csrc/api/include/torch/nn/functional/fold.h b/torch/csrc/api/include/torch/nn/functional/fold.h
index 757c0ba..9c11e25 100644
--- a/torch/csrc/api/include/torch/nn/functional/fold.h
+++ b/torch/csrc/api/include/torch/nn/functional/fold.h
@@ -30,7 +30,7 @@
}
} // namespace detail
-inline Tensor fold(const Tensor& input, FoldFuncOptions options) {
+inline Tensor fold(const Tensor& input, const FoldFuncOptions& options) {
return detail::fold(
input,
options.output_size(),
@@ -64,7 +64,7 @@
}
} // namespace detail
-inline Tensor unfold(const Tensor& input, UnfoldFuncOptions options) {
+inline Tensor unfold(const Tensor& input, const UnfoldFuncOptions& options) {
return detail::unfold(input, options.kernel_size(), options.dilation(), options.padding(), options.stride());
}
diff --git a/torch/csrc/api/include/torch/nn/functional/loss.h b/torch/csrc/api/include/torch/nn/functional/loss.h
index 5ad4fe7..531a004 100644
--- a/torch/csrc/api/include/torch/nn/functional/loss.h
+++ b/torch/csrc/api/include/torch/nn/functional/loss.h
@@ -22,7 +22,7 @@
inline Tensor l1_loss(
const Tensor& input,
const Tensor& target,
- L1LossFuncOptions options = {}) {
+ const L1LossFuncOptions& options = {}) {
return detail::l1_loss(input, target, options.reduction());
}
@@ -61,7 +61,7 @@
inline Tensor kl_div(
const Tensor& input,
const Tensor& target,
- KLDivLossFuncOptions options = {}) {
+ const KLDivLossFuncOptions& options = {}) {
return detail::kl_div(input, target, options.reduction());
}
@@ -100,7 +100,7 @@
inline Tensor mse_loss(
const Tensor& input,
const Tensor& target,
- MSELossFuncOptions options = {}) {
+ const MSELossFuncOptions& options = {}) {
return detail::mse_loss(input, target, options.reduction());
}
@@ -139,7 +139,7 @@
inline Tensor binary_cross_entropy(
const Tensor& input,
const Tensor& target,
- BCELossFuncOptions options = {}) {
+ const BCELossFuncOptions& options = {}) {
return detail::binary_cross_entropy(input, target, options.weight(), options.reduction());
}
@@ -162,7 +162,7 @@
inline Tensor hinge_embedding_loss(
const Tensor& input,
const Tensor& target,
- HingeEmbeddingLossFuncOptions options = {}) {
+ const HingeEmbeddingLossFuncOptions& options = {}) {
return detail::hinge_embedding_loss(input, target, options.margin(), options.reduction());
}
@@ -195,7 +195,7 @@
inline Tensor multi_margin_loss(
const Tensor& input,
const Tensor& target,
- MultiMarginLossFuncOptions options = {}) {
+ const MultiMarginLossFuncOptions& options = {}) {
return detail::multi_margin_loss(input, target, options.p(), options.margin(), options.weight(), options.reduction());
}
@@ -221,7 +221,7 @@
const Tensor& input1,
const Tensor& input2,
const Tensor& target,
- CosineEmbeddingLossFuncOptions options = {}) {
+ const CosineEmbeddingLossFuncOptions& options = {}) {
return detail::cosine_embedding_loss(input1, input2, target, options.margin(), options.reduction());
}
@@ -261,7 +261,7 @@
inline Tensor smooth_l1_loss(
const Tensor& input,
const Tensor& target,
- SmoothL1LossFuncOptions options = {}) {
+ const SmoothL1LossFuncOptions& options = {}) {
return detail::smooth_l1_loss(input, target, options.reduction());
}
@@ -282,7 +282,7 @@
inline Tensor multilabel_margin_loss(
const Tensor& input,
const Tensor& target,
- MultiLabelMarginLossFuncOptions options = {}) {
+ const MultiLabelMarginLossFuncOptions& options = {}) {
return detail::multilabel_margin_loss(input, target, options.reduction());
}
@@ -303,7 +303,7 @@
inline Tensor soft_margin_loss(
const Tensor& input,
const Tensor& target,
- SoftMarginLossFuncOptions options = {}) {
+ const SoftMarginLossFuncOptions& options = {}) {
return detail::soft_margin_loss(input, target, options.reduction());
}
@@ -344,7 +344,7 @@
inline Tensor multilabel_soft_margin_loss(
const Tensor& input,
const Tensor& target,
- MultiLabelSoftMarginLossFuncOptions options = {}) {
+ const MultiLabelSoftMarginLossFuncOptions& options = {}) {
return detail::multilabel_soft_margin_loss(input, target, options.weight(), options.reduction());
}
@@ -376,7 +376,7 @@
const Tensor& anchor,
const Tensor& positive,
const Tensor& negative,
- TripletMarginLossFuncOptions options = {}) {
+ const TripletMarginLossFuncOptions& options = {}) {
return detail::triplet_margin_loss(
anchor,
positive,
@@ -413,7 +413,7 @@
const Tensor& targets,
const Tensor& input_lengths,
const Tensor& target_lengths,
- CTCLossFuncOptions options = {}) {
+ const CTCLossFuncOptions& options = {}) {
return detail::ctc_loss(
log_probs,
targets,
@@ -440,7 +440,7 @@
} // namespace detail
inline Tensor poisson_nll_loss(const Tensor& input, const Tensor& target,
- PoissonNLLLossFuncOptions options = {}) {
+ const PoissonNLLLossFuncOptions& options = {}) {
return detail::poisson_nll_loss(
input, target,
options.log_input(), options.full(), options.eps(), options.reduction());
@@ -465,7 +465,7 @@
} // namespace detail
inline Tensor margin_ranking_loss(const Tensor& input1, const Tensor& input2,
- const Tensor& target, MarginRankingLossFuncOptions options = {}) {
+ const Tensor& target, const MarginRankingLossFuncOptions& options = {}) {
return detail::margin_ranking_loss(input1, input2, target, options.margin(), options.reduction());
}
diff --git a/torch/csrc/api/include/torch/nn/functional/normalization.h b/torch/csrc/api/include/torch/nn/functional/normalization.h
index e7b244d..fcd17a9 100644
--- a/torch/csrc/api/include/torch/nn/functional/normalization.h
+++ b/torch/csrc/api/include/torch/nn/functional/normalization.h
@@ -28,9 +28,8 @@
inline Tensor normalize(
const Tensor& input,
- NormalizeFuncOptions options = {},
- c10::optional<Tensor> out = c10::nullopt) {
- return detail::normalize(input, options.p(), options.dim(), options.eps(), out);
+ NormalizeFuncOptions options = {}) {
+ return detail::normalize(input, options.p(), options.dim(), options.eps(), options.out());
}
// ============================================================================
@@ -46,10 +45,8 @@
} // namespace detail
inline Tensor layer_norm(const Tensor& input,
- LayerNormFuncOptions options,
- const Tensor& weight = Tensor(),
- const Tensor& bias = Tensor()) {
- return detail::layer_norm(input, options.normalized_shape(), weight, bias, options.eps());
+ const LayerNormFuncOptions& options) {
+ return detail::layer_norm(input, options.normalized_shape(), options.weight(), options.bias(), options.eps());
}
// ============================================================================
@@ -95,7 +92,7 @@
inline Tensor local_response_norm(
const Tensor& input,
- LocalResponseNormFuncOptions options) {
+ const LocalResponseNormFuncOptions& options) {
return detail::local_response_norm(input, options.size(), options.alpha(), options.beta(), options.k());
}
diff --git a/torch/csrc/api/include/torch/nn/functional/padding.h b/torch/csrc/api/include/torch/nn/functional/padding.h
index cc25cfd..0ccc1a2 100644
--- a/torch/csrc/api/include/torch/nn/functional/padding.h
+++ b/torch/csrc/api/include/torch/nn/functional/padding.h
@@ -82,7 +82,7 @@
}
} // namespace detail
-inline Tensor pad(const Tensor& input, PadFuncOptions options) {
+inline Tensor pad(const Tensor& input, const PadFuncOptions& options) {
return detail::pad(input, options.pad(), options.mode(), options.value());
}
diff --git a/torch/csrc/api/include/torch/nn/functional/pixelshuffle.h b/torch/csrc/api/include/torch/nn/functional/pixelshuffle.h
index 2ed134e..050d950 100644
--- a/torch/csrc/api/include/torch/nn/functional/pixelshuffle.h
+++ b/torch/csrc/api/include/torch/nn/functional/pixelshuffle.h
@@ -19,7 +19,7 @@
inline Tensor pixel_shuffle(
const Tensor& input,
- PixelShuffleFuncOptions options) {
+ const PixelShuffleFuncOptions& options) {
return detail::pixel_shuffle(input, options.upscale_factor());
}
diff --git a/torch/csrc/api/include/torch/nn/functional/pooling.h b/torch/csrc/api/include/torch/nn/functional/pooling.h
index 32ff899..b230293 100644
--- a/torch/csrc/api/include/torch/nn/functional/pooling.h
+++ b/torch/csrc/api/include/torch/nn/functional/pooling.h
@@ -24,7 +24,7 @@
}
} // namespace detail
-inline Tensor avg_pool1d(const Tensor& input, AvgPool1dFuncOptions options) {
+inline Tensor avg_pool1d(const Tensor& input, const AvgPool1dFuncOptions& options) {
return avg_pool1d(
input,
options.kernel_size(),
@@ -53,7 +53,7 @@
}
} // namespace detail
-inline Tensor avg_pool2d(const Tensor& input, AvgPool2dFuncOptions options) {
+inline Tensor avg_pool2d(const Tensor& input, const AvgPool2dFuncOptions& options) {
return detail::avg_pool2d(
input,
options.kernel_size(),
@@ -83,7 +83,7 @@
}
} // namespace detail
-inline Tensor avg_pool3d(const Tensor& input, AvgPool3dFuncOptions options) {
+inline Tensor avg_pool3d(const Tensor& input, const AvgPool3dFuncOptions& options) {
return detail::avg_pool3d(
input,
options.kernel_size(),
@@ -113,7 +113,7 @@
}
} // namespace detail
-inline Tensor max_pool1d(const Tensor& input, MaxPool1dFuncOptions options) {
+inline Tensor max_pool1d(const Tensor& input, const MaxPool1dFuncOptions& options) {
return detail::max_pool1d(
input,
options.kernel_size(),
@@ -141,7 +141,7 @@
}
} // namespace detail
-inline std::tuple<Tensor, Tensor> max_pool1d_with_indices(const Tensor& input, MaxPool1dFuncOptions options) {
+inline std::tuple<Tensor, Tensor> max_pool1d_with_indices(const Tensor& input, const MaxPool1dFuncOptions& options) {
return detail::max_pool1d_with_indices(
input,
options.kernel_size(),
@@ -168,7 +168,7 @@
}
} // namespace detail
-inline Tensor max_pool2d(const Tensor& input, MaxPool2dFuncOptions options) {
+inline Tensor max_pool2d(const Tensor& input, const MaxPool2dFuncOptions& options) {
return detail::max_pool2d(
input,
options.kernel_size(),
@@ -196,7 +196,7 @@
}
} // namespace detail
-inline std::tuple<Tensor, Tensor> max_pool2d_with_indices(const Tensor& input, MaxPool2dFuncOptions options) {
+inline std::tuple<Tensor, Tensor> max_pool2d_with_indices(const Tensor& input, const MaxPool2dFuncOptions& options) {
return detail::max_pool2d_with_indices(
input,
options.kernel_size(),
@@ -223,7 +223,7 @@
}
} // namespace detail
-inline Tensor max_pool3d(const Tensor& input, MaxPool3dFuncOptions options) {
+inline Tensor max_pool3d(const Tensor& input, const MaxPool3dFuncOptions& options) {
return detail::max_pool3d(
input,
options.kernel_size(),
@@ -251,7 +251,7 @@
}
} // namespace detail
-inline std::tuple<Tensor, Tensor> max_pool3d_with_indices(const Tensor& input, MaxPool3dFuncOptions options) {
+inline std::tuple<Tensor, Tensor> max_pool3d_with_indices(const Tensor& input, const MaxPool3dFuncOptions& options) {
return detail::max_pool3d_with_indices(
input,
options.kernel_size(),
@@ -271,7 +271,7 @@
} // namespace detail
inline Tensor adaptive_max_pool1d(const Tensor& input,
- AdaptiveMaxPool1dFuncOptions options) {
+ const AdaptiveMaxPool1dFuncOptions& options) {
return detail::adaptive_max_pool1d(input, options.output_size());
}
@@ -283,7 +283,7 @@
} // namespace detail
inline std::tuple<Tensor, Tensor> adaptive_max_pool1d_with_indices(
- const Tensor& input, AdaptiveMaxPool1dFuncOptions options) {
+ const Tensor& input, const AdaptiveMaxPool1dFuncOptions& options) {
return detail::adaptive_max_pool1d_with_indices(input, options.output_size());
}
@@ -295,7 +295,7 @@
} // namespace detail
inline Tensor adaptive_max_pool2d(const Tensor& input,
- AdaptiveMaxPool2dFuncOptions options) {
+ const AdaptiveMaxPool2dFuncOptions& options) {
return detail::adaptive_max_pool2d(input, options.output_size());
}
@@ -307,7 +307,7 @@
} // namespace detail
inline std::tuple<Tensor, Tensor> adaptive_max_pool2d_with_indices(
- const Tensor& input, AdaptiveMaxPool2dFuncOptions options) {
+ const Tensor& input, const AdaptiveMaxPool2dFuncOptions& options) {
return detail::adaptive_max_pool2d_with_indices(input, options.output_size());
}
@@ -319,7 +319,7 @@
} // namespace detail
inline Tensor adaptive_max_pool3d(const Tensor& input,
- AdaptiveMaxPool3dFuncOptions options) {
+ const AdaptiveMaxPool3dFuncOptions& options) {
return detail::adaptive_max_pool3d(input, options.output_size());
}
@@ -331,7 +331,7 @@
} // namespace detail
inline std::tuple<Tensor, Tensor> adaptive_max_pool3d_with_indices(
- const Tensor& input, AdaptiveMaxPool3dFuncOptions options) {
+ const Tensor& input, const AdaptiveMaxPool3dFuncOptions& options) {
return detail::adaptive_max_pool3d_with_indices(input, options.output_size());
}
@@ -345,7 +345,7 @@
} // namespace detail
inline Tensor adaptive_avg_pool1d(const Tensor& input,
- AdaptiveAvgPool1dFuncOptions options) {
+ const AdaptiveAvgPool1dFuncOptions& options) {
return detail::adaptive_avg_pool1d(input, options.output_size());
}
@@ -357,7 +357,7 @@
} // namespace detail
inline Tensor adaptive_avg_pool2d(const Tensor& input,
- AdaptiveAvgPool2dFuncOptions options) {
+ const AdaptiveAvgPool2dFuncOptions& options) {
return detail::adaptive_avg_pool2d(input, options.output_size());
}
@@ -369,7 +369,7 @@
} // namespace detail
inline Tensor adaptive_avg_pool3d(const Tensor& input,
- AdaptiveAvgPool3dFuncOptions options) {
+ const AdaptiveAvgPool3dFuncOptions& options) {
return detail::adaptive_avg_pool3d(input, options.output_size());
}
@@ -377,7 +377,7 @@
inline std::vector<int64_t> _unpool_output_size(const Tensor& input,
const IntArrayRef& kernel_size, const IntArrayRef& stride,
- const IntArrayRef& padding, const c10::optional<IntArrayRef>& output_size) {
+ const IntArrayRef& padding, const c10::optional<std::vector<int64_t>>& output_size) {
auto input_size = input.sizes();
std::vector<int64_t> default_size;
for (size_t d = 0; d < kernel_size.size(); d++) {
@@ -389,7 +389,7 @@
} else {
std::vector<int64_t> output_size_;
if (output_size->size() == kernel_size.size() + 2) {
- output_size_ = output_size->slice(2).vec();
+ output_size_ = IntArrayRef(*output_size).slice(2).vec();
}
if (output_size_.size() != kernel_size.size()) {
TORCH_CHECK(false, "output_size should be a sequence containing ",
@@ -416,7 +416,7 @@
ExpandingArray<1> kernel_size,
ExpandingArray<1> stride,
ExpandingArray<1> padding,
- const c10::optional<IntArrayRef>& output_size) {
+ const c10::optional<std::vector<int64_t>>& output_size) {
auto output_size_ = _unpool_output_size(input, kernel_size,
stride, padding,
output_size);
@@ -427,15 +427,14 @@
} // namespace detail
inline Tensor max_unpool1d(const Tensor& input, const Tensor& indices,
- MaxUnpool1dFuncOptions options,
- const c10::optional<IntArrayRef>& output_size = c10::nullopt) {
+ const MaxUnpool1dFuncOptions& options) {
return detail::max_unpool1d(
input,
indices,
options.kernel_size(),
options.stride(),
options.padding(),
- output_size);
+ options.output_size());
}
namespace detail {
@@ -445,7 +444,7 @@
ExpandingArray<2> kernel_size,
ExpandingArray<2> stride,
ExpandingArray<2> padding,
- const c10::optional<IntArrayRef>& output_size) {
+ const c10::optional<std::vector<int64_t>>& output_size) {
auto output_size_ = _unpool_output_size(input, kernel_size,
stride, padding,
output_size);
@@ -455,15 +454,14 @@
} // namespace detail
inline Tensor max_unpool2d(const Tensor& input, const Tensor& indices,
- MaxUnpool2dFuncOptions options,
- const c10::optional<IntArrayRef>& output_size = c10::nullopt) {
+ const MaxUnpool2dFuncOptions& options) {
return detail::max_unpool2d(
input,
indices,
options.kernel_size(),
options.stride(),
options.padding(),
- output_size);
+ options.output_size());
}
namespace detail {
@@ -473,7 +471,7 @@
ExpandingArray<3> kernel_size,
ExpandingArray<3> stride,
ExpandingArray<3> padding,
- const c10::optional<IntArrayRef>& output_size) {
+ const c10::optional<std::vector<int64_t>>& output_size) {
auto output_size_ = _unpool_output_size(input, kernel_size,
stride, padding,
output_size);
@@ -484,15 +482,14 @@
} // namespace detail
inline Tensor max_unpool3d(const Tensor& input, const Tensor& indices,
- MaxUnpool3dFuncOptions options,
- const c10::optional<IntArrayRef>& output_size = c10::nullopt) {
+ const MaxUnpool3dFuncOptions& options) {
return detail::max_unpool3d(
input,
indices,
options.kernel_size(),
options.stride(),
options.padding(),
- output_size);
+ options.output_size());
}
// ============================================================================
@@ -516,7 +513,7 @@
}
} // namespace detail
-inline Tensor lp_pool1d(const Tensor& input, LPPool1dFuncOptions options) {
+inline Tensor lp_pool1d(const Tensor& input, const LPPool1dFuncOptions& options) {
return detail::lp_pool1d(
input,
options.norm_type(),
@@ -547,7 +544,7 @@
}
} // namespace detail
-inline Tensor lp_pool2d(const Tensor& input, LPPool2dFuncOptions options) {
+inline Tensor lp_pool2d(const Tensor& input, const LPPool2dFuncOptions& options) {
return detail::lp_pool2d(
input,
options.norm_type(),
diff --git a/torch/csrc/api/include/torch/nn/functional/upsampling.h b/torch/csrc/api/include/torch/nn/functional/upsampling.h
index ecf78fa..f8d0234 100644
--- a/torch/csrc/api/include/torch/nn/functional/upsampling.h
+++ b/torch/csrc/api/include/torch/nn/functional/upsampling.h
@@ -109,7 +109,7 @@
}
} // namespace detail
-inline Tensor interpolate(const Tensor& input, InterpolateFuncOptions options = {}) {
+inline Tensor interpolate(const Tensor& input, const InterpolateFuncOptions& options = {}) {
return detail::interpolate(
input,
options.size(),
diff --git a/torch/csrc/api/include/torch/nn/functional/vision.h b/torch/csrc/api/include/torch/nn/functional/vision.h
index 529678d..04e7693 100644
--- a/torch/csrc/api/include/torch/nn/functional/vision.h
+++ b/torch/csrc/api/include/torch/nn/functional/vision.h
@@ -104,7 +104,7 @@
inline Tensor grid_sample(
const Tensor& input,
const Tensor& grid,
- GridSampleFuncOptions options = {}) {
+ const GridSampleFuncOptions& options = {}) {
return detail::grid_sample(
input,
grid,
diff --git a/torch/csrc/api/include/torch/nn/modules/pooling.h b/torch/csrc/api/include/torch/nn/modules/pooling.h
index 57e69a8..a8e0c45 100644
--- a/torch/csrc/api/include/torch/nn/modules/pooling.h
+++ b/torch/csrc/api/include/torch/nn/modules/pooling.h
@@ -352,7 +352,7 @@
public:
using MaxUnpoolImpl<1, MaxUnpool1dImpl>::MaxUnpoolImpl;
Tensor forward(const Tensor& input, const Tensor& indices,
- const c10::optional<IntArrayRef>& output_size = c10::nullopt);
+ const c10::optional<std::vector<int64_t>>& output_size = c10::nullopt);
};
/// A `ModuleHolder` subclass for `MaxUnpool1dImpl`.
@@ -370,7 +370,7 @@
public:
using MaxUnpoolImpl<2, MaxUnpool2dImpl>::MaxUnpoolImpl;
Tensor forward(const Tensor& input, const Tensor& indices,
- const c10::optional<IntArrayRef>& output_size = c10::nullopt);
+ const c10::optional<std::vector<int64_t>>& output_size = c10::nullopt);
};
/// A `ModuleHolder` subclass for `MaxUnpool2dImpl`.
@@ -388,7 +388,7 @@
public:
using MaxUnpoolImpl<3, MaxUnpool3dImpl>::MaxUnpoolImpl;
Tensor forward(const Tensor& input, const Tensor& indices,
- const c10::optional<IntArrayRef>& output_size = c10::nullopt);
+ const c10::optional<std::vector<int64_t>>& output_size = c10::nullopt);
};
/// A `ModuleHolder` subclass for `MaxUnpool3dImpl`.
diff --git a/torch/csrc/api/include/torch/nn/options/activation.h b/torch/csrc/api/include/torch/nn/options/activation.h
index 17d70c7..f563daa 100644
--- a/torch/csrc/api/include/torch/nn/options/activation.h
+++ b/torch/csrc/api/include/torch/nn/options/activation.h
@@ -82,7 +82,23 @@
TORCH_ARG(int64_t, dim);
};
-TORCH_NN_FUNCTIONAL_USE_MODULE_OPTIONS(Softmax, SoftmaxFuncOptions)
+// ============================================================================
+
+namespace functional {
+
+struct TORCH_API SoftmaxFuncOptions {
+ SoftmaxFuncOptions(int64_t dim);
+
+ /// Dimension along which Softmax will be computed.
+ TORCH_ARG(int64_t, dim);
+
+ /// the desired data type of returned tensor.
+ /// If specified, the input tensor is casted to `dtype` before the operation
+ /// is performed. This is useful for preventing data type overflows. Default: None.
+ TORCH_ARG(c10::optional<torch::Dtype>, dtype) = c10::nullopt;
+};
+
+} // namespace functional
// ============================================================================
@@ -94,7 +110,23 @@
TORCH_ARG(int64_t, dim);
};
-TORCH_NN_FUNCTIONAL_USE_MODULE_OPTIONS(Softmin, SoftminFuncOptions)
+// ============================================================================
+
+namespace functional {
+
+struct TORCH_API SoftminFuncOptions {
+ SoftminFuncOptions(int64_t dim);
+
+ /// Dimension along which Softmin will be computed.
+ TORCH_ARG(int64_t, dim);
+
+ /// the desired data type of returned tensor.
+ /// If specified, the input tensor is casted to `dtype` before the operation
+ /// is performed. This is useful for preventing data type overflows. Default: None.
+ TORCH_ARG(c10::optional<torch::Dtype>, dtype) = c10::nullopt;
+};
+
+} // namespace functional
// ============================================================================
@@ -106,7 +138,23 @@
TORCH_ARG(int64_t, dim);
};
-TORCH_NN_FUNCTIONAL_USE_MODULE_OPTIONS(LogSoftmax, LogSoftmaxFuncOptions)
+// ============================================================================
+
+namespace functional {
+
+struct TORCH_API LogSoftmaxFuncOptions {
+ LogSoftmaxFuncOptions(int64_t dim);
+
+ /// Dimension along which LogSoftmax will be computed.
+ TORCH_ARG(int64_t, dim);
+
+ /// the desired data type of returned tensor.
+ /// If specified, the input tensor is casted to `dtype` before the operation
+ /// is performed. This is useful for preventing data type overflows. Default: None.
+ TORCH_ARG(c10::optional<torch::Dtype>, dtype) = c10::nullopt;
+};
+
+} // namespace functional
// ============================================================================
@@ -160,7 +208,24 @@
TORCH_ARG(bool, inplace) = false;
};
-TORCH_NN_FUNCTIONAL_USE_MODULE_OPTIONS(RReLU, RReLUFuncOptions)
+// ============================================================================
+
+namespace functional {
+
+struct TORCH_API RReLUFuncOptions {
+ /// lower bound of the uniform distribution. Default: 1/8
+ TORCH_ARG(double, lower) = 1.0 / 8.0;
+
+ /// upper bound of the uniform distribution. Default: 1/3
+ TORCH_ARG(double, upper) = 1.0 / 3.0;
+
+ TORCH_ARG(bool, training) = false;
+
+ /// can optionally do the operation in-place. Default: False
+ TORCH_ARG(bool, inplace) = false;
+};
+
+} // namespace functional
// ============================================================================
@@ -203,7 +268,7 @@
// ============================================================================
/// Options for Threshold functional and module.
-struct ThresholdOptions {
+struct TORCH_API ThresholdOptions {
ThresholdOptions(double threshold, double value)
: threshold_(threshold), value_(value) {}
@@ -224,7 +289,7 @@
namespace functional {
/// Options for Gumbel Softmax functional.
-struct GumbelSoftmaxFuncOptions {
+struct TORCH_API GumbelSoftmaxFuncOptions {
/// non-negative scalar temperature
TORCH_ARG(double, tau) = 1.0;
diff --git a/torch/csrc/api/include/torch/nn/options/batchnorm.h b/torch/csrc/api/include/torch/nn/options/batchnorm.h
index f39addd..8c755d1 100644
--- a/torch/csrc/api/include/torch/nn/options/batchnorm.h
+++ b/torch/csrc/api/include/torch/nn/options/batchnorm.h
@@ -47,6 +47,8 @@
TORCH_ARG(Tensor, bias) = Tensor();
+ TORCH_ARG(bool, training) = false;
+
/// A momentum multiplier for the mean and variance.
/// Changing this parameter after construction __is effective__.
TORCH_ARG(c10::optional<double>, momentum) = 0.1;
diff --git a/torch/csrc/api/include/torch/nn/options/normalization.h b/torch/csrc/api/include/torch/nn/options/normalization.h
index aab6768..e4eae8e 100644
--- a/torch/csrc/api/include/torch/nn/options/normalization.h
+++ b/torch/csrc/api/include/torch/nn/options/normalization.h
@@ -22,7 +22,25 @@
TORCH_ARG(bool, elementwise_affine) = true;
};
-TORCH_NN_FUNCTIONAL_USE_MODULE_OPTIONS(LayerNorm, LayerNormFuncOptions)
+// ============================================================================
+
+namespace functional {
+
+/// Options for the `LayerNorm` module.
+struct TORCH_API LayerNormFuncOptions {
+ /* implicit */ LayerNormFuncOptions(std::vector<int64_t> normalized_shape);
+ /// input shape from an expected input.
+ TORCH_ARG(std::vector<int64_t>, normalized_shape);
+
+ TORCH_ARG(Tensor, weight) = {};
+
+ TORCH_ARG(Tensor, bias) = {};
+
+ /// a value added to the denominator for numerical stability. ``Default: 1e-5``.
+ TORCH_ARG(double, eps) = 1e-5;
+};
+
+} // namespace functional
// ============================================================================
@@ -72,6 +90,9 @@
TORCH_ARG(int64_t, dim) = 1;
/// Small value to avoid division by zero. Default: 1e-12
TORCH_ARG(double, eps) = 1e-12;
+ /// the output tensor. If `out` is used, this
+ /// operation won't be differentiable.
+ TORCH_ARG(c10::optional<Tensor>, out) = c10::nullopt;
};
} // namespace functional
diff --git a/torch/csrc/api/include/torch/nn/options/pooling.h b/torch/csrc/api/include/torch/nn/options/pooling.h
index 6606289..cd09f7f 100644
--- a/torch/csrc/api/include/torch/nn/options/pooling.h
+++ b/torch/csrc/api/include/torch/nn/options/pooling.h
@@ -136,7 +136,7 @@
// ============================================================================
-/// Options for a `D`-dimensional maxunpool functional and module.
+/// Options for a `D`-dimensional maxunpool module.
template <size_t D>
struct MaxUnpoolOptions {
MaxUnpoolOptions(ExpandingArray<D> kernel_size)
@@ -161,9 +161,39 @@
/// `MaxUnpoolOptions` specialized for 3-D maxunpool.
using MaxUnpool3dOptions = MaxUnpoolOptions<3>;
-TORCH_NN_FUNCTIONAL_USE_MODULE_OPTIONS(MaxUnpool1d, MaxUnpool1dFuncOptions)
-TORCH_NN_FUNCTIONAL_USE_MODULE_OPTIONS(MaxUnpool2d, MaxUnpool2dFuncOptions)
-TORCH_NN_FUNCTIONAL_USE_MODULE_OPTIONS(MaxUnpool3d, MaxUnpool3dFuncOptions)
+// ============================================================================
+
+namespace functional {
+
+/// Options for a `D`-dimensional maxunpool functional.
+template <size_t D>
+struct MaxUnpoolFuncOptions {
+ MaxUnpoolFuncOptions(ExpandingArray<D> kernel_size)
+ : kernel_size_(kernel_size), stride_(kernel_size) {}
+
+ /// the size of the window to take a max over
+ TORCH_ARG(ExpandingArray<D>, kernel_size);
+
+ /// the stride of the window. Default value is `kernel_size
+ TORCH_ARG(ExpandingArray<D>, stride);
+
+ /// implicit zero padding to be added on both sides
+ TORCH_ARG(ExpandingArray<D>, padding) = 0;
+
+ /// the targeted output size
+ TORCH_ARG(c10::optional<std::vector<int64_t>>, output_size) = c10::nullopt;
+};
+
+/// `MaxUnpoolFuncOptions` specialized for 1-D maxunpool.
+using MaxUnpool1dFuncOptions = MaxUnpoolFuncOptions<1>;
+
+/// `MaxUnpoolFuncOptions` specialized for 2-D maxunpool.
+using MaxUnpool2dFuncOptions = MaxUnpoolFuncOptions<2>;
+
+/// `MaxUnpoolFuncOptions` specialized for 3-D maxunpool.
+using MaxUnpool3dFuncOptions = MaxUnpoolFuncOptions<3>;
+
+} // namespace functional
// ============================================================================
diff --git a/torch/csrc/api/src/nn/modules/activation.cpp b/torch/csrc/api/src/nn/modules/activation.cpp
index d808150..e24ff8a 100644
--- a/torch/csrc/api/src/nn/modules/activation.cpp
+++ b/torch/csrc/api/src/nn/modules/activation.cpp
@@ -233,7 +233,7 @@
RReLUImpl::RReLUImpl(const RReLUOptions& options_) : options(options_) {}
Tensor RReLUImpl::forward(Tensor input) {
- return F::detail::rrelu(input, options.lower(), options.upper(), options.inplace(), is_training());
+ return F::detail::rrelu(input, options.lower(), options.upper(), is_training(), options.inplace());
}
void RReLUImpl::reset() {}
diff --git a/torch/csrc/api/src/nn/modules/pooling.cpp b/torch/csrc/api/src/nn/modules/pooling.cpp
index a550411..9ff7893 100644
--- a/torch/csrc/api/src/nn/modules/pooling.cpp
+++ b/torch/csrc/api/src/nn/modules/pooling.cpp
@@ -235,7 +235,7 @@
}
Tensor MaxUnpool1dImpl::forward(const Tensor& input, const Tensor& indices,
- const c10::optional<IntArrayRef>& output_size) {
+ const c10::optional<std::vector<int64_t>>& output_size) {
return F::detail::max_unpool1d(
input,
indices,
@@ -246,7 +246,7 @@
}
Tensor MaxUnpool2dImpl::forward(const Tensor& input, const Tensor& indices,
- const c10::optional<IntArrayRef>& output_size) {
+ const c10::optional<std::vector<int64_t>>& output_size) {
return F::detail::max_unpool2d(
input,
indices,
@@ -257,7 +257,7 @@
}
Tensor MaxUnpool3dImpl::forward(const Tensor& input, const Tensor& indices,
- const c10::optional<IntArrayRef>& output_size) {
+ const c10::optional<std::vector<int64_t>>& output_size) {
return F::detail::max_unpool3d(
input,
indices,
diff --git a/torch/csrc/api/src/nn/options/activation.cpp b/torch/csrc/api/src/nn/options/activation.cpp
index 1192ebb..88c39d2 100644
--- a/torch/csrc/api/src/nn/options/activation.cpp
+++ b/torch/csrc/api/src/nn/options/activation.cpp
@@ -19,5 +19,15 @@
SoftshrinkOptions::SoftshrinkOptions(double lambda) : lambda_(lambda) {}
+namespace functional {
+
+SoftmaxFuncOptions::SoftmaxFuncOptions(int64_t dim) : dim_(dim) {}
+
+SoftminFuncOptions::SoftminFuncOptions(int64_t dim) : dim_(dim) {}
+
+LogSoftmaxFuncOptions::LogSoftmaxFuncOptions(int64_t dim) : dim_(dim) {}
+
+} // namespace functional
+
} // namespace nn
} // namespace torch
diff --git a/torch/csrc/api/src/nn/options/normalization.cpp b/torch/csrc/api/src/nn/options/normalization.cpp
index 22ea16d..4b7571a 100644
--- a/torch/csrc/api/src/nn/options/normalization.cpp
+++ b/torch/csrc/api/src/nn/options/normalization.cpp
@@ -7,5 +7,11 @@
CrossMapLRN2dOptions::CrossMapLRN2dOptions(int64_t size) : size_(size) {}
+namespace functional {
+
+LayerNormFuncOptions::LayerNormFuncOptions(std::vector<int64_t> normalized_shape) : normalized_shape_(std::move(normalized_shape)) {}
+
+} // namespace functional
+
} // namespace nn
} // namespace torch
