Tensor construction codemod(ResizeLike) - 5/7 (#15084)

Summary:
Pull Request resolved: https://github.com/pytorch/pytorch/pull/15084

Codemod generated with clangr shard mode, 25 files per diff,
motivation: https://github.com/pytorch/pytorch/pull/12407

Reviewed By: ezyang

Differential Revision: D13419711

fbshipit-source-id: dd2b740c3f13d8087085bafc5571aaf908d1af42

diff --git a/caffe2/operators/h_softmax_op.cc b/caffe2/operators/h_softmax_op.cc
index cb7a5f2..24555c4 100644 (file)
--- a/caffe2/operators/h_softmax_op.cc
+++ b/caffe2/operators/h_softmax_op.cc
@@ -194,14 +194,12 @@ bool HSoftmaxGradientOp<float, CPUContext>::RunOnDevice() {
   auto& label = Input(3);
   auto& intermediate_output = Input(4);
   auto& dY = Input(5);
-  auto* dX = Output(0);
-  auto* dW = Output(1);
-  auto* db = Output(2);
-  auto* dX_intermediate_output = Output(3);
-  dX->ResizeLike(X);
-  dW->ResizeLike(W);
-  db->ResizeLike(b);
-  dX_intermediate_output->ResizeLike(intermediate_output);
+
+  auto* dX = Output(0, X.sizes(), at::dtype<float>());
+  auto* dW = Output(1, W.sizes(), at::dtype<float>());
+  auto* db = Output(2, b.sizes(), at::dtype<float>());
+  auto* dX_intermediate_output =
+      Output(3, intermediate_output.sizes(), at::dtype<float>());
 
   float* dX_data = dX->template mutable_data<float>();
   float* dW_data = dW->template mutable_data<float>();

diff --git a/caffe2/operators/im2col_op.h b/caffe2/operators/im2col_op.h
index 6352c3a..d63acd7 100644 (file)
--- a/caffe2/operators/im2col_op.h
+++ b/caffe2/operators/im2col_op.h
@@ -192,8 +192,8 @@ class Col2ImOp final : public Operator<Context> {
   bool RunOnDevice() override {
     auto& X = Input(0);
     auto& Z = Input(1);
-    auto* Y = Output(0);
-    Y->ResizeLike(Z);
+
+    auto* Y = Output(0, Z.sizes(), at::dtype<T>());
     CAFFE_ENFORCE(4 == Y->dim());
 
     int N = 0, C = 0, H = 0, W = 0;

diff --git a/caffe2/operators/index_hash_ops.h b/caffe2/operators/index_hash_ops.h
index 44c8eba..9c9ad5b 100644 (file)
--- a/caffe2/operators/index_hash_ops.h
+++ b/caffe2/operators/index_hash_ops.h
@@ -26,8 +26,9 @@ class IndexHashOp : public Operator<Context> {
   template <typename T>
   bool DoRunWithType() {
     auto& indices = Input(INDICES);
-    auto* hashed_indices = Output(HASHED_INDICES);
-    hashed_indices->ResizeLike(indices);
+
+    auto* hashed_indices =
+        Output(HASHED_INDICES, indices.sizes(), at::dtype<T>());
 
     CAFFE_ENFORCE_GE(
         static_cast<int64_t>(std::numeric_limits<T>::max()),

diff --git a/caffe2/operators/index_ops.cc b/caffe2/operators/index_ops.cc
index 3278b7d..912912a 100644 (file)
--- a/caffe2/operators/index_ops.cc
+++ b/caffe2/operators/index_ops.cc
@@ -45,8 +45,8 @@ class IndexGetOp: public Operator<CPUContext> {
     auto* dict = dynamic_cast_if_rtti<Index<T>*>(base.get());
     CAFFE_ENFORCE(dict, "Wrong dictionary type given input keys.");
     const auto& keys = Input(1);
-    auto* values = Output(0);
-    values->ResizeLike(keys);
+
+    auto* values = Output(0, keys.sizes(), at::dtype<int64_tValue>());
     dict->Get(
         keys.data<T>(),
         values->template mutable_data<int64_tValue>(),

diff --git a/caffe2/operators/instance_norm_gradient_op.cc b/caffe2/operators/instance_norm_gradient_op.cc
index 16fe0c9..20d610a 100644 (file)
--- a/caffe2/operators/instance_norm_gradient_op.cc
+++ b/caffe2/operators/instance_norm_gradient_op.cc
@@ -11,9 +11,7 @@ bool InstanceNormGradientOp<T, Context>::RunOnDeviceWithOrderNHWC() {
   const auto& output_grad = Input(OUTPUT_GRAD);
   const auto& mean = InputSize() >= 5 ? Input(MEAN) : mean_;
   const auto& inv_stdev = InputSize() >= 6 ? Input(INV_STDEV) : inv_stdev_;
-  auto input_grad = Output(INPUT_GRAD);
-  auto scale_grad = Output(SCALE_GRAD);
-  auto bias_grad = Output(BIAS_GRAD);
+
   CAFFE_ENFORCE_EQ(4, input.dim());
   const int N = input.dim32(0);
   const int H = input.dim32(1);
@@ -28,9 +26,9 @@ bool InstanceNormGradientOp<T, Context>::RunOnDeviceWithOrderNHWC() {
   CAFFE_ENFORCE_EQ(H, output_grad.dim32(1));
   CAFFE_ENFORCE_EQ(W, output_grad.dim32(2));
   CAFFE_ENFORCE_EQ(C, output_grad.dim32(3));
-  input_grad->ResizeLike(input);
-  scale_grad->ResizeLike(scale);
-  bias_grad->ResizeLike(bias);
+  auto input_grad = Output(INPUT_GRAD, input.sizes(), at::dtype<T>());
+  auto scale_grad = Output(SCALE_GRAD, scale.sizes(), at::dtype<T>());
+  auto bias_grad = Output(BIAS_GRAD, bias.sizes(), at::dtype<T>());
 
   ConstEigenVectorArrayMap<T> scale_arr(scale.template data<T>(), C);
   ConstEigenVectorArrayMap<T> bias_arr(bias.template data<T>(), C);
@@ -142,9 +140,7 @@ bool InstanceNormGradientOp<T, Context>::RunOnDeviceWithOrderNCHW() {
   const auto& output_grad = Input(OUTPUT_GRAD);
   const auto& mean = InputSize() >= 5 ? Input(MEAN) : mean_;
   const auto& inv_stdev = InputSize() >= 6 ? Input(INV_STDEV) : inv_stdev_;
-  auto input_grad = Output(INPUT_GRAD);
-  auto scale_grad = Output(SCALE_GRAD);
-  auto bias_grad = Output(BIAS_GRAD);
+
   CAFFE_ENFORCE_EQ(4, input.dim());
   const int N = input.dim32(0);
   const int C = input.dim32(1);
@@ -159,9 +155,9 @@ bool InstanceNormGradientOp<T, Context>::RunOnDeviceWithOrderNCHW() {
   CAFFE_ENFORCE_EQ(C, output_grad.dim32(1));
   CAFFE_ENFORCE_EQ(H, output_grad.dim32(2));
   CAFFE_ENFORCE_EQ(W, output_grad.dim32(3));
-  input_grad->ResizeLike(input);
-  scale_grad->ResizeLike(scale);
-  bias_grad->ResizeLike(bias);
+  auto input_grad = Output(INPUT_GRAD, input.sizes(), at::dtype<T>());
+  auto scale_grad = Output(SCALE_GRAD, scale.sizes(), at::dtype<T>());
+  auto bias_grad = Output(BIAS_GRAD, bias.sizes(), at::dtype<T>());
 
   ConstEigenArrayMap<T> input_mat(input.template data<T>(), H * W, N * C);
   ConstEigenVectorArrayMap<T> scale_arr(scale.template data<T>(), C);

diff --git a/caffe2/operators/instance_norm_op.cc b/caffe2/operators/instance_norm_op.cc
index d406a29..5730cef 100644 (file)
--- a/caffe2/operators/instance_norm_op.cc
+++ b/caffe2/operators/instance_norm_op.cc
@@ -11,8 +11,10 @@ namespace caffe2 {
 template <typename T, typename Context>
 bool InstanceNormOp<T, Context>::RunOnDeviceWithOrderNHWC() {
   const auto& X = Input(INPUT);
-  auto* Y = Output(OUTPUT);
-  CAFFE_ENFORCE(Y != &X, "Can't run InstanceNorm NHWC in-place");
+
+  CAFFE_ENFORCE(
+      !IsInputOutputAlias(INPUT, OUTPUT),
+      "Can't run InstanceNorm NHWC in-place");
   auto* mean = OutputSize() > 1 ? Output(MEAN) : &mean_;
   auto* inv_stdev = OutputSize() > 1 ? Output(INV_STDEV) : &inv_stdev_;
   const int N = X.dim32(0);
@@ -24,7 +26,7 @@ bool InstanceNormOp<T, Context>::RunOnDeviceWithOrderNHWC() {
   CAFFE_ENFORCE_EQ(Input(SCALE).numel(), C);
   CAFFE_ENFORCE_EQ(Input(BIAS).numel(), C);
 
-  Y->ResizeLike(X);
+  auto* Y = Output(OUTPUT, X.sizes(), at::dtype<T>());
   mean->Resize(N, C);
   inv_stdev->Resize(N, C);
   ConstEigenVectorArrayMap<T> scale(Input(SCALE).template data<T>(), C);
@@ -63,7 +65,7 @@ bool InstanceNormOp<T, Context>::RunOnDeviceWithOrderNCHW() {
   const auto& X = Input(INPUT);
   const auto& scale = Input(SCALE);
   const auto& bias = Input(BIAS);
-  auto* Y = Output(OUTPUT);
+
   auto* mean = OutputSize() > 1 ? Output(MEAN) : &mean_;
   auto* inv_stdev = OutputSize() > 1 ? Output(INV_STDEV) : &inv_stdev_;
   const int N = X.dim32(0);
@@ -74,7 +76,7 @@ bool InstanceNormOp<T, Context>::RunOnDeviceWithOrderNCHW() {
   CAFFE_ENFORCE_EQ(scale.numel(), C);
   CAFFE_ENFORCE_EQ(bias.numel(), C);
 
-  Y->ResizeLike(X);
+  auto* Y = Output(OUTPUT, X.sizes(), at::dtype<T>());
   mean->Resize(N, C);
   inv_stdev->Resize(N, C);
 

diff --git a/caffe2/operators/integral_image_op.cc b/caffe2/operators/integral_image_op.cc
index 6523c85..7ae82cd 100644 (file)
--- a/caffe2/operators/integral_image_op.cc
+++ b/caffe2/operators/integral_image_op.cc
@@ -72,10 +72,10 @@ bool IntegralImageGradientOp<float, CPUContext>::RunOnDevice() {
   auto& X = Input(0); // Original input to "forward" op
   auto& dY = Input(1); // Gradient of net w.r.t. output of "forward" op
   // (aka "gradOutput")
-  auto* dX = Output(0); // Gradient of net w.r.t. input to "forward" op
-  // (aka "gradInput")
+  auto* dX = Output(
+      0, X.sizes(), at::dtype<float>()); // Gradient of net w.r.t. input to
+                                         // "forward" op (aka "gradInput")
 
-  dX->ResizeLike(X);
   const int ind = X.dim32(0);
   const int chans = X.dim32(1);
   const int rows_in = dY.dim32(2);

diff --git a/caffe2/operators/jsd_op.cc b/caffe2/operators/jsd_op.cc
index 002bccb..7595c9d 100644 (file)
--- a/caffe2/operators/jsd_op.cc
+++ b/caffe2/operators/jsd_op.cc
@@ -29,10 +29,9 @@ template <>
 bool BernoulliJSDOp<float, CPUContext>::RunOnDevice() {
   auto& X = Input(0); // predicted probabilities
   auto& T = Input(1); // target probabilities
-  auto* L = Output(0); // JSD loss output
   int N = X.numel();
   CAFFE_ENFORCE_EQ(T.numel(), N);
-  L->ResizeLike(X);
+  auto* L = Output(0, X.sizes(), at::dtype<float>()); // JSD loss output
   auto* x_data = X.data<float>();
   auto* t_data = T.data<float>();
   auto* l_data = L->template mutable_data<float>();
@@ -51,9 +50,9 @@ bool BernoulliJSDGradientOp<float, CPUContext>::RunOnDevice() {
   auto& go = Input(0);
   auto& X = Input(1);
   auto& T = Input(2);
-  auto* gi = Output(0);
+
   int N = X.numel();
-  gi->ResizeLike(X);
+  auto* gi = Output(0, X.sizes(), at::dtype<float>());
   auto* go_data = go.data<float>();
   auto* x_data = X.data<float>();
   auto* t_data = T.data<float>();

diff --git a/caffe2/operators/layer_norm_op.h b/caffe2/operators/layer_norm_op.h
index 2155d9b..d47064e 100644 (file)
--- a/caffe2/operators/layer_norm_op.h
+++ b/caffe2/operators/layer_norm_op.h
@@ -126,12 +126,12 @@ class LayerNormGradientOp final : public Operator<Context> {
     const auto& mean = Input(2);
     const auto& sig = Input(3);
     const auto& X = Input(4);
-    auto* dX = Output(0);
+
     const int canonical_axis = X.canonical_axis_index(axis_);
     const int M = X.size_to_dim(canonical_axis);
     const int N = X.size_from_dim(canonical_axis);
 
-    dX->ResizeLike(X);
+    auto* dX = Output(0, X.sizes(), at::dtype<T>());
     ds_.Resize(M);
     db_.Resize(M);
     dY_scale_.Resize(M);

diff --git a/caffe2/operators/leaky_relu_op.cc b/caffe2/operators/leaky_relu_op.cc
index eb28590..004dbad 100644 (file)
--- a/caffe2/operators/leaky_relu_op.cc
+++ b/caffe2/operators/leaky_relu_op.cc
@@ -8,8 +8,8 @@ namespace caffe2 {
 template <>
 bool LeakyReluOp<float, CPUContext>::RunOnDevice() {
   const auto& X = Input(0);
-  auto* Y = Output(0);
-  Y->ResizeLike(X);
+
+  auto* Y = Output(0, X.sizes(), at::dtype<float>());
   ConstEigenVectorMap<float> Xvec(X.template data<float>(), X.numel());
   EigenVectorMap<float> Yvec(Y->template mutable_data<float>(), Y->numel());
   Yvec = Xvec.cwiseMax(0.f) + Xvec.cwiseMin(0.f) * alpha_;
@@ -20,8 +20,8 @@ template <>
 bool LeakyReluGradientOp<float, CPUContext>::RunOnDevice() {
   const auto& Y = Input(0);
   const auto& dY = Input(1);
-  auto* dX = Output(0);
-  dX->ResizeLike(Y);
+
+  auto* dX = Output(0, Y.sizes(), at::dtype<float>());
   CAFFE_ENFORCE_EQ(Y.numel(), dY.numel());
   ConstEigenVectorMap<float> Yvec(Y.template data<float>(), Y.numel());
   ConstEigenVectorMap<float> dYvec(dY.template data<float>(), dY.numel());

diff --git a/caffe2/operators/lengths_reducer_rowwise_8bit_ops.h b/caffe2/operators/lengths_reducer_rowwise_8bit_ops.h
index 4c78ce8..adf3dcc 100644 (file)
--- a/caffe2/operators/lengths_reducer_rowwise_8bit_ops.h
+++ b/caffe2/operators/lengths_reducer_rowwise_8bit_ops.h
@@ -102,10 +102,9 @@ class FloatToRowwiseQuantized8BitsOp : public Operator<Context> {
   USE_SIMPLE_CTOR_DTOR(FloatToRowwiseQuantized8BitsOp);
   bool RunOnDevice() override {
     auto& input = Input(DATA_FLOAT);
-    auto* output = Output(DATA_UINT8);
 
     auto* input_data = input.template data<float>();
-    output->ResizeLike(input);
+    auto* output = Output(DATA_UINT8, input.sizes(), at::dtype<uint8_t>());
     vector<int64_t> scale_bias_dims = {input.size(0), 2};
     auto* scale_bias = Output(SCALE_BIAS, scale_bias_dims, at::dtype<float>());
     auto* output_data = output->template mutable_data<uint8_t>();
@@ -148,7 +147,7 @@ class Rowwise8BitQuantizedToFloatOp : public Operator<Context> {
   bool RunOnDevice() override {
     auto& input = Input(DATA_UINT8);
     auto& scale_bias = Input(SCALE_BIAS);
-    auto* output = Output(DATA_FLOAT);
+
     CAFFE_ENFORCE_EQ(2, scale_bias.dim(), "scale_bias has to be matrix");
     CAFFE_ENFORCE_EQ(
         input.size(0),
@@ -158,7 +157,7 @@ class Rowwise8BitQuantizedToFloatOp : public Operator<Context> {
         2,
         scale_bias.size(1),
         "the second dim of scale_bias has to be equal to 2");
-    output->ResizeLike(input);
+    auto* output = Output(DATA_FLOAT, input.sizes(), at::dtype<float>());
     auto* input_data = input.template data<uint8_t>();
     auto* scale_bias_data = scale_bias.template data<float>();
 

diff --git a/caffe2/operators/local_response_normalization_op.cc b/caffe2/operators/local_response_normalization_op.cc
index a0637e3..e6b079b 100644 (file)
--- a/caffe2/operators/local_response_normalization_op.cc
+++ b/caffe2/operators/local_response_normalization_op.cc
@@ -6,7 +6,7 @@ template<>
 bool LRNOp<float, CPUContext>::RunOnDeviceWithOrderNCHW() {
   // Note(Yangqing): this one is copied from my Caffe implementation.
   auto& X = Input(0);
-  auto* Y = Output(0);
+
   DCHECK_EQ(X.dim(), 4);
   const int N = X.dim32(0);
   const int C = X.dim32(1);
@@ -14,7 +14,7 @@ bool LRNOp<float, CPUContext>::RunOnDeviceWithOrderNCHW() {
   const int W = X.dim32(3);
   const int image_size = C * H * W;
   const float* Xdata = X.data<float>();
-  Y->ResizeLike(X);
+  auto* Y = Output(0, X.sizes(), at::dtype<float>());
   float* Ydata = Y->template mutable_data<float>();
 
   if (OutputSize() > 1) {
@@ -70,7 +70,7 @@ bool LRNOp<float, CPUContext>::RunOnDeviceWithOrderNHWC() {
   // Note(Yangqing): This one is copied from my Decaf implementation. How many
   // variants have I written...?
   auto& X = Input(0);
-  auto* Y = Output(0);
+
   DCHECK_EQ(X.dim(), 4);
   const int N = X.dim32(0);
   const int H = X.dim32(1);
@@ -78,7 +78,7 @@ bool LRNOp<float, CPUContext>::RunOnDeviceWithOrderNHWC() {
   const int C = X.dim32(3);
   const int num_rows = N * H * W;
   const float* Xdata = X.data<float>();
-  Y->ResizeLike(X);
+  auto* Y = Output(0, X.sizes(), at::dtype<float>());
   float* Ydata = Y->template mutable_data<float>();
 
   if (OutputSize() > 1) {
@@ -123,7 +123,7 @@ bool LRNGradientOp<float, CPUContext>::RunOnDeviceWithOrderNCHW() {
   auto& X = Input(0);
   auto& Y = Input(1);
   auto& dY = Input(2);
-  auto* dX = Output(0);
+
   DCHECK_EQ(X.dim(), 4);
   const int N = X.dim32(0);
   const int C = X.dim32(1);
@@ -134,7 +134,7 @@ bool LRNGradientOp<float, CPUContext>::RunOnDeviceWithOrderNCHW() {
   // long as the sizes check out.
   DCHECK_EQ(X.numel(), Y.numel());
   DCHECK_EQ(X.numel(), dY.numel());
-  dX->ResizeLike(X);
+  auto* dX = Output(0, X.sizes(), at::dtype<float>());
 
   const float* Xdata = X.data<float>();
   const float* Ydata = Y.data<float>();
@@ -226,7 +226,7 @@ bool LRNGradientOp<float, CPUContext>::RunOnDeviceWithOrderNHWC() {
   auto& X = Input(0);
   auto& Y = Input(1);
   auto& dY = Input(2);
-  auto* dX = Output(0);
+
   DCHECK_EQ(X.dim(), 4);
   const int N = X.dim32(0);
   const int H = X.dim32(1);
@@ -238,7 +238,7 @@ bool LRNGradientOp<float, CPUContext>::RunOnDeviceWithOrderNHWC() {
   // long as the sizes check out.
   DCHECK_EQ(X.numel(), Y.numel());
   DCHECK_EQ(X.numel(), dY.numel());
-  dX->ResizeLike(X);
+  auto* dX = Output(0, X.sizes(), at::dtype<float>());
   if (!scale_) {
     scale_ = &local_scale_tensor_;
   }

diff --git a/caffe2/operators/locally_connected_op_impl.h b/caffe2/operators/locally_connected_op_impl.h
index 293ced9..df05cad 100644 (file)
--- a/caffe2/operators/locally_connected_op_impl.h
+++ b/caffe2/operators/locally_connected_op_impl.h
@@ -372,7 +372,7 @@ bool LocallyConnectedGradientOp<T, Context>::RunOnDeviceWithOrderNCHW() {
   const auto& X = Input(INPUT);
   const auto& filter = Input(FILTER);
   const auto& dY = Input(OUTPUT_GRAD);
-  auto* dfilter = Output(FILTER_GRAD);
+
   const int image_ndim = X.dim() - 2;
   CAFFE_ENFORCE_EQ(X.dim() + image_ndim, filter.dim());
 
@@ -419,7 +419,7 @@ bool LocallyConnectedGradientOp<T, Context>::RunOnDeviceWithOrderNCHW() {
       &shape.Y_transposed_dims,
       &shape.Y_axes);
 
-  dfilter->ResizeLike(filter);
+  auto* dfilter = Output(FILTER_GRAD, filter.sizes(), at::dtype<T>());
   const T* X_data = X.template data<T>();
   const T* filter_data = filter.template data<T>();
   const T* dY_data = dY.template data<T>();
@@ -427,8 +427,8 @@ bool LocallyConnectedGradientOp<T, Context>::RunOnDeviceWithOrderNCHW() {
   T* dX_data = nullptr;
   T* dbias_data = nullptr;
   if (OutputSize() == 3 || (no_bias_ && OutputSize() == 2)) {
-    auto* dX = Output(no_bias_ ? BIAS_OR_INPUT_GRAD : INPUT_GRAD);
-    dX->ResizeLike(X);
+    auto* dX = Output(
+        no_bias_ ? BIAS_OR_INPUT_GRAD : INPUT_GRAD, X.sizes(), at::dtype<T>());
     dX_data = dX->template mutable_data<T>();
   }
   if (!no_bias_) {
@@ -463,7 +463,7 @@ bool LocallyConnectedGradientOp<T, Context>::RunOnDeviceWithOrderNHWC() {
   const auto& X = Input(INPUT);
   const auto& filter = Input(FILTER);
   const auto& dY = Input(OUTPUT_GRAD);
-  auto* dfilter = Output(FILTER_GRAD);
+
   CAFFE_ENFORCE_EQ(
       kernel_.size(),
       2,
@@ -508,7 +508,7 @@ bool LocallyConnectedGradientOp<T, Context>::RunOnDeviceWithOrderNHWC() {
       &shape.Y_transposed_dims,
       &shape.Y_axes);
 
-  dfilter->ResizeLike(filter);
+  auto* dfilter = Output(FILTER_GRAD, filter.sizes(), at::dtype<T>());
   const T* X_data = X.template data<T>();
   const T* filter_data = filter.template data<T>();
   const T* dY_data = dY.template data<T>();
@@ -516,8 +516,8 @@ bool LocallyConnectedGradientOp<T, Context>::RunOnDeviceWithOrderNHWC() {
   T* dX_data = nullptr;
   T* dbias_data = nullptr;
   if (OutputSize() == 3 || (no_bias_ && OutputSize() == 2)) {
-    auto* dX = Output(no_bias_ ? BIAS_OR_INPUT_GRAD : INPUT_GRAD);
-    dX->ResizeLike(X);
+    auto* dX = Output(
+        no_bias_ ? BIAS_OR_INPUT_GRAD : INPUT_GRAD, X.sizes(), at::dtype<T>());
     dX_data = dX->template mutable_data<T>();
   }
   if (!no_bias_) {

diff --git a/caffe2/operators/logit_op.cc b/caffe2/operators/logit_op.cc
index 79dd9f2..f4d9cb4 100644 (file)
--- a/caffe2/operators/logit_op.cc
+++ b/caffe2/operators/logit_op.cc
@@ -24,8 +24,8 @@ template <>
 bool LogitGradientOp<float, CPUContext>::RunOnDevice() {
   const auto& X = Input(0);
   const auto& dY = Input(1);
-  auto* dX = Output(0);
-  dX->ResizeLike(X);
+
+  auto* dX = Output(0, X.sizes(), at::dtype<float>());
   int channels = X.dim32(X.dim() - 1);
   ConstEigenArrayMap<float> Xmat(
       X.template data<float>(), channels, X.numel() / channels);

diff --git a/caffe2/operators/lp_pool_op.cc b/caffe2/operators/lp_pool_op.cc
index 5c120e5..03881bc 100644 (file)
--- a/caffe2/operators/lp_pool_op.cc
+++ b/caffe2/operators/lp_pool_op.cc
@@ -108,12 +108,12 @@ bool PoolGradientOp<float, CPUContext, LpPool>::RunOnDeviceWithOrderNCHW() {
   const auto& X = Input(0);
   const auto& Y = Input(1);
   auto& dY = Input(2);
-  auto* dX = Output(0);
+
   const auto p = OperatorBase::GetSingleArgument<float>("p", 2.0);
   const auto inv_p = 1.0 / p;
 
   // TODO(Yangqing): Add shape checks.
-  dX->ResizeLike(X);
+  auto* dX = Output(0, X.sizes(), at::dtype<float>());
   math::Set<float, CPUContext>(
       X.numel(), 0, dX->template mutable_data<float>(), &context_);
   const float* dYdata = dY.data<float>();
@@ -167,9 +167,9 @@ bool PoolGradientOp<float, CPUContext, LpPool>::RunOnDeviceWithOrderNHWC() {
   const auto& Y = Input(1);
   auto& dY = Input(2);
   CAFFE_ENFORCE_EQ(dY.dim(), 4);
-  auto* dX = Output(0);
+
   // TODO(Yangqing): Add shape checks.
-  dX->ResizeLike(X);
+  auto* dX = Output(0, X.sizes(), at::dtype<float>());
   math::Set<float, CPUContext>(
       X.numel(), 0, dX->template mutable_data<float>(), &context_);
   const float* dYdata = dY.data<float>();

diff --git a/caffe2/operators/lpnorm_op.cc b/caffe2/operators/lpnorm_op.cc
index 0add1bc..3321806 100644 (file)
--- a/caffe2/operators/lpnorm_op.cc
+++ b/caffe2/operators/lpnorm_op.cc
@@ -32,10 +32,10 @@ template <>
 bool LpNormGradientOp<float, CPUContext>::RunOnDevice() {
   const auto& X = Input(0);
   const auto& dnorm = Input(1);
-  auto* dX = Output(0);
+
   CAFFE_ENFORCE_EQ(dnorm.dim(), 1);
   CAFFE_ENFORCE_EQ(dnorm.dim32(0), 1);
-  dX->ResizeLike(X);
+  auto* dX = Output(0, X.sizes(), at::dtype<float>());
   const float size = average_ ? (float)X.numel() : 1.0f;
   if (p_ == 1) {
     EigenVectorMap<float>(dX->template mutable_data<float>(), X.numel())

diff --git a/caffe2/operators/margin_ranking_criterion_op.cc b/caffe2/operators/margin_ranking_criterion_op.cc
index 25f5d5a..e8a3f33 100644 (file)
--- a/caffe2/operators/margin_ranking_criterion_op.cc
+++ b/caffe2/operators/margin_ranking_criterion_op.cc
@@ -11,14 +11,14 @@ bool MarginRankingCriterionOp<CPUContext>::RunOnDevice() {
   auto& X1 = Input(0);
   auto& X2 = Input(1);
   auto& Y = Input(2);
-  auto* loss = Output(0);
+
   CAFFE_ENFORCE_EQ(
       X1.numel(),
       X2.numel(),
       "The two inputs for computing ranking loss should have the same size.");
   CAFFE_ENFORCE_EQ(
       X1.numel(), Y.numel(), "The input and label should have the same size.");
-  loss->ResizeLike(X1);
+  auto* loss = Output(0, X1.sizes(), at::dtype<float>());
 
   const float* X1data = X1.data<float>();
   const float* X2data = X2.data<float>();
@@ -36,11 +36,9 @@ bool MarginRankingCriterionGradientOp<CPUContext>::RunOnDevice() {
   auto& X2 = Input(1);
   auto& Y = Input(2);
   auto& dLoss = Input(3);
-  auto* dX1 = Output(0);
-  auto* dX2 = Output(1);
 
-  dX1->ResizeLike(X1);
-  dX2->ResizeLike(X2);
+  auto* dX1 = Output(0, X1.sizes(), at::dtype<float>());
+  auto* dX2 = Output(1, X2.sizes(), at::dtype<float>());
 
   const float* X1data = X1.data<float>();
   const float* X2data = X2.data<float>();

diff --git a/caffe2/operators/mean_op.h b/caffe2/operators/mean_op.h
index 0a5d072..536b460 100644 (file)
--- a/caffe2/operators/mean_op.h
+++ b/caffe2/operators/mean_op.h
@@ -20,9 +20,8 @@ class MeanOp final : public Operator<Context> {
   template <typename T>
   bool DoRunWithType() {
     auto& input0 = Input(0);
-    auto* output = Output(0);
 
-    output->ResizeLike(input0);
+    auto* output = Output(0, input0.sizes(), at::dtype<T>());
     output->CopyFrom(input0, true /*async*/);
 
     if (InputSize() == 1) {
@@ -93,8 +92,8 @@ class MeanGradientOp : public Operator<Context> {
     float scale = 1.0f / num_inputs;
 
     // dX0 = scale * dY
-    auto* dX0 = Output(0);
-    dX0->ResizeLike(dY);
+
+    auto* dX0 = Output(0, dY.sizes(), at::dtype<T>());
     math::Scale(
         size, scale, dY_data, dX0->template mutable_data<T>(), &context_);
 

diff --git a/caffe2/operators/merge_id_lists_op.h b/caffe2/operators/merge_id_lists_op.h
index 428821c..0915c37 100644 (file)
--- a/caffe2/operators/merge_id_lists_op.h
+++ b/caffe2/operators/merge_id_lists_op.h
@@ -20,8 +20,7 @@ class MergeIdListsOp : public Operator<Context> {
     CAFFE_ENFORCE_EQ(first_lengths.dim(), 1, "LENGTHS should be 1-D");
     const auto batch_size = first_lengths.numel();
 
-    auto* out_lengths = Output(0);
-    out_lengths->ResizeLike(first_lengths);
+    auto* out_lengths = Output(0, first_lengths.sizes(), at::dtype<int32_t>());
 
     auto* out_lengths_data = out_lengths->template mutable_data<int32_t>();
 

diff --git a/caffe2/operators/minmax_gradient_ops.cc b/caffe2/operators/minmax_gradient_ops.cc
index 326586b..9c7df22 100644 (file)
--- a/caffe2/operators/minmax_gradient_ops.cc
+++ b/caffe2/operators/minmax_gradient_ops.cc
@@ -26,8 +26,7 @@ bool SelectGradientOpBase<T, Context>::RunOnDevice() {
     ConstEigenArrayMap<T> input_array(
         input.template data<T>(), 1, input.numel());
 
-    auto* grad_input = Output(i);
-    grad_input->ResizeLike(input);
+    auto* grad_input = Output(i, input.sizes(), at::dtype<T>());
     EigenArrayMap<T> grad_in_array(
         grad_input->template mutable_data<T>(), 1, grad_input->numel());
     grad_in_array = grad_out_array *

diff --git a/caffe2/operators/mod_op.cc b/caffe2/operators/mod_op.cc
index 5515196..48c1eea 100644 (file)
--- a/caffe2/operators/mod_op.cc
+++ b/caffe2/operators/mod_op.cc
@@ -12,8 +12,7 @@ bool ModOp<CPUContext>::DoRunWithType() {
   auto N = data.numel();
   const auto* data_ptr = data.template data<T>();
 
-  auto* output = Output(0);
-  output->ResizeLike(Input(DATA));
+  auto* output = Output(0, Input(DATA).sizes(), at::dtype<T>());
   auto* output_ptr = output->template mutable_data<T>();
 
   for (auto i = 0; i < N; i++) {

diff --git a/caffe2/operators/moments_op.h b/caffe2/operators/moments_op.h
index 6f38f8e..608ece7 100644 (file)
--- a/caffe2/operators/moments_op.h
+++ b/caffe2/operators/moments_op.h
@@ -82,7 +82,7 @@ class MomentsGradientOp final : public Operator<Context> {
     const auto& dvariance = Input(1);
     const auto& X = Input(2);
     const auto& mean = Input(3);
-    auto* dX = Output(0);
+
     const int ndim = X.dim();
     if (axes_.empty()) {
       axes_.resize(ndim);
@@ -100,7 +100,7 @@ class MomentsGradientOp final : public Operator<Context> {
     for (const int axis : axes_) {
       dY_dims[axis] = 1;
     }
-    dX->ResizeLike(X);
+    auto* dX = Output(0, X.sizes(), at::dtype<T>());
     return Compute(
         dY_dims,
         dX_dims,

diff --git a/caffe2/operators/norm_planar_yuv_op.cc b/caffe2/operators/norm_planar_yuv_op.cc
index 2ff837d..724ce14 100644 (file)
--- a/caffe2/operators/norm_planar_yuv_op.cc
+++ b/caffe2/operators/norm_planar_yuv_op.cc
@@ -16,8 +16,8 @@ class NormalizePlanarYUVOp : public Operator<CPUContext> {
     const auto& X = Input(0);
     const auto& M = Input(1); // mean
     const auto& S = Input(2); // standard deviation
-    auto* Z = Output(0);
-    Z->ResizeLike(X);
+
+    auto* Z = Output(0, X.sizes(), at::dtype<float>());
 
     CAFFE_ENFORCE(X.sizes().size() == 4);
 

diff --git a/caffe2/operators/normalize_l1_op.h b/caffe2/operators/normalize_l1_op.h
index 8192ced..7285447 100644 (file)
--- a/caffe2/operators/normalize_l1_op.h
+++ b/caffe2/operators/normalize_l1_op.h
@@ -15,9 +15,9 @@ class NormalizeL1Op final : public Operator<Context> {
 
   bool RunOnDevice() override {
     const auto& x = Input(0);
-    auto* y = Output(0);
+
     const auto* xData = x.template data<T>();
-    y->ResizeLike(x);
+    auto* y = Output(0, x.sizes(), at::dtype<T>());
     auto* yData = y->template mutable_data<T>();
 
     const auto canonical_axis = x.canonical_axis_index(

diff --git a/caffe2/operators/normalize_op.h b/caffe2/operators/normalize_op.h
index a420339..3a0995c 100644 (file)
--- a/caffe2/operators/normalize_op.h
+++ b/caffe2/operators/normalize_op.h
@@ -18,9 +18,9 @@ class NormalizeOp final : public Operator<Context> {
 
   bool RunOnDevice() override {
     const auto& x = Input(0);
-    auto* y = Output(0);
+
     const auto* xData = x.template data<T>();
-    y->ResizeLike(x);
+    auto* y = Output(0, x.sizes(), at::dtype<T>());
     auto* yData = y->template mutable_data<T>();
 
     const auto canonical_axis = x.canonical_axis_index(
@@ -48,8 +48,8 @@ class NormalizeGradientOp final : public Operator<Context> {
   bool RunOnDevice() override {
     const auto& x = Input(0);
     const auto& gOut = Input(GRAD_OUT);
-    auto* gIn = Output(GRAD_IN);
-    gIn->ResizeLike(gOut);
+
+    auto* gIn = Output(GRAD_IN, gOut.sizes(), at::dtype<T>());
 
     const auto* xData = x.template data<T>();
     const auto* gOutData = gOut.template data<T>();