From f22b326aca15ae482aeb48b07c958ab333c8a025 Mon Sep 17 00:00:00 2001
From: Bram Wasti <bwasti@fb.com>
Date: Tue, 12 Jun 2018 09:50:48 -0700
Subject: [PATCH 001/118] [fix] fixup the bias multiplier data access issue

Hotfix for failues in conv_transpose
---
 caffe2/operators/conv_transpose_op_impl.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/caffe2/operators/conv_transpose_op_impl.h b/caffe2/operators/conv_transpose_op_impl.h
index dd35678baea19..808433939c785 100644
--- a/caffe2/operators/conv_transpose_op_impl.h
+++ b/caffe2/operators/conv_transpose_op_impl.h
@@ -38,7 +38,6 @@ bool ConvTransposeOp<T, Context>::RunOnDeviceWithOrderNCHW() {
   const int input_image_size = H * W;
   const int output_image_size = Y->dim32(2) * Y->dim32(3);
 
-#if !defined(__ARM_NEON__) && !defined(__ARM_NEON)
   if (InputSize() == 3) {
     auto& bias = Input(BIAS);
     CAFFE_ENFORCE(bias.ndim() == 1, "bias must be 1D tensor");
@@ -55,7 +54,6 @@ bool ConvTransposeOp<T, Context>::RunOnDeviceWithOrderNCHW() {
           &context_);
     }
   }
-#endif // !defined(__ARM_NEON__) && !defined(__ARM_NEON)
 
   const T* Xdata = X.template data<T>();
   const T* filter_data = filter.template data<T>();

From 61623dafcfeb97ef9927616bb4536ef8b7b0885b Mon Sep 17 00:00:00 2001
From: Xiaolong Wang <xlwang@fb.com>
Date: Tue, 12 Jun 2018 09:51:30 -0700
Subject: [PATCH 002/118] [D2][Easy]: lint regularizer

lint with black
---
 caffe2/python/regularizer.py | 28 ++++++++++------------------
 1 file changed, 10 insertions(+), 18 deletions(-)

diff --git a/caffe2/python/regularizer.py b/caffe2/python/regularizer.py
index e5381ac6ab7d3..9f57a096dd8ce 100644
--- a/caffe2/python/regularizer.py
+++ b/caffe2/python/regularizer.py
@@ -1,10 +1,6 @@
 # @package optimizer
 # Module caffe2.python.optimizer
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
+from __future__ import absolute_import, division, print_function, unicode_literals
 
 from caffe2.python import core
 
@@ -13,11 +9,11 @@ class Regularizer(object):
     def __init__(self):
         self.apply_after_optimizer = False
 
-    '''
+    """
     Adds regularization to train_net for given parameter. Its factor ahead of
     regularization is given when initialization.
     The param should be a BlobReference.
-    '''
+    """
 
     def __call__(self, net, param_init_net, param, grad=None):
         assert isinstance(param, core.BlobReference)
@@ -30,13 +26,12 @@ def _run(self, net, param_init_net, param, grad):
 class L1Norm(Regularizer):
     def __init__(self, reg_lambda):
         super(L1Norm, self).__init__()
-        assert reg_lambda >= 0,\
-            'factor ahead of regularization should be 0 or positive'
+        assert reg_lambda >= 0, "factor ahead of regularization should be 0 or positive"
 
         self.reg_lambda = reg_lambda
 
     def _run(self, net, param_init_net, param, grad=None):
-        output_blob = net.NextScopedBlob(param + '_l1_regularization')
+        output_blob = net.NextScopedBlob(param + "_l1_regularization")
         net.LpNorm([param], [output_blob], p=1)
         net.Scale([output_blob], [output_blob], scale=self.reg_lambda)
         return output_blob
@@ -45,13 +40,12 @@ def _run(self, net, param_init_net, param, grad=None):
 class L2Norm(Regularizer):
     def __init__(self, reg_lambda):
         super(L2Norm, self).__init__()
-        assert reg_lambda >= 0,\
-            'factor ahead of regularization should be 0 or positive'
+        assert reg_lambda >= 0, "factor ahead of regularization should be 0 or positive"
 
         self.reg_lambda = reg_lambda
 
     def _run(self, net, param_init_net, param, grad=None):
-        output_blob = net.NextScopedBlob(param + '_l2_regularization')
+        output_blob = net.NextScopedBlob(param + "_l2_regularization")
         net.LpNorm([param], [output_blob], p=2)
         net.Scale([output_blob], [output_blob], scale=self.reg_lambda)
         return output_blob
@@ -64,7 +58,7 @@ def __init__(self, norm=1.0):
         self.apply_after_optimizer = True
 
     def _run(self, net, param_init_net, param, grad):
-        assert self.norm > 0, 'norm should be bigger than 0.'
+        assert self.norm > 0, "norm should be bigger than 0."
         if isinstance(grad, core.GradientSlice):
             net.SparseNormalize(
                 [param, grad.indices, grad.values],
@@ -73,9 +67,7 @@ def _run(self, net, param_init_net, param, grad):
                 norm=self.norm,
             )
         else:
-            raise NotImplementedError(
-                "MaxNorm is not supported for dense parameters"
-            )
+            raise NotImplementedError("MaxNorm is not supported for dense parameters")
 
 
 class ConstantNorm(Regularizer):
@@ -85,7 +77,7 @@ def __init__(self, norm=1.0):
         self.apply_after_optimizer = True
 
     def _run(self, net, param_init_net, param, grad):
-        assert self.norm > 0, 'norm should be bigger than 0.'
+        assert self.norm > 0, "norm should be bigger than 0."
         if isinstance(grad, core.GradientSlice):
             net.SparseNormalize(
                 [param, grad.indices, grad.values],

From ef8acc3065190a3cd438d251ea7a88f4774700f0 Mon Sep 17 00:00:00 2001
From: Xiaolong Wang <xlwang@fb.com>
Date: Tue, 12 Jun 2018 09:51:39 -0700
Subject: [PATCH 003/118] [GanH]: Split mu in adaptive weight for diagnose

---
 caffe2/python/layers/adaptive_weight.py | 60 ++++++++++++-------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/caffe2/python/layers/adaptive_weight.py b/caffe2/python/layers/adaptive_weight.py
index 9aec2735b44c1..0676a1f280d6f 100644
--- a/caffe2/python/layers/adaptive_weight.py
+++ b/caffe2/python/layers/adaptive_weight.py
@@ -1,86 +1,86 @@
 # @package adaptive_weight
 # Module caffe2.fb.python.layers.adaptive_weight
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
+from __future__ import absolute_import, division, print_function, unicode_literals
 
+import numpy as np
 from caffe2.python import core, schema
 from caffe2.python.layers.layers import ModelLayer
-import numpy as np
-'''
+
+
+"""
 Implementation of adaptive weighting: https://arxiv.org/pdf/1705.07115.pdf
-'''
+"""
 
 
 class AdaptiveWeight(ModelLayer):
+
     def __init__(
         self,
         model,
         input_record,
-        name='adaptive_weight',
+        name="adaptive_weight",
         optimizer=None,
         weights=None,
+        slice_mu=False,
         **kwargs
     ):
-        super(AdaptiveWeight,
-              self).__init__(model, name, input_record, **kwargs)
+        super(AdaptiveWeight, self).__init__(model, name, input_record, **kwargs)
         self.output_schema = schema.Scalar(
-            np.float32, self.get_next_blob_reference('adaptive_weight')
+            np.float32, self.get_next_blob_reference("adaptive_weight")
         )
         self.data = self.input_record.field_blobs()
         self.num = len(self.data)
         # mu_i = log(sigma_i^2)
         if weights is None:
             # mu_i is set such that all initial weights are 1. / num
-            initializer = ('ConstantFill', {'value': np.log(self.num / 2.)})
+            initializer = ("ConstantFill", {"value": np.log(self.num / 2.)})
         else:
             assert len(weights) == self.num
             weights = np.array(weights).astype(np.float32)
-            assert min(weights) > 0, 'initial weights must be non-negative'
+            assert min(weights) > 0, "initial weights must be non-negative"
             values = np.log(1. / 2. / weights)
             initializer = (
-                'GivenTensorFill', {
-                    'values': values,
-                    'dtype': core.DataType.FLOAT
-                }
+                "GivenTensorFill",
+                {"values": values, "dtype": core.DataType.FLOAT},
             )
 
         self.mu = self.create_param(
-            param_name='mu',
+            param_name="mu",
             shape=[self.num],
             initializer=initializer,
             optimizer=optimizer,
         )
+        self.slice_mu = slice_mu
 
     def concat_data(self, net):
-        reshaped = [
-            net.NextScopedBlob('reshaped_data_%d' % i) for i in range(self.num)
-        ]
+        reshaped = [net.NextScopedBlob("reshaped_data_%d" % i) for i in range(self.num)]
         # coerce shape for single real values
         for i in range(self.num):
             net.Reshape(
                 [self.data[i]],
-                [reshaped[i], net.NextScopedBlob('new_shape_%d' % i)],
-                shape=[1]
+                [reshaped[i], net.NextScopedBlob("new_shape_%d" % i)],
+                shape=[1],
             )
-        concated = net.NextScopedBlob('concated_data')
+        concated = net.NextScopedBlob("concated_data")
         net.Concat(
-            reshaped, [concated, net.NextScopedBlob('concated_new_shape')],
-            axis=0
+            reshaped, [concated, net.NextScopedBlob("concated_new_shape")], axis=0
         )
         return concated
 
     def compute_adaptive_sum(self, x, net):
-        mu_exp = net.NextScopedBlob('mu_exp')
+        mu_exp = net.NextScopedBlob("mu_exp")
         net.Exp(self.mu, mu_exp)
-        mu_exp_double = net.NextScopedBlob('mu_exp_double')
+        mu_exp_double = net.NextScopedBlob("mu_exp_double")
         net.Scale(mu_exp, mu_exp_double, scale=2.0)
-        weighted_x = net.NextScopedBlob('weighted_x')
+        weighted_x = net.NextScopedBlob("weighted_x")
         net.Div([x, mu_exp_double], weighted_x)
-        weighted_elements = net.NextScopedBlob('weighted_elements')
+        weighted_elements = net.NextScopedBlob("weighted_elements")
         net.Add([weighted_x, self.mu], weighted_elements)
         net.SumElements(weighted_elements, self.output_schema())
+        if self.slice_mu:
+            for i in range(self.num):
+                mu_i = net.NextScopedBlob("mu_%d" % i)
+                net.Slice(self.mu, mu_i, starts=[i], ends=[i + 1])
 
     def add_ops(self, net):
         data = self.concat_data(net)

From 124750269578a89ca4b79434ca367e29e0ab9d4f Mon Sep 17 00:00:00 2001
From: Jiyan Yang <chocjy@fb.com>
Date: Tue, 12 Jun 2018 09:51:48 -0700
Subject: [PATCH 004/118] [Dper] Add the ability to split FC weights into
 multiple smaller ones

---
 caffe2/python/layers/fc.py | 93 ++++++++++++++++++++++++++++++++------
 1 file changed, 78 insertions(+), 15 deletions(-)

diff --git a/caffe2/python/layers/fc.py b/caffe2/python/layers/fc.py
index 68d0d49ed2b08..b949cc5b1bb81 100644
--- a/caffe2/python/layers/fc.py
+++ b/caffe2/python/layers/fc.py
@@ -16,7 +16,8 @@ class FC(SamplingTrainableMixin, ModelLayer):
 
     def __init__(self, model, input_record, output_dims, weight_init=None,
                  bias_init=None, weight_optim=None, bias_optim=None, name='fc',
-                 weight_reg=None, bias_reg=None, clip_param=None, **kwargs):
+                 weight_reg=None, bias_reg=None, clip_param=None, max_fc_size=None,
+                 **kwargs):
         super(FC, self).__init__(model, name, input_record, **kwargs)
         assert isinstance(input_record, schema.Scalar), (
             "Incorrect input type {}".format(input_record))
@@ -54,35 +55,97 @@ def __init__(self, model, input_record, output_dims, weight_init=None,
         bias_init = bias_init if bias_init else (
             'UniformFill', {'min': -scale, 'max': scale})
 
-        self.w = self.create_param(param_name='w',
-                                   shape=[output_dims, input_dims],
-                                   initializer=weight_init,
-                                   optimizer=weight_optim,
-                                   regularizer=weight_reg)
+        self.output_dim_vec = FC.calculate_fc_output_dims(
+            max_fc_size, input_dims, output_dims)
 
-        self.b = self.create_param(param_name='b',
-                                   shape=[output_dims, ],
-                                   initializer=bias_init,
-                                   optimizer=bias_optim,
-                                   regularizer=bias_reg)
+        if self.output_dim_vec is None or len(self.output_dim_vec) == 1:
+            self.w = self.create_param(param_name='w',
+                                       shape=[output_dims, input_dims],
+                                       initializer=weight_init,
+                                       optimizer=weight_optim,
+                                       regularizer=weight_reg)
+
+            self.b = self.create_param(param_name='b',
+                                       shape=[output_dims, ],
+                                       initializer=bias_init,
+                                       optimizer=bias_optim,
+                                       regularizer=bias_reg)
+        else:
+            self.w_vec = []
+            self.b_vec = []
+
+            for idx, output_dim in enumerate(self.output_dim_vec):
+                self.w_vec.append(self.create_param(param_name='w_sub_{}'.format(idx),
+                                             shape=[output_dim, input_dims],
+                                             initializer=weight_init,
+                                             optimizer=weight_optim,
+                                             regularizer=weight_reg))
+
+                self.b_vec.append(self.create_param(param_name='b_sub_{}'.format(idx),
+                                             shape=[output_dim, ],
+                                             initializer=weight_init,
+                                             optimizer=weight_optim,
+                                             regularizer=weight_reg))
 
         self.output_schema = schema.Scalar(
             (np.float32, (output_dims, )),
             self.get_next_blob_reference('output')
         )
 
+    @staticmethod
+    def calculate_fc_output_dims(max_fc_size, input_dim, output_dim):
+
+        if not max_fc_size or max_fc_size < 0:
+            return None
+
+        assert max_fc_size >= input_dim, "Currently we split along the output " \
+            "dimension. So we need max_fc_size >= input_dim. But, max_fc_size: " \
+            "{}, input_dim: {}".format(max_fc_size, input_dim)
+
+        output_dim_allowed = int(np.floor(max_fc_size / input_dim))
+        num_fc = int(np.floor((output_dim - 1) / output_dim_allowed) + 1)
+
+        output_dim_vec = [output_dim_allowed] * (num_fc - 1)
+
+        output_dim_vec.append(output_dim - sum(output_dim_vec))
+
+        return output_dim_vec
+
     def _add_ops(self, net, params):
         if self.clip_args is not None:
             clipped_params = [net.NextScopedBlob(
                 'clipped_%s' % str(p)) for p in params]
             for p, cp in zip(params, clipped_params):
                 net.Clip([p], [cp], **self.clip_args)
-            net.FC(self.input_record.field_blobs() + clipped_params,
-                   self.output_schema.field_blobs(), **self.kwargs)
-        else:
+
+            params = clipped_params
+
+        if self.output_dim_vec is None or len(self.output_dim_vec) == 1:
             net.FC(self.input_record.field_blobs() + params,
                    self.output_schema.field_blobs(), **self.kwargs)
+        else:
+            w_vec = params[:int(len(params) / 2)]
+            b_vec = params[int(len(params) / 2):]
+
+            assert len(w_vec) == len(b_vec)
+
+            output_blob_vec = []
+
+            for i in range(len(self.output_dim_vec)):
+                output_blob = net.NextScopedBlob(
+                    'output_sub_{}'.format(i))
+                output_blob_vec.append(
+                    net.FC(self.input_record.field_blobs() +
+                           [w_vec[i], b_vec[i]],
+                           [output_blob], **self.kwargs))
+
+            net.Concat(output_blob_vec,
+                       self.output_schema.field_blobs() +
+                       [self.output_schema.field_blobs()[0] + "_concat_dims"])
 
     @property
     def param_blobs(self):
-        return [self.w, self.b]
+        if self.output_dim_vec is None or len(self.output_dim_vec) == 1:
+            return [self.w, self.b]
+        else:
+            return self.w_vec + self.b_vec

From d8ff1c411d039cf3fb864ac85b8108d5b77cc227 Mon Sep 17 00:00:00 2001
From: Xianjie Chen <cxj@fb.com>
Date: Tue, 12 Jun 2018 09:52:06 -0700
Subject: [PATCH 005/118] fix SumReduceLikeOp for empty blob

as desc.
---
 .../elementwise_op_broadcast_test.py          | 162 ++++++++++++++++++
 1 file changed, 162 insertions(+)

diff --git a/caffe2/python/operator_test/elementwise_op_broadcast_test.py b/caffe2/python/operator_test/elementwise_op_broadcast_test.py
index ff6bddeb2bb6d..e767a0db161a9 100644
--- a/caffe2/python/operator_test/elementwise_op_broadcast_test.py
+++ b/caffe2/python/operator_test/elementwise_op_broadcast_test.py
@@ -324,3 +324,165 @@ def test_semantic_broadcast(self, gc, dc):
         out = workspace.FetchBlob("out")
         np.testing.assert_array_almost_equal(out, X + Y)
         self.assertDeviceChecks(dc, op, [X, Y], [0])
+
+    @given(**hu.gcs)
+    def test_sum_reduce_empty_blob(self, gc, dc):
+        net = core.Net('test')
+
+        with core.DeviceScope(gc):
+            net.GivenTensorFill([], ["X"], values=[], shape=[2, 0, 5])
+            net.GivenTensorFill([], ["Y"], values=[], shape=[2, 0])
+            net.SumReduceLike(["X", "Y"], "out", axis=0)
+            workspace.RunNetOnce(net)
+
+    @given(**hu.gcs)
+    def test_sum_reduce(self, gc, dc):
+        # Set broadcast and no axis, i.e. broadcasting last dimensions.
+        X = np.random.rand(2, 3, 4, 5).astype(np.float32)
+        Y = np.random.rand(4, 5).astype(np.float32)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1)
+        workspace.FeedBlob("X", X)
+        workspace.FeedBlob("Y", Y)
+        workspace.RunOperatorOnce(op)
+        out = workspace.FetchBlob("out")
+        res = np.sum(X, axis=0)
+        res = np.sum(res, axis=0)
+        np.testing.assert_array_almost_equal(out, res)
+        self.assertDeviceChecks(dc, op, [X, Y], [0])
+
+        # Set broadcast and no axis, i.e. broadcasting last dimensions.
+        X = np.random.rand(2, 3, 4, 5).astype(np.float32)
+        Y = np.random.rand(2, 3).astype(np.float32)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1, axis=0)
+        workspace.FeedBlob("X", X)
+        workspace.FeedBlob("Y", Y)
+        workspace.RunOperatorOnce(op)
+        out = workspace.FetchBlob("out")
+        res = np.sum(X, axis=3)
+        res = np.sum(res, axis=2)
+        np.testing.assert_array_almost_equal(out, res, decimal=3)
+        self.assertDeviceChecks(dc, op, [X, Y], [0])
+
+        # broadcasting intermediate dimensions
+        X = np.random.rand(2, 3, 4, 5).astype(np.float32)
+        Y = np.random.rand(3, 4).astype(np.float32)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1, axis=1)
+        workspace.FeedBlob("X", X)
+        workspace.FeedBlob("Y", Y)
+        workspace.RunOperatorOnce(op)
+        out = workspace.FetchBlob("out")
+        res = np.sum(X, axis=0)
+        res = np.sum(res, axis=2)
+        np.testing.assert_array_almost_equal(out, res)
+        self.assertDeviceChecks(dc, op, [X, Y], [0])
+
+        # broadcasting intermediate dimensions
+        X = np.random.rand(2, 3, 4, 500).astype(np.float64)
+        Y = np.random.rand(1).astype(np.float64)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1)
+        workspace.FeedBlob("X", X)
+        workspace.FeedBlob("Y", Y)
+        workspace.RunOperatorOnce(op)
+        out = workspace.FetchBlob("out")
+        res = np.array(np.sum(X))
+        np.testing.assert_array_almost_equal(out, res, decimal=0)
+
+        # broadcasting with single elem dimensions at both ends
+        X = np.random.rand(2, 3, 4, 5).astype(np.float32)
+        Y = np.random.rand(1, 3, 4, 1).astype(np.float32)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1)
+        workspace.FeedBlob("X", X)
+        workspace.FeedBlob("Y", Y)
+        workspace.RunOperatorOnce(op)
+        out = workspace.FetchBlob("out")
+        res = np.sum(X, axis=0)
+        res = np.sum(res, axis=2).reshape(Y.shape)
+        np.testing.assert_array_almost_equal(out, res)
+        self.assertDeviceChecks(dc, op, [X, Y], [0])
+
+        # fp64 is not supported with the CUDA op
+        dc_cpu_only = [d for d in dc if d.device_type != caffe2_pb2.CUDA]
+        self.assertDeviceChecks(dc_cpu_only, op, [X, Y], [0])
+
+    @unittest.skipIf(not workspace.has_gpu_support, "No gpu support")
+    @given(**hu.gcs_gpu_only)
+    def test_sum_reduce_fp16(self, gc, dc):
+        # Set broadcast and no axis, i.e. broadcasting last dimensions.
+        X = np.random.rand(2, 3, 4, 5).astype(np.float16)
+        Y = np.random.rand(4, 5).astype(np.float16)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1, device_option=gc)
+
+        def ref_op(X, Y):
+            res = np.sum(X, axis=0)
+            res = np.sum(res, axis=0)
+            return [res]
+
+        self.assertReferenceChecks(
+            device_option=gc,
+            op=op,
+            inputs=[X, Y],
+            reference=ref_op,
+            threshold=1e-3)
+
+        # Set broadcast and no axis, i.e. broadcasting last dimensions.
+        X = np.random.rand(2, 3, 4, 5).astype(np.float16)
+        Y = np.random.rand(2, 3).astype(np.float16)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1, axis=0)
+
+        def ref_op(X, Y):
+            res = np.sum(X, axis=3)
+            res = np.sum(res, axis=2)
+            return [res]
+
+        self.assertReferenceChecks(
+            device_option=gc,
+            op=op,
+            inputs=[X, Y],
+            reference=ref_op,
+            threshold=1e-3)
+
+        # broadcasting intermediate dimensions
+        X = np.random.rand(2, 3, 4, 5).astype(np.float16)
+        Y = np.random.rand(3, 4).astype(np.float16)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1, axis=1)
+
+        def ref_op(X, Y):
+            res = np.sum(X, axis=0)
+            res = np.sum(res, axis=2)
+            return [res]
+
+        self.assertReferenceChecks(
+            device_option=gc,
+            op=op,
+            inputs=[X, Y],
+            reference=ref_op,
+            threshold=1e-3)
+
+        # broadcasting with single elem dimensions at both ends
+        X = np.random.rand(2, 3, 4, 5).astype(np.float16)
+        Y = np.random.rand(1, 3, 4, 1).astype(np.float16)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1)
+
+        def ref_op(X, Y):
+            res = np.sum(X, axis=0)
+            res = np.sum(res, axis=2)
+            return [res.reshape(Y.shape)]
+
+        self.assertReferenceChecks(
+            device_option=gc,
+            op=op,
+            inputs=[X, Y],
+            reference=ref_op,
+            threshold=1e-3)
+
+if __name__ == "__main__":
+    unittest.main()

From 86d32bac7f6bf44714cf4f6c5fb712218dd06f9f Mon Sep 17 00:00:00 2001
From: Jun Liu <junliu@fb.com>
Date: Tue, 12 Jun 2018 09:52:41 -0700
Subject: [PATCH 006/118] add ctc_greedy_decoder for caffe2

ctc_greedy_decoder same as tf's
---
 caffe2/operators/ctc_greedy_decoder_op.cc     | 98 +++++++++++++++++++
 caffe2/operators/ctc_greedy_decoder_op.h      | 32 ++++++
 .../ctc_greedy_decoder_op_test.py             | 90 +++++++++++++++++
 3 files changed, 220 insertions(+)
 create mode 100644 caffe2/operators/ctc_greedy_decoder_op.cc
 create mode 100644 caffe2/operators/ctc_greedy_decoder_op.h
 create mode 100644 caffe2/python/operator_test/ctc_greedy_decoder_op_test.py

diff --git a/caffe2/operators/ctc_greedy_decoder_op.cc b/caffe2/operators/ctc_greedy_decoder_op.cc
new file mode 100644
index 0000000000000..5f9792d651b37
--- /dev/null
+++ b/caffe2/operators/ctc_greedy_decoder_op.cc
@@ -0,0 +1,98 @@
+#include "caffe2/operators/ctc_greedy_decoder_op.h"
+
+namespace caffe2 {
+
+namespace {
+
+template <class Context>
+const float* getTensorDataPtr(const Tensor<Context>& tensor, int t, int n) {
+  const auto& dims = tensor.dims();
+  CAFFE_ENFORCE_EQ(dims.size(), 3);
+  int offset = (t * dims[1] + n) * dims[2];
+  CAFFE_ENFORCE_LT(offset, tensor.size());
+  return tensor.template data<float>() + offset;
+}
+
+} // namespace
+
+template <>
+bool CTCGreedyDecoderOp<CPUContext>::RunOnDevice() {
+  // [max_time_step, batch_size, num_classes]
+  auto& inputs = Input(INPUTS);
+  // [batch_size]
+  auto* output_len = Output(OUTPUT_LEN);
+  // [total_decoded_output]
+  auto* values = Output(VALUES);
+
+  const auto& inputs_dims = inputs.dims();
+  int32_t max_time_step = inputs_dims[0];
+  int32_t batch_size = inputs_dims[1];
+  int32_t num_classes = inputs_dims[2];
+  // [batch_size]
+  const int* seq_len_data =
+      (InputSize() == 2) ? Input(SEQ_LEN).data<int>() : nullptr;
+
+  vector<int> values_cach;
+  output_len->Resize(vector<TIndex>{batch_size});
+  int* output_len_data = output_len->mutable_data<int>();
+
+  for (int32_t i = 0; i < batch_size; ++i) {
+    int previous_label = 0, t_dec = 0;
+    int32_t seq_len_i = (seq_len_data) ? seq_len_data[i] : max_time_step;
+    CAFFE_ENFORCE_LE(seq_len_i, max_time_step);
+    for (int32_t t = 0; t < seq_len_i; ++t) {
+      auto* prob_data = getTensorDataPtr(inputs, t, i);
+      int curr_label =
+          std::max_element(prob_data, prob_data + num_classes) - prob_data;
+      if (curr_label != 0 &&
+          (!merge_repeated_ || (previous_label != curr_label))) {
+        t_dec++;
+        values_cach.push_back(curr_label);
+      }
+      previous_label = curr_label;
+    }
+    output_len_data[i] = t_dec;
+  }
+
+  values->Resize(vector<TIndex>{values_cach.size()});
+  int* values_data = values->mutable_data<int>();
+  for (int i = 0; i < values_cach.size(); ++i) {
+    values_data[i] = values_cach.at(i);
+  }
+  values_cach.clear();
+
+  return true;
+}
+
+REGISTER_CPU_OPERATOR(CTCGreedyDecoder, CTCGreedyDecoderOp<CPUContext>);
+OPERATOR_SCHEMA(CTCGreedyDecoder)
+    .NumInputs(1, 2)
+    .NumOutputs(2)
+    .Arg(
+        "merge_repeated",
+        "When merge_repeated is true, merge repeated classes in output.")
+    .SetDoc("Greedy decoder for connectionist temporal classification.")
+    .Input(
+        0,
+        "INPUTS",
+        "3D float Tensor sized [max_time, batch_size, num_classes]")
+    .Input(
+        1,
+        "SEQ_LEN",
+        "(optional) 1D int vector containing sequence lengths, "
+        "having size [batch_size]"
+        "seq_len will be set to max_time if not provided")
+    .Output(
+        0,
+        "OUTPUT_LEN",
+        "Output_len matrix size (batch). "
+        "The row store: [decoded_length]")
+    .Output(
+        1,
+        "VALUES",
+        "Values vector, size (total_decoded_outputs). "
+        "The vector stores the decoded classes")
+    .InheritOnnxSchema("CTCGreedyDecoder");
+SHOULD_NOT_DO_GRADIENT(CTCGreedyDecoder);
+
+} // namespace caffe2
diff --git a/caffe2/operators/ctc_greedy_decoder_op.h b/caffe2/operators/ctc_greedy_decoder_op.h
new file mode 100644
index 0000000000000..a5a0bab8f9480
--- /dev/null
+++ b/caffe2/operators/ctc_greedy_decoder_op.h
@@ -0,0 +1,32 @@
+#ifndef CAFFE2_OPERATORS_CTC_GREEDY_DECODER_OP_H_
+#define CAFFE2_OPERATORS_CTC_GREEDY_DECODER_OP_H_
+
+#include "caffe2/core/context.h"
+#include "caffe2/core/operator.h"
+
+namespace caffe2 {
+
+template <class Context>
+class CTCGreedyDecoderOp : public Operator<Context> {
+ public:
+  USE_OPERATOR_CONTEXT_FUNCTIONS;
+  CTCGreedyDecoderOp(const OperatorDef& operator_def, Workspace* ws)
+      : Operator<Context>(operator_def, ws) {
+    if (OperatorBase::HasArgument("merge_repeated")) {
+      merge_repeated_ =
+          OperatorBase::GetSingleArgument<bool>("merge_repeated", true);
+    }
+  }
+
+  bool RunOnDevice() override;
+
+ protected:
+  bool merge_repeated_;
+  INPUT_TAGS(INPUTS, SEQ_LEN);
+  OUTPUT_TAGS(OUTPUT_LEN, VALUES);
+  // Input: X, 3D tensor; L, 1D tensor. Output: Y sparse tensor
+};
+
+} // namespace caffe2
+
+#endif // CAFFE2_OPERATORS_CTC_GREEDY_DECODER_OP_H_
diff --git a/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py b/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py
new file mode 100644
index 0000000000000..4ae1db3050bc4
--- /dev/null
+++ b/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py
@@ -0,0 +1,90 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+from caffe2.python import core
+from hypothesis import given
+import caffe2.python.hypothesis_test_util as hu
+import hypothesis.strategies as st
+import numpy as np
+
+import unittest
+
+
+class TestCTCGreedyDecoderOp(hu.HypothesisTestCase):
+
+    @given(
+        batch=st.sampled_from([2, 4, 128, 256]),
+        max_time=st.sampled_from([2, 10, 30, 50]),
+        num_classes=st.sampled_from([2, 10, 26, 40]),
+        merge_repeated=st.sampled_from([True, False]),
+        **hu.gcs
+    )
+    def test_ctc_greedy_decoder(
+        self, batch, max_time,
+        num_classes, merge_repeated, gc, dc
+    ):
+
+        def input_generater():
+            inputs = np.random.rand(max_time, batch, num_classes)\
+                .astype(np.float32)
+            seq_len = np.random.randint(1, max_time + 1, size=batch)\
+                .astype(np.int32)
+            return inputs, seq_len
+
+        def ref_ctc_decoder(inputs, seq_len):
+            merge = merge_repeated
+            output_len = np.array([]).astype(np.int32)
+            val = np.array([]).astype(np.int32)
+            for i in range(batch):
+                prev_id = 0
+                t_dec = 0
+                len_i = seq_len[i] if seq_len is not None else max_time
+                for t in range(len_i):
+                    max_id = np.argmax(inputs[t, i, :])
+                    if max_id == 0:
+                        prev_id = max_id
+                        continue
+                    if max_id == prev_id and merge:
+                        prev_id = max_id
+                        continue
+                    t_dec += 1
+                    val = np.append(val, max_id)
+                    prev_id = max_id
+                output_len = np.append(output_len, t_dec)
+
+            return [output_len, val]
+
+        def ref_ctc_decoder_max_time(inputs):
+            return ref_ctc_decoder(inputs, None)
+
+        inputs, seq_len = input_generater()
+        op = core.CreateOperator('CTCGreedyDecoder',
+            ['INPUTS', 'SEQ_LEN'],
+            ['OUTPUT_LEN', 'VALUES'],
+            merge_repeated=merge_repeated)
+
+        self.assertReferenceChecks(
+            device_option=gc,
+            op=op,
+            inputs=[inputs, seq_len],
+            reference=ref_ctc_decoder,
+        )
+
+        op_1 = core.CreateOperator('CTCGreedyDecoder',
+            ['INPUTS'],
+            ['OUTPUT_LEN', 'VALUES'],
+            merge_repeated=merge_repeated)
+
+        self.assertReferenceChecks(
+            device_option=gc,
+            op=op_1,
+            inputs=[inputs],
+            reference=ref_ctc_decoder_max_time,
+        )
+
+
+if __name__ == "__main__":
+    import random
+    random.seed(2603)
+    unittest.main()

From e2c322e9f20f5f3a1700b93624e9f8384cb0b21c Mon Sep 17 00:00:00 2001
From: Ilia Cherniavskii <iliacher@fb.com>
Date: Tue, 12 Jun 2018 09:53:05 -0700
Subject: [PATCH 007/118] Update event callback handling

Allow multiple callbacks per event
---
 caffe2/core/event.cc    | 18 ++++++------------
 caffe2/core/event.h     |  6 +++---
 caffe2/core/event_cpu.h |  2 +-
 3 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/caffe2/core/event.cc b/caffe2/core/event.cc
index 0a612b68c1e95..e547167dadfe5 100644
--- a/caffe2/core/event.cc
+++ b/caffe2/core/event.cc
@@ -99,28 +99,22 @@ void EventSetFinishedCPU(const Event* event, const char* err_msg) {
     wrapper->status_ = EventStatus::EVENT_FAILED;
   }
 
-  if (wrapper->callback_) {
-    wrapper->callback_();
+  for (auto& callback : wrapper->callbacks_) {
+    callback();
   }
 
   wrapper->cv_completed_.notify_all();
 }
 
-bool EventSetCallbackCPU(Event* event, EventCallbackFunction callback) {
+void EventSetCallbackCPU(Event* event, EventCallbackFunction callback) {
   auto* wrapper = static_cast<CPUEventWrapper*>(event->event_.get());
   std::unique_lock<std::mutex> lock(wrapper->mutex_);
 
-  if (wrapper->callback_) {
-    return false;
-  }
-  wrapper->callback_ = callback;
+  wrapper->callbacks_.push_back(callback);
   if (wrapper->status_ == EventStatus::EVENT_SUCCESS ||
       wrapper->status_ == EventStatus::EVENT_FAILED) {
-    if (wrapper->callback_) {
-      wrapper->callback_();
-    }
+    callback();
   }
-  return true;
 }
 
 void EventResetCPU(Event* event) {
@@ -128,7 +122,7 @@ void EventResetCPU(Event* event) {
   std::unique_lock<std::mutex> lock(wrapper->mutex_);
   wrapper->status_ = EventStatus::EVENT_INITIALIZED;
   wrapper->err_msg_ = "";
-  wrapper->callback_ = nullptr;
+  wrapper->callbacks_.clear();
 }
 
 REGISTER_EVENT_CREATE_FUNCTION(CPU, EventCreateCPU);
diff --git a/caffe2/core/event.h b/caffe2/core/event.h
index 17822490dfc12..d6bbc126760bb 100644
--- a/caffe2/core/event.h
+++ b/caffe2/core/event.h
@@ -49,7 +49,7 @@ typedef void (*EventResetFunction)(Event*);
 
 // Sets callback that is called when event is finished
 typedef std::function<void()> EventCallbackFunction;
-typedef bool (*EventSetCallbackFunction)(Event*, EventCallbackFunction);
+typedef void (*EventSetCallbackFunction)(Event*, EventCallbackFunction);
 
 class Event {
  public:
@@ -124,10 +124,10 @@ class Event {
     return event_callback_setter_[type_] != nullptr;
   }
 
-  bool SetCallback(EventCallbackFunction callback) {
+  void SetCallback(EventCallbackFunction callback) {
     CAFFE_ENFORCE(
         event_callback_setter_[type_], "Event does not support callbacks");
-    return event_callback_setter_[type_](this, callback);
+    event_callback_setter_[type_](this, callback);
   }
 
   // If parent op has succeeded, then we can run any child op;
diff --git a/caffe2/core/event_cpu.h b/caffe2/core/event_cpu.h
index d723828aa517e..130841c10e72d 100644
--- a/caffe2/core/event_cpu.h
+++ b/caffe2/core/event_cpu.h
@@ -19,7 +19,7 @@ struct CPUEventWrapper {
   std::condition_variable cv_completed_;
   std::atomic<int> status_;
   std::string err_msg_;
-  EventCallbackFunction callback_;
+  std::vector<EventCallbackFunction> callbacks_;
 };
 
 void EventCreateCPU(const DeviceOption& option, Event* event);

From a4fec7b4d3ca76a01c941a60269916ca274eb1fd Mon Sep 17 00:00:00 2001
From: Ellie Wen <dwen@fb.com>
Date: Tue, 12 Jun 2018 09:53:22 -0700
Subject: [PATCH 008/118] Add WeightedSum layer

The motivation is to do weighted sum in HoNet/crossnet, in the next diff, I'll replace model.Add with model.WeightedSum in
honet: https://fburl.com/f4rmolg2
crossnet: https://fburl.com/v7awn8se, https://fburl.com/63filbnm
---
 caffe2/python/layers/blob_weighted_sum.py | 73 +++++++++++++++++++++++
 caffe2/python/layers_test.py              | 63 +++++++++++++++++++
 2 files changed, 136 insertions(+)
 create mode 100644 caffe2/python/layers/blob_weighted_sum.py

diff --git a/caffe2/python/layers/blob_weighted_sum.py b/caffe2/python/layers/blob_weighted_sum.py
new file mode 100644
index 0000000000000..cf8ecfd99045d
--- /dev/null
+++ b/caffe2/python/layers/blob_weighted_sum.py
@@ -0,0 +1,73 @@
+## @package BlobWeightedSum
+# Module caffe2.python.layers.blob_weighted_sum
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+from caffe2.python import schema
+from caffe2.python.layers.layers import ModelLayer
+
+
+class BlobWeightedSum(ModelLayer):
+    """
+    This layer implements the weighted sum:
+    weighted element-wise sum of input blobs.
+    """
+    def __init__(
+        self,
+        model,
+        input_record,
+        init_weights=None,
+        weight_optim=None,
+        name='blob_weighted_sum',
+        **kwargs
+    ):
+        super(BlobWeightedSum, self).__init__(model, name, input_record, **kwargs)
+
+        self.blobs = self.input_record.field_blobs()
+
+        self.num_weights = len(self.blobs)
+        assert self.num_weights > 1, (
+            "BlobWeightedSum expects more than one input blobs"
+        )
+
+        assert len(input_record.field_types()[0].shape) > 0, (
+            "BlobWeightedSum expects limited dimensions of the input tensor"
+        )
+
+        assert all(
+            input_record.field_types()[0].shape == input_record.field_types()[i].shape
+            for i in range(1, self.num_weights)
+        ), "Shape of input blobs should be the same shape {}".format(
+            input_record.field_types()[0].shape
+        )
+
+        if init_weights:
+            assert self.num_weights == len(init_weights), (
+                "the size of init_weights should be the same as input blobs, "
+                "expects {}, got {}".format(self.num_weights, len(init_weights))
+            )
+        else:
+            init_weights = [1.0] * self.num_weights
+
+        self.weights = [
+            self.create_param(
+                param_name="w_{}".format(idx),
+                shape=[1],
+                initializer=('ConstantFill', {'value': float(init_weights[idx])}),
+                optimizer=weight_optim
+            ) for idx in range(self.num_weights)
+        ]
+
+        self.output_schema = schema.Scalar(
+            input_record.field_types()[0],
+            self.get_next_blob_reference('blob_weighted_sum_out')
+        )
+
+    def add_ops(self, net):
+        net.WeightedSum(
+            [x for pair in zip(self.blobs, self.weights) for x in pair],
+            self.output_schema(),
+            grad_on_w=True,
+        )
diff --git a/caffe2/python/layers_test.py b/caffe2/python/layers_test.py
index e7e4df3bfd714..278276609d594 100644
--- a/caffe2/python/layers_test.py
+++ b/caffe2/python/layers_test.py
@@ -1854,3 +1854,66 @@ def testLabelSmoothForCategoricalLabel(self, categories, bsz, gc, dc):
     )
     def testLabelSmoothForBinaryProbLabel(self, bsz, gc, dc):
         self._testLabelSmooth(2, True, bsz)
+
+    @given(
+        num_inputs=st.integers(min_value=2, max_value=10),
+        batch_size=st.integers(min_value=2, max_value=10),
+        input_dim=st.integers(min_value=5, max_value=10),
+        seed=st.integers(1, 10),
+    )
+    def testBlobWeightedSum(self, num_inputs, batch_size, input_dim, seed):
+
+        def get_blob_weighted_sum():
+            weights = []
+            for i in range(num_inputs):
+                w_blob_name = 'blob_weighted_sum/w_{0}'.format(i)
+                assert workspace.HasBlob(w_blob_name), (
+                    "cannot fine blob {}".format(w_blob_name)
+                )
+                w = workspace.FetchBlob(w_blob_name)
+                weights.append(w)
+
+            result = np.sum([
+                input_data[idx] * weights[idx] for idx in range(num_inputs)
+            ], axis=0)
+            return result
+
+        np.random.seed(seed)
+        expected_output_schema = schema.Scalar((np.float32, (input_dim,)))
+        input_schema = schema.Tuple(
+            *[expected_output_schema for _ in range(num_inputs)]
+        )
+        input_data = [
+            np.random.random((batch_size, input_dim)).astype(np.float32)
+            for _ in range(num_inputs)
+        ]
+        input_record = self.new_record(input_schema)
+        schema.FeedRecord(input_record, input_data)
+
+        # test output schema
+        ws_output = self.model.BlobWeightedSum(input_record)
+        self.assertEqual(len(self.model.layers), 1)
+        assert schema.equal_schemas(ws_output, expected_output_schema)
+
+        # test train net
+        train_init_net, train_net = self.get_training_nets()
+        workspace.RunNetOnce(train_init_net)
+        workspace.RunNetOnce(train_net)
+        output = workspace.FetchBlob(ws_output())
+        npt.assert_almost_equal(get_blob_weighted_sum(), output, decimal=5)
+
+        self.run_train_net_forward_only()
+        output = workspace.FetchBlob(ws_output())
+        npt.assert_almost_equal(get_blob_weighted_sum(), output, decimal=5)
+
+        # test eval net
+        eval_net = self.get_eval_net()
+        workspace.RunNetOnce(eval_net)
+        output = workspace.FetchBlob(ws_output())
+        npt.assert_almost_equal(get_blob_weighted_sum(), output, decimal=5)
+
+        # test pred net
+        pred_net = self.get_predict_net()
+        workspace.RunNetOnce(pred_net)
+        output = workspace.FetchBlob(ws_output())
+        npt.assert_almost_equal(get_blob_weighted_sum(), output, decimal=5)

From 79a53936d1f065e0df878b9521e643ebef198fe1 Mon Sep 17 00:00:00 2001
From: Ilia Cherniavskii <iliacher@fb.com>
Date: Tue, 12 Jun 2018 09:53:32 -0700
Subject: [PATCH 009/118] Replicate DAG's behavior

Some callers expect RunAsync to block, replicate that behavior in case of
explicit 'dag' net type
---
 caffe2/core/net_async_base.cc       | 3 +++
 caffe2/core/net_async_base.h        | 1 +
 caffe2/core/net_async_scheduling.cc | 4 ++++
 3 files changed, 8 insertions(+)

diff --git a/caffe2/core/net_async_base.cc b/caffe2/core/net_async_base.cc
index 742a3457ec916..89d579aeb4c1d 100644
--- a/caffe2/core/net_async_base.cc
+++ b/caffe2/core/net_async_base.cc
@@ -455,6 +455,7 @@ void AsyncNetBase::computeExecutionModeFlags() {
     check_stream_status_ = false;
     use_single_pool_ = true;
     use_per_net_pools_ = true;
+    is_blocking_ = true;
   } else if (net_type == kAsyncDag) {
     streams_per_gpu_ = 1;
     finish_chain_ = false;
@@ -462,6 +463,7 @@ void AsyncNetBase::computeExecutionModeFlags() {
     check_stream_status_ = false;
     use_single_pool_ = true;
     use_per_net_pools_ = true;
+    is_blocking_ = true;
   } else {
     streams_per_gpu_ = FLAGS_caffe2_streams_per_gpu;
     finish_chain_ = FLAGS_caffe2_net_async_finish_chain;
@@ -469,6 +471,7 @@ void AsyncNetBase::computeExecutionModeFlags() {
     check_stream_status_ = FLAGS_caffe2_net_async_check_stream_status;
     use_single_pool_ = FLAGS_caffe2_net_async_use_single_pool;
     use_per_net_pools_ = FLAGS_caffe2_net_async_use_per_net_pools;
+    is_blocking_ = false;
   }
 }
 
diff --git a/caffe2/core/net_async_base.h b/caffe2/core/net_async_base.h
index cebffa2e657da..c7047d2e64162 100644
--- a/caffe2/core/net_async_base.h
+++ b/caffe2/core/net_async_base.h
@@ -114,6 +114,7 @@ class AsyncNetBase : public NetBase {
   bool check_stream_status_;
   bool use_single_pool_;
   bool use_per_net_pools_;
+  bool is_blocking_;
 
   DISABLE_COPY_AND_ASSIGN(AsyncNetBase);
 
diff --git a/caffe2/core/net_async_scheduling.cc b/caffe2/core/net_async_scheduling.cc
index 5cf96d0a551fc..87c2a4b0c237f 100644
--- a/caffe2/core/net_async_scheduling.cc
+++ b/caffe2/core/net_async_scheduling.cc
@@ -203,6 +203,10 @@ bool AsyncSchedulingNet::RunAsync() {
     finishRun();
   }
 
+  if (is_blocking_) {
+    Wait();
+  }
+
   return true;
 }
 

From 01f8865f8b98f019cb4d5ffd5d368c15aeb2842b Mon Sep 17 00:00:00 2001
From: Yan Zhu <yzhu@fb.com>
Date: Tue, 12 Jun 2018 09:53:43 -0700
Subject: [PATCH 010/118] [dper] layernorm layer

as title
---
 caffe2/python/layers/layer_normalization.py | 76 +++++++++++++++++++++
 caffe2/python/layers_test.py                | 14 ++++
 2 files changed, 90 insertions(+)
 create mode 100644 caffe2/python/layers/layer_normalization.py

diff --git a/caffe2/python/layers/layer_normalization.py b/caffe2/python/layers/layer_normalization.py
new file mode 100644
index 0000000000000..db34adbd93c80
--- /dev/null
+++ b/caffe2/python/layers/layer_normalization.py
@@ -0,0 +1,76 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+from caffe2.python import schema
+from caffe2.python.layers.layers import ModelLayer
+
+import numpy as np
+
+
+class LayerNormalization(ModelLayer):
+    def __init__(
+        self,
+        model,
+        input_record,
+        name='layer_normalization',
+        scale_optim=None,
+        bias_optim=None,
+        epsilon=1e-4,
+        axis=1,
+        **kwargs
+    ):
+        super(LayerNormalization, self).__init__(
+            model, name, input_record, **kwargs)
+
+        assert isinstance(input_record, schema.Scalar), (
+            "Incorrect input type: {}".format(input_record))
+
+        self.input_shape = input_record.field_type().shape
+        self.epsilon = epsilon
+        self.axis = axis
+
+        assert len(self.input_shape) >= 1, (
+            "This layer supports only >= 2D tesnors")
+        input_dims = self.input_shape[0]
+
+        self.output_schema = schema.Scalar(
+            (np.float32, self.input_shape),
+            self.get_next_blob_reference('output')
+        )
+
+        self.scale = self.create_param(param_name='scale',
+                                       shape=[input_dims],
+                                       initializer=('ConstantFill', {'value': 1.0}),
+                                       optimizer=scale_optim)
+        self.bias = self.create_param(param_name='bias',
+                                       shape=[input_dims],
+                                       initializer=('ConstantFill', {'value': 0.0}),
+                                       optimizer=bias_optim)
+
+    def add_ops(self, net):
+        input_blob = self.input_record.field_blobs()
+        ln_output = self.output_schema.field_blobs()
+
+        output_blobs = [net.NextScopedBlob('ln_output'), net.NextScopedBlob('ln_mean'),
+                        net.NextScopedBlob('ln_stdev')]
+
+        normalized, mean, stdev = net.LayerNorm(input_blob,
+            output_blobs,
+            axis=self.axis,
+            epsilon=self.epsilon)
+
+        scaled = net.Mul(
+            [normalized, self.scale],
+            [net.NextScopedBlob('ln_scaled')],
+            broadcast=1,
+            axis=self.axis,
+        )
+
+        net.Add(
+            [scaled, self.bias],
+            ln_output,
+            broadcast=1,
+            axis=self.axis,
+        )
diff --git a/caffe2/python/layers_test.py b/caffe2/python/layers_test.py
index 278276609d594..4383c01b13915 100644
--- a/caffe2/python/layers_test.py
+++ b/caffe2/python/layers_test.py
@@ -769,6 +769,20 @@ def testBatchNormalization(self, X):
         schema.FeedRecord(input_record, [X])
         workspace.RunNetOnce(predict_net)
 
+    @given(
+        X=hu.arrays(dims=[2, 5, 6]),
+    )
+    def testLayerNormalization(self, X):
+        input_record = self.new_record(schema.Scalar((np.float32, (5, 6,))))
+        schema.FeedRecord(input_record, [X])
+        ln_output = self.model.LayerNormalization(input_record)
+        self.assertEqual(schema.Scalar((np.float32, (5, 6,))), ln_output)
+        self.model.output_schema = schema.Struct()
+
+        train_init_net, train_net = self.get_training_nets()
+        workspace.RunNetOnce(train_init_net)
+        workspace.RunNetOnce(train_net)
+
     @given(
         X=hu.arrays(dims=[5, 2]),
         num_to_collect=st.integers(min_value=1, max_value=10),

From 7fa1915adc31784fb2a1c0540858f2a5cf94a19d Mon Sep 17 00:00:00 2001
From: Ilia Cherniavskii <iliacher@fb.com>
Date: Tue, 12 Jun 2018 09:53:51 -0700
Subject: [PATCH 011/118] Override dag, async_dag, async_polling

Overriding dag, async_dag and async_polling with async_scheduling
---
 caffe2/core/net.cc | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/caffe2/core/net.cc b/caffe2/core/net.cc
index 9d6f536c06346..19f1c4798c717 100644
--- a/caffe2/core/net.cc
+++ b/caffe2/core/net.cc
@@ -104,17 +104,30 @@ std::vector<NetObserverCreator>* GetNetObserverCreators() {
   return &creators;
 }
 
+const std::unordered_map<std::string, std::string>& defaultOverrides() {
+  static const std::unordered_map<std::string, std::string> overrides = {
+      {"dag", "async_scheduling"},
+      {"async_dag", "async_scheduling"},
+      {"async_polling", "async_scheduling"},
+      {"async_simple", "simple"},
+  };
+  return overrides;
+}
+
 void checkExecutorOverride(std::string& net_type) {
   auto executors = caffe2::split(',', FLAGS_caffe2_override_executor);
   CAFFE_ENFORCE(
       executors.size() % 2 == 0, "Invalid override executors flag value");
   std::unordered_map<std::string, std::string> overrides;
+  for (const auto& kv : defaultOverrides()) {
+    overrides[kv.first] = kv.second;
+  }
   for (size_t idx = 0; idx < executors.size() - 1; idx += 2) {
     overrides[executors[idx]] = executors[idx + 1];
   }
   if (overrides.count(net_type)) {
-    LOG(INFO) << "Overrode net type '" << net_type << "' with '"
-              << overrides[net_type] << "'";
+    VLOG(1) << "Overrode net type '" << net_type << "' with '"
+            << overrides[net_type] << "'";
     net_type = overrides[net_type];
   }
 }
@@ -147,9 +160,7 @@ unique_ptr<NetBase> CreateNet(
     // sequentially.
     net_type = kSimpleNet;
   }
-  if (!FLAGS_caffe2_override_executor.empty()) {
-    checkExecutorOverride(net_type);
-  }
+  checkExecutorOverride(net_type);
   unique_ptr<NetBase> net = NetRegistry()->Create(net_type, net_def, ws);
 
   VLOG(1) << "Adding a global observer to a net";

From 2ace3e1211455f6a68ecca5b2b8e4273e05db0e8 Mon Sep 17 00:00:00 2001
From: Giuseppe Ottaviano <ott@fb.com>
Date: Tue, 12 Jun 2018 09:54:03 -0700
Subject: [PATCH 012/118] Name the thread pools

Caffe thread pools currently inherit the thread names from the thread that starts them, which can be misleading. Give them an explicit name instead.
---
 caffe2/core/net_dag.cc                |  3 +++
 caffe2/utils/thread_name.cc           | 24 ++++++++++++++++++++++++
 caffe2/utils/thread_name.h            |  9 +++++++++
 caffe2/utils/thread_pool.h            |  2 ++
 caffe2/utils/threadpool/ThreadPool.h  |  4 ++--
 caffe2/utils/threadpool/WorkersPool.h |  8 +++++---
 6 files changed, 45 insertions(+), 5 deletions(-)
 create mode 100644 caffe2/utils/thread_name.cc
 create mode 100644 caffe2/utils/thread_name.h

diff --git a/caffe2/core/net_dag.cc b/caffe2/core/net_dag.cc
index 8ecc17f902c95..e256362d409e9 100644
--- a/caffe2/core/net_dag.cc
+++ b/caffe2/core/net_dag.cc
@@ -11,6 +11,7 @@
 #include "caffe2/core/timer.h"
 #include "caffe2/proto/caffe2.pb.h"
 #include "caffe2/utils/proto_utils.h"
+#include "caffe2/utils/thread_name.h"
 
 CAFFE2_DEFINE_bool(
     caffe2_disable_chaining,
@@ -200,6 +201,8 @@ void DAGNetBase::HandleException(
 }
 
 void DAGNetBase::WorkerFunction() {
+  setThreadName("CaffeDAGNet");
+
   // WorkerFunctions() is an infinite loop until there are no more jobs to run.
   while (true) {
     int idx = 0;
diff --git a/caffe2/utils/thread_name.cc b/caffe2/utils/thread_name.cc
new file mode 100644
index 0000000000000..5fdcc22567756
--- /dev/null
+++ b/caffe2/utils/thread_name.cc
@@ -0,0 +1,24 @@
+#include "caffe2/utils/thread_name.h"
+
+#include <algorithm>
+
+#if defined(__GLIBC__) && !defined(__APPLE__) && !defined(__ANDROID__)
+#define CAFFE2_HAS_PTHREAD_SETNAME_NP
+#endif
+
+#ifdef CAFFE2_HAS_PTHREAD_SETNAME_NP
+#include <pthread.h>
+#endif
+
+namespace caffe2 {
+
+void setThreadName(std::string name) {
+#ifdef CAFFE2_HAS_PTHREAD_SETNAME_NP
+  constexpr size_t kMaxThreadName = 15;
+  name.resize(std::min(name.size(), kMaxThreadName));
+
+  pthread_setname_np(pthread_self(), name.c_str());
+#endif
+}
+
+} // namespace caffe2
diff --git a/caffe2/utils/thread_name.h b/caffe2/utils/thread_name.h
new file mode 100644
index 0000000000000..aece335c23dbc
--- /dev/null
+++ b/caffe2/utils/thread_name.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <string>
+
+namespace caffe2 {
+
+void setThreadName(std::string name);
+
+} // namespace caffe2
diff --git a/caffe2/utils/thread_pool.h b/caffe2/utils/thread_pool.h
index db25d7c30dfcf..3c10dd769e8eb 100644
--- a/caffe2/utils/thread_pool.h
+++ b/caffe2/utils/thread_pool.h
@@ -9,6 +9,7 @@
 #include <utility>
 
 #include "caffe2/core/numa.h"
+#include "caffe2/utils/thread_name.h"
 
 namespace caffe2 {
 
@@ -115,6 +116,7 @@ class TaskThreadPool {
  private:
   /// @brief Entry point for pool threads.
   void main_loop(std::size_t index) {
+    setThreadName("CaffeTaskThread");
     NUMABind(numa_node_id_);
 
     while (running_) {
diff --git a/caffe2/utils/threadpool/ThreadPool.h b/caffe2/utils/threadpool/ThreadPool.h
index 8c111d0ac044b..aa6c44ac7984c 100644
--- a/caffe2/utils/threadpool/ThreadPool.h
+++ b/caffe2/utils/threadpool/ThreadPool.h
@@ -19,12 +19,12 @@ class WorkersPool;
 
 constexpr size_t kCacheLineSize = 64;
 
-// A work-stealing threadpool with the given number of threads.
+// A threadpool with the given number of threads.
 // NOTE: the kCacheLineSize alignment is present only for cache
 // performance, and is not strictly enforced (for example, when
 // the object is created on the heap). Thus, in order to avoid
 // misaligned intrinsics, no SSE instructions shall be involved in
-// the ThreadPool implemetation.
+// the ThreadPool implementation.
 class alignas(kCacheLineSize) ThreadPool {
  public:
   static std::unique_ptr<ThreadPool> defaultThreadPool();
diff --git a/caffe2/utils/threadpool/WorkersPool.h b/caffe2/utils/threadpool/WorkersPool.h
index 9d2ffd57864b6..0c621d53854de 100644
--- a/caffe2/utils/threadpool/WorkersPool.h
+++ b/caffe2/utils/threadpool/WorkersPool.h
@@ -1,10 +1,11 @@
 #pragma once
 
-#include "caffe2/core/common.h"
-#include "caffe2/core/logging.h"
 #include <atomic>
-#include <thread>
 #include <condition_variable>
+#include <thread>
+#include "caffe2/core/common.h"
+#include "caffe2/core/logging.h"
+#include "caffe2/utils/thread_name.h"
 
 #if defined(_MSC_VER)
 #include <intrin.h>
@@ -262,6 +263,7 @@ class alignas(kGEMMLOWPCacheLineSize) Worker {
 
   // Thread entry point.
   void ThreadFunc() {
+    setThreadName("CaffeWorkersPool");
     ChangeState(State::Ready);
 
     // Thread main loop

From b9b458cfa87199c6f3fc4429183a1c49cc4041c8 Mon Sep 17 00:00:00 2001
From: Artem Volkhin <volkhin@fb.com>
Date: Tue, 12 Jun 2018 09:54:16 -0700
Subject: [PATCH 013/118] [Caffe2] FilleOp should support int64_t dimensions

Change argument type to int64_t for shape argument of FillerOp (used in ConstantFill, XavierFill, etc)
---
 caffe2/operators/filler_op.h                   |  8 ++++----
 caffe2/python/operator_test/filler_ops_test.py | 15 +++++++++++++++
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/caffe2/operators/filler_op.h b/caffe2/operators/filler_op.h
index 8fac761bdbb36..c144b70378273 100644
--- a/caffe2/operators/filler_op.h
+++ b/caffe2/operators/filler_op.h
@@ -22,7 +22,7 @@ class FillerOp : public Operator<Context> {
  public:
   FillerOp(const OperatorDef& operator_def, Workspace* ws)
       : Operator<Context>(operator_def, ws),
-        shape_(ToVectorTIndex(OperatorBase::GetRepeatedArgument<int>("shape"))),
+        shape_(OperatorBase::GetRepeatedArgument<int64_t>("shape")),
         extra_shape_(ToVectorTIndex(
             OperatorBase::GetRepeatedArgument<int>("extra_shape"))),
         input_as_shape_(
@@ -524,12 +524,12 @@ inline std::vector<TensorShape> FillerTensorInference(
       out[0].set_unknown_shape(true);
       return out;
     }
-    for (int d : in[0].dims()) {
+    for (auto d : in[0].dims()) {
       out[0].add_dims(d);
     }
   } else {
-    auto shape = helper.GetRepeatedArgument<int>("shape");
-    for (int d : shape) {
+    auto shape = helper.GetRepeatedArgument<int64_t>("shape");
+    for (auto d : shape) {
       out[0].add_dims(d);
     }
   }
diff --git a/caffe2/python/operator_test/filler_ops_test.py b/caffe2/python/operator_test/filler_ops_test.py
index 186778ee9416e..df13cba4a3b96 100644
--- a/caffe2/python/operator_test/filler_ops_test.py
+++ b/caffe2/python/operator_test/filler_ops_test.py
@@ -49,6 +49,21 @@ def test_shape_error(self, gc, dc):
         self.assertTrue(workspace.RunOperatorOnce(op))
         self.assertEqual(workspace.FetchBlob('out'), [2.0])
 
+    @given(**hu.gcs)
+    def test_int64_shape(self, gc, dc):
+        large_dim = 2 ** 31 + 1
+        net = core.Net("test_shape_net")
+        net.UniformFill(
+            [],
+            'out',
+            shape=[0, large_dim],
+            min=0.0,
+            max=1.0,
+        )
+        self.assertTrue(workspace.CreateNet(net))
+        self.assertTrue(workspace.RunNet(net.Name()))
+        self.assertEqual(workspace.blobs['out'].shape, (0, large_dim))
+
     @given(
         shape=hu.dims().flatmap(
             lambda dims: hu.arrays(

From db1f09971dffd10d0cbd1eb5f9ab8a2c057fb9c4 Mon Sep 17 00:00:00 2001
From: Dmytro Dzhulgakov <dzhulgakov@fb.com>
Date: Tue, 12 Jun 2018 09:54:41 -0700
Subject: [PATCH 014/118] Remove caffe2/caffe2/contrib/torch/

It's not used anywhere and depends on old lua torch that conflicts with Aten. Given PT1 it's not relevant any more (though it was nice and clever code!)

#accept2ship
---
 caffe2/contrib/torch/th_ops.cc         | 118 -----
 caffe2/contrib/torch/th_ops_gpu.cu     | 160 -------
 caffe2/contrib/torch/th_ops_test.py    |  50 ---
 caffe2/contrib/torch/torch_op.cpp      |  46 --
 caffe2/contrib/torch/torch_op.h        | 575 -------------------------
 caffe2/contrib/torch/torch_op_gpu.cpp  | 110 -----
 caffe2/contrib/torch/torch_ops_test.py | 135 ------
 7 files changed, 1194 deletions(-)
 delete mode 100644 caffe2/contrib/torch/th_ops.cc
 delete mode 100644 caffe2/contrib/torch/th_ops_gpu.cu
 delete mode 100644 caffe2/contrib/torch/th_ops_test.py
 delete mode 100644 caffe2/contrib/torch/torch_op.cpp
 delete mode 100644 caffe2/contrib/torch/torch_op.h
 delete mode 100644 caffe2/contrib/torch/torch_op_gpu.cpp
 delete mode 100644 caffe2/contrib/torch/torch_ops_test.py

diff --git a/caffe2/contrib/torch/th_ops.cc b/caffe2/contrib/torch/th_ops.cc
deleted file mode 100644
index b4e18a4d4e894..0000000000000
--- a/caffe2/contrib/torch/th_ops.cc
+++ /dev/null
@@ -1,118 +0,0 @@
-#include "caffe2/core/context.h"
-#include "caffe2/core/operator.h"
-
-extern "C" {
-#include <THNN.h>
-}
-
-namespace caffe2 {
-
-namespace {
-
-using UniqueTHFloatTensor =
-    std::unique_ptr<THFloatTensor, decltype(&THFloatTensor_free)>;
-
-UniqueTHFloatTensor aliasFromTensorCPU(TensorCPU* tensor) {
-  if (!tensor->ndim()) {
-    return UniqueTHFloatTensor(THFloatTensor_new(), THFloatTensor_free);
-  }
-
-  THLongStorage* thshape = THLongStorage_newWithSize(tensor->ndim());
-  for (int i = 0; i < tensor->ndim(); ++i) {
-    THLongStorage_set(thshape, i, tensor->dim(i));
-  }
-  THFloatStorage* storage = THFloatStorage_newWithData(
-      tensor->template mutable_data<float>(), tensor->size());
-  THFloatStorage_clearFlag(storage, TH_STORAGE_FREEMEM);
-  auto* th = THFloatTensor_newWithStorage(storage, 0, thshape, nullptr);
-  THFloatStorage_free(storage);
-  THLongStorage_free(thshape);
-  CAFFE_ENFORCE_EQ(
-      THFloatTensor_storage(th)->data, tensor->template mutable_data<float>());
-  return UniqueTHFloatTensor(th, THFloatTensor_free);
-}
-
-void copyToTensorCPU(UniqueTHFloatTensor th, TensorCPU* tensor) {
-  // TODO - if th and tensor point to the same data and have the same
-  // size, elide the copy!
-  th = UniqueTHFloatTensor(
-      THFloatTensor_newContiguous(th.get()), THFloatTensor_free);
-  const auto dims = std::vector<TIndex>(
-      th->size, th->size + THFloatTensor_nDimension(th.get()));
-  // Short-circuit if we never reallocated in TH
-  auto* storage = THFloatTensor_storage(th.get());
-  // Short-circuit if we never reallocated in TH
-  if (dims == tensor->dims() &&
-      storage->data == tensor->template data<float>()) {
-    THFloatStorage_clearFlag(storage, TH_STORAGE_FREEMEM);
-    return;
-  }
-  tensor->Resize(dims);
-  CPUContext ctx;
-  ctx.Copy<float, CPUContext, CPUContext>(
-      tensor->size(), storage->data, tensor->mutable_data<float>());
-}
-
-// _Everything_ below here can be autogenerated with the TBD
-// THNN/THCUNN schema. This is just a proof of concept.
-
-class THNNELUCPUOp final : public Operator<CPUContext> {
- public:
-  USE_OPERATOR_FUNCTIONS(CPUContext);
-  using Operator<CPUContext>::Operator;
-  bool RunOnDevice() override {
-    // TODO - we can autogenerate this from a schema.
-    auto X = aliasFromTensorCPU(const_cast<TensorCPU*>(&Input(0)));
-    auto Y = aliasFromTensorCPU(Output(0));
-    THNN_FloatELU_updateOutput(
-        nullptr,
-        X.get(),
-        Y.get(),
-        GetSingleArgument<float>("alpha", 1.0),
-        &Input(0) == Output(0));
-    copyToTensorCPU(std::move(Y), Output(0));
-    return true;
-  }
-};
-
-class THNNELUCPUGradientOp final : public Operator<CPUContext> {
- public:
-  USE_OPERATOR_FUNCTIONS(CPUContext);
-  using Operator<CPUContext>::Operator;
-
-  bool RunOnDevice() override {
-    // TODO - we can autogenerate this from a schema.
-    auto X = aliasFromTensorCPU(const_cast<TensorCPU*>(&Input(0)));
-    auto Y = aliasFromTensorCPU(const_cast<TensorCPU*>(&Input(1)));
-    auto dY = aliasFromTensorCPU(const_cast<TensorCPU*>(&Input(2)));
-    auto dX = aliasFromTensorCPU(Output(0));
-    THNN_FloatELU_updateGradInput(
-        nullptr,
-        X.get(),
-        dY.get(),
-        dX.get(),
-        Y.get(),
-        GetSingleArgument<float>("alpha", 1.0),
-        &Input(2) == Output(0) /* inplace */);
-    copyToTensorCPU(std::move(dX), Output(0));
-    return true;
-  }
-};
-
-REGISTER_CPU_OPERATOR_WITH_ENGINE(ELU, THNN, THNNELUCPUOp);
-REGISTER_CPU_OPERATOR_WITH_ENGINE(ELUGradient, THNN, THNNELUCPUGradientOp);
-
-class GetELUGradient : public GradientMakerBase {
-  using GradientMakerBase::GradientMakerBase;
-  vector<OperatorDef> GetGradientDefs() override {
-    return SingleGradientDef(
-        "ELUGradient",
-        "",
-        vector<string>{I(0), O(0), GO(0)},
-        vector<string>{GI(0)},
-        Def().arg());
-  }
-};
-REGISTER_GRADIENT(ELU, GetELUGradient);
-}
-}
diff --git a/caffe2/contrib/torch/th_ops_gpu.cu b/caffe2/contrib/torch/th_ops_gpu.cu
deleted file mode 100644
index a998384316771..0000000000000
--- a/caffe2/contrib/torch/th_ops_gpu.cu
+++ /dev/null
@@ -1,160 +0,0 @@
-#include "caffe2/core/context.h"
-#include "caffe2/core/context_gpu.h"
-#include "caffe2/core/operator.h"
-
-#include <THCAllocator.h>
-#include <THCStorage.h>
-#include <THCTensor.h>
-
-#include <THCUNN.h>
-
-namespace caffe2 {
-
-namespace {
-
-THCState* getTHCState() {
-  // TODO don't leak the THCState. We only have as many threads as
-  // e.g. the number of AsyncDAGNet worker threads, which is small
-  // (O(numGPUs)).
-  static thread_local THCState* state = nullptr;
-  if (!state) {
-    state = new THCState();
-    THCudaInit(state);
-    CHECK_NOTNULL(state);
-  }
-  return state;
-}
-
-struct THCudaTensorDeleter {
-  explicit THCudaTensorDeleter(THCState* state)
-      : state_(CHECK_NOTNULL(state)) {}
-  void operator()(THCudaTensor* th) {
-    THCudaTensor_free(state_, th);
-  }
-
-  THCState* state_{nullptr};
-};
-
-using UniqueTHCudaTensor = std::unique_ptr<THCudaTensor, THCudaTensorDeleter>;
-
-THCState* thnnState(CUDAContext* context) {
-  THCState* state = getTHCState();
-  THCStream* stream = THCState_getStream(state);
-  // TODO - swap these back after we're done before we handle
-  // deletion.
-  // TODO - handle proper destroy of existing handle
-  // (if not already caffe2 set handle)
-  stream->stream = context->cuda_stream();
-
-  // TODO - destroy the current handle
-  int device;
-  THCudaCheck(cudaGetDevice(&device));
-  int blasHandleIndex = THCState_getCurrentBlasHandleIndex(state);
-  THCState_getDeviceBlasHandle(state, device, blasHandleIndex); // to reserve
-  THCCudaResourcesPerDevice* res = &(state->resourcesPerDevice[device]);
-  res->blasHandles[blasHandleIndex - 1] = context->cublas_handle();
-  return state;
-}
-
-UniqueTHCudaTensor aliasFromTensorCUDA(
-    CUDAContext* context,
-    TensorCUDA* tensor) {
-  auto* state = thnnState(context);
-  if (!tensor->ndim()) {
-    return UniqueTHCudaTensor(
-        THCudaTensor_new(state), THCudaTensorDeleter(state));
-  }
-  THLongStorage* thshape = THLongStorage_newWithSize(tensor->ndim());
-  for (int i = 0; i < tensor->ndim(); ++i) {
-    THLongStorage_set(thshape, i, tensor->dim(i));
-  }
-  THCudaStorage* storage = THCudaStorage_newWithData(
-      state, tensor->mutable_data<float>(), tensor->size());
-  THCudaStorage_clearFlag(state, storage, TH_STORAGE_FREEMEM);
-  auto* th =
-      THCudaTensor_newWithStorage(state, storage, 0, thshape, nullptr);
-  THCudaStorage_free(state, storage);
-  THLongStorage_free(thshape);
-  CAFFE_ENFORCE_EQ(
-      THCudaTensor_storage(state, th)->data,
-      tensor->mutable_data<float>());
-  return UniqueTHCudaTensor(th, THCudaTensorDeleter(state));
-}
-
-void copyToTensorCUDA(
-    CUDAContext* context,
-    UniqueTHCudaTensor th,
-    TensorCUDA* tensor) {
-  auto* state = thnnState(context);
-  // As contiguous
-  th = UniqueTHCudaTensor(
-      THCudaTensor_newContiguous(state, th.get()),
-      THCudaTensorDeleter(state));
-  const auto dims = std::vector<TIndex>(
-      th->size, th->size + THCudaTensor_nDimension(state, th.get()));
-  auto* storage = THCudaTensor_storage(state, th.get());
-  // Short-circuit if we never reallocated in TH
-  if (dims == tensor->dims() && storage->data == tensor->data<float>()) {
-    THCudaStorage_clearFlag(state, storage, TH_STORAGE_FREEMEM);
-    return;
-  }
-
-  tensor->Resize(dims);
-  context->Copy<float, CUDAContext, CUDAContext>(
-      tensor->size(), storage->data, tensor->mutable_data<float>());
-}
-
-// _Everything_ below here can be autogenerated with the TBD
-// THNN/THCUNN schema. This is just a proof of concept.
-
-class THNNELUCUDAOp final : public Operator<CUDAContext> {
- public:
-  USE_OPERATOR_FUNCTIONS(CUDAContext);
-  using Operator<CUDAContext>::Operator;
-
-  bool RunOnDevice() override {
-    // TODO - we can autogenerate this from a schema.
-    auto* state = thnnState(&context_);
-    auto X = aliasFromTensorCUDA(&context_, const_cast<TensorCUDA*>(&Input(0)));
-    auto Y = aliasFromTensorCUDA(&context_, Output(0));
-    THNN_CudaELU_updateOutput(
-        state,
-        X.get(),
-        Y.get(),
-        GetSingleArgument<float>("alpha", 1.0),
-        &Input(0) == Output(0));
-    copyToTensorCUDA(&context_, std::move(Y), Output(0));
-    return true;
-  }
-};
-
-class THNNELUCUDAGradientOp final : public Operator<CUDAContext> {
- public:
-  USE_OPERATOR_FUNCTIONS(CUDAContext);
-  using Operator<CUDAContext>::Operator;
-
-  bool RunOnDevice() override {
-    // TODO - we can autogenerate this from a schema.
-    auto* state = thnnState(&context_);
-    auto X = aliasFromTensorCUDA(&context_, const_cast<TensorCUDA*>(&Input(0)));
-    auto Y = aliasFromTensorCUDA(&context_, const_cast<TensorCUDA*>(&Input(1)));
-    auto dY =
-        aliasFromTensorCUDA(&context_, const_cast<TensorCUDA*>(&Input(2)));
-    auto dX = aliasFromTensorCUDA(&context_, Output(0));
-    THNN_CudaELU_updateGradInput(
-        state,
-        X.get(),
-        dY.get(),
-        dX.get(),
-        Y.get(),
-        GetSingleArgument<float>("alpha", 1.0),
-        &Input(2) == Output(0) /* inplace */);
-    copyToTensorCUDA(&context_, std::move(dX), Output(0));
-    return true;
-  }
-};
-
-REGISTER_CUDA_OPERATOR_WITH_ENGINE(ELU, THNN, THNNELUCUDAOp);
-REGISTER_CUDA_OPERATOR_WITH_ENGINE(ELUGradient, THNN, THNNELUCUDAGradientOp);
-}
-}
diff --git a/caffe2/contrib/torch/th_ops_test.py b/caffe2/contrib/torch/th_ops_test.py
deleted file mode 100644
index 09d7d1635d58d..0000000000000
--- a/caffe2/contrib/torch/th_ops_test.py
+++ /dev/null
@@ -1,50 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-from caffe2.python import core, dyndep
-import caffe2.python.hypothesis_test_util as hu
-
-from hypothesis import given
-import hypothesis.strategies as st
-import numpy as np
-
-dyndep.InitOpsLibrary('@/caffe2/caffe2/contrib/torch:th_ops')
-
-
-try:
-    dyndep.InitOpsLibrary('@/caffe2/caffe2/contrib/torch:th_ops_gpu')
-    HAS_GPU = True
-except Exception as e:
-    print("Exception loading Torch GPU library: ", e)
-    # GPU import can fail, as Torch is not using cuda-lazy
-    HAS_GPU = False
-    pass
-
-
-class THOpsTest(hu.HypothesisTestCase):
-    @given(X=hu.tensor(),
-           alpha=st.floats(min_value=0.1, max_value=2.0),
-           in_place=st.booleans(),
-           **(hu.gcs if HAS_GPU else hu.gcs_cpu_only))
-    def test_elu(self, X, alpha, in_place, gc, dc):
-        op = core.CreateOperator(
-            "ELU",
-            ["X"],
-            ["X" if in_place else "Y"],
-            engine="THNN",
-            alpha=alpha)
-        self.assertDeviceChecks(dc, op, [X], [0])
-
-        def elu(X):
-            Y = np.copy(X)
-            Y[Y <= 0] = (np.exp(Y[Y <= 0]) - 1) * alpha
-            return (Y,)
-
-        self.assertReferenceChecks(gc, op, [X], elu)
-        # Avoid the nonlinearity at 0 for gradient checker.
-        X[X == 0] += 0.2
-        X[np.abs(X) < 0.2] += np.sign(X[np.abs(X) < 0.2])
-        assert len(X[np.abs(X) < 0.2]) == 0
-        self.assertGradientChecks(gc, op, [X], 0, [0])
diff --git a/caffe2/contrib/torch/torch_op.cpp b/caffe2/contrib/torch/torch_op.cpp
deleted file mode 100644
index 3e9f9b0bdc1b9..0000000000000
--- a/caffe2/contrib/torch/torch_op.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "torch_op.h"
-
-namespace caffe2 {
-
-namespace torch {
-
-const char* TyTraits<CPUContext>::moduleTy = "float";
-const char* TyTraits<CPUContext>::tensorTy = "torch.FloatTensor";
-const char* TyTraits<CPUContext>::prelude = R"(
-        require 'torch'
-        require 'nn'
-)";
-}
-
-struct GetTorchGradient : public GradientMakerBase {
-  using GradientMakerBase::GradientMakerBase;
-  std::vector<OperatorDef> GetGradientDefs() override {
-    std::vector<std::string> gradientInputs;
-    for (int i = 0; i < def_.input_size(); ++i) {
-      gradientInputs.push_back(I(i));
-    }
-    for (int i = 0; i < def_.output_size(); ++i) {
-      gradientInputs.push_back(O(i));
-    }
-    for (int i = 0; i < def_.output_size(); ++i) {
-      gradientInputs.push_back(GO(i));
-    }
-    std::vector<std::string> gradientOutputs;
-    for (int i = 0; i < def_.input_size(); ++i) {
-      gradientOutputs.push_back(GI(i));
-    }
-
-    return SingleGradientDef(
-        "TorchGradient", "", gradientInputs, gradientOutputs);
-  }
-};
-
-
-REGISTER_CPU_OPERATOR(Torch, TorchOp<CPUContext>);
-REGISTER_CPU_OPERATOR(TorchInit, TorchInitOp<CPUContext>);
-REGISTER_CPU_OPERATOR(TorchGradient, TorchGradientOp<CPUContext>);
-REGISTER_GRADIENT(Torch, GetTorchGradient);
-OPERATOR_SCHEMA(Torch).AllowInplace([](int, int) { return true; });
-OPERATOR_SCHEMA(TorchInit);
-OPERATOR_SCHEMA(TorchGradient).AllowInplace([](int, int) { return true; });
-}
diff --git a/caffe2/contrib/torch/torch_op.h b/caffe2/contrib/torch/torch_op.h
deleted file mode 100644
index c5860364400b5..0000000000000
--- a/caffe2/contrib/torch/torch_op.h
+++ /dev/null
@@ -1,575 +0,0 @@
-#pragma once
-#include <unordered_map>
-
-#include "caffe2/core/context.h"
-#include "caffe2/core/operator.h"
-#include "caffe2/core/tensor.h"
-
-extern "C" {
-#include <TH/THStorage.h>
-#include <TH/THTensor.h>
-#include <lua.h>
-#include <luaT.h>
-#include <lualib.h>
-}
-
-namespace caffe2 {
-
-namespace torch {
-
-template <typename Context>
-struct TyTraits {};
-
-template <>
-struct TyTraits<CPUContext> {
-  static const char* moduleTy;
-  static const char* prelude;
-  static const char* tensorTy;
-  using Tensor = THFloatTensor;
-};
-
-template <typename Context>
-class Torch final {
- public:
-  using Traits = TyTraits<Context>;
-  Torch() {
-    L_ = luaL_newstate();
-    luaL_openlibs(L_);
-    luaL_loadstring(L_, Traits::prelude);
-    int err = lua_pcall(L_, 0, 0, 0);
-    CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L_, -1));
-  };
-
-  ~Torch() {
-    lua_close(L_);
-  }
-
-  lua_State* L() {
-    return L_;
-  }
-
-  static const char* tensorTy(const Blob& blob) {
-    CAFFE_ENFORCE(blob.template IsType<Tensor<Context>>());
-    const auto& tc = blob.template Get<Tensor<Context>>();
-    CAFFE_ENFORCE(
-        tc.template IsType<float>() + tc.meta().name(), ", ", tc.size());
-    return Traits::tensorTy;
-  }
-
-  void setContext(Context* /*context*/) {}
-
-  void setTensor(typename Traits::Tensor* t, Blob* blob) {
-    CAFFE_ENFORCE_EQ(tensorTy(*blob), Traits::tensorTy);
-    auto* tc = blob->template GetMutable<Tensor<Context>>();
-    CAFFE_ENFORCE_EQ(THFloatTensor_nElement(t), tc->size());
-    THFloatStorage* storage = THFloatStorage_newWithData(
-        tc->template mutable_data<float>(), tc->size());
-    THFloatStorage_clearFlag(storage, TH_STORAGE_FREEMEM);
-    THFloatStorage* original = t->storage;
-    t->storage = storage;
-    THFloatStorage_free(original);
-  }
-
-  std::vector<TIndex> tensorShape(typename Traits::Tensor* t) {
-    auto* size = t->size;
-    return std::vector<TIndex>(size, size + THFloatTensor_nDimension(t));
-  }
-
-  typename Traits::Tensor* newTensorAs(const Tensor<Context>& tc) {
-    THLongStorage* thshape = THLongStorage_newWithSize(tc.ndim());
-    for (uint32_t i = 0; i < tc.ndim(); ++i) {
-      THLongStorage_set(thshape, i, tc.dim(i));
-    }
-    THFloatTensor* d = THFloatTensor_newWithSize(thshape, nullptr);
-    THLongStorage_free(thshape);
-    return d;
-  }
-
-  typename Traits::Tensor* blobToTensor(Blob* blob) {
-    CAFFE_ENFORCE_EQ(tensorTy(*blob), Traits::tensorTy);
-    auto* tc = blob->template GetMutable<Tensor<Context>>();
-
-    size_t size = tc->size();
-    THLongStorage* thshape = THLongStorage_newWithSize(tc->ndim());
-    for (int i = 0; i < tc->ndim(); ++i) {
-      THLongStorage_set(thshape, i, tc->dim(i));
-    }
-    THFloatStorage* storage =
-        THFloatStorage_newWithData(tc->template mutable_data<float>(), size);
-    THFloatStorage_clearFlag(storage, TH_STORAGE_FREEMEM);
-    auto* th = THFloatTensor_newWithStorage(storage, 0, thshape, nullptr);
-    THFloatStorage_free(storage);
-    THLongStorage_free(thshape);
-    CAFFE_ENFORCE_EQ(
-        THFloatTensor_storage(th)->data, tc->template mutable_data<float>());
-    return th;
-  }
-
-  std::vector<typename Traits::Tensor*> pushTable(
-      const std::vector<Blob*>& blobs) {
-    if (blobs.empty()) {
-      lua_pushnil(L());
-      return {};
-    }
-
-    if (blobs.size() == 1) {
-      auto* th = blobToTensor(blobs[0]);
-      luaT_pushudata(L(), th, tensorTy(*blobs[0]));
-      return {th};
-    }
-
-    std::vector<typename Traits::Tensor*> res;
-    lua_createtable(L(), blobs.size(), 0);
-    int index = 1;
-    for (auto* blob : blobs) {
-      auto* th = blobToTensor(blob);
-      res.push_back(th);
-      luaT_pushudata(L(), th, tensorTy(*blob));
-      lua_rawseti(L(), -2, index++);
-    }
-    return res;
-  }
-
-  void verifyOutput(Blob* dst, typename Traits::Tensor* torchDst) {
-    if (!luaT_isudata(L(), -1, Traits::tensorTy)) {
-      LOG(FATAL) << "Unsupported Torch tensor type " << luaT_typename(L(), -1);
-    }
-
-    // Invariant: dst has the same size as src, and has the same data
-    // values as src.
-    auto* src = static_cast<typename Traits::Tensor*>(
-        luaT_toudata(L(), -1, Traits::tensorTy));
-    auto* thDst = static_cast<typename Traits::Tensor*>(torchDst);
-    auto* tcDst = dst->template GetMutable<Tensor<Context>>();
-    CAFFE_ENFORCE(src->storage->data);
-    CAFFE_ENFORCE(src->storage->size);
-    CAFFE_ENFORCE_EQ(src->storage->data, thDst->storage->data);
-    CAFFE_ENFORCE_EQ(src->storage->data, tcDst->template data<float>());
-    CAFFE_ENFORCE_EQ(src->storage->size, thDst->storage->size);
-    CAFFE_ENFORCE_EQ(src->storage->size, tcDst->size());
-  }
-
-  void verifyOutputs(
-      const std::vector<Blob*>& blobs,
-      const std::vector<typename Traits::Tensor*>& tensors) {
-    CAFFE_ENFORCE_EQ(tensors.size(), blobs.size());
-
-    if (blobs.empty()) {
-      return;
-    }
-
-    if (blobs.size() == 1) {
-      verifyOutput(blobs[0], tensors[0]);
-      return;
-    }
-
-    CAFFE_ENFORCE(lua_istable(L(), -1));
-    lua_pushnil(L());
-    for (auto i = 0; i < blobs.size(); ++i) {
-      CAFFE_ENFORCE(lua_next(L(), -2));
-      verifyOutput(blobs[i], tensors[i]);
-      lua_pop(L(), 1);
-    }
-    lua_pop(L(), 1);
-  }
-
-private:
-  lua_State* L_;
-};
-}
-
-template <typename Context>
-class TorchOpBase : public Operator<Context> {
- public:
-  USE_OPERATOR_CONTEXT_FUNCTIONS;
-  using OperatorBase::Outputs;
-  using OperatorBase::Inputs;
-  TorchOpBase(const OperatorDef& operator_def, Workspace* ws)
-      : Operator<Context>(operator_def, ws) {
-    lua_State* L = state_.L();
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-    const auto initString = "return " +
-        OperatorBase::GetSingleArgument<std::string>("init", "") + ":" +
-        torch::Torch<Context>::Traits::moduleTy + "()";
-    CAFFE_ENFORCE_EQ(luaL_loadstring(L, initString.c_str()), 0);
-    int err = lua_pcall(L, 0, 1, 0);
-    CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L, -1));
-    // Get number of parameters
-    uint32_t numParams = 0;
-    lua_getfield(L, -1, "parameters");
-    lua_pushvalue(L, -2);
-    CAFFE_ENFORCE_EQ(lua_pcall(L, 1, LUA_MULTRET, 0), 0);
-    if (lua_gettop(L) == 1) {
-      numParams = 0;
-    } else {
-      CAFFE_ENFORCE_EQ(lua_gettop(L), 3);
-      numParams = lua_objlen(L, -2);
-      lua_pop(L, 2);
-    }
-    CAFFE_ENFORCE_EQ(
-        numParams, OperatorBase::GetSingleArgument<int>("num_params", 0));
-    // TODO: free parameters?
-    self_ = luaL_ref(L, LUA_REGISTRYINDEX);
-  }
-
-  void reshapeBlobs(
-      const std::vector<Blob*>& inputBlobs,
-      const std::vector<Blob*>& paramBlobs,
-      const std::vector<Blob*>& outputBlobs) {
-    auto cacheEqual = [=]() {
-      if (cachedInputSizes_.size() != inputBlobs.size()) {
-        return false;
-      }
-
-      for (auto i = 0; i < inputBlobs.size(); ++i) {
-        const auto& current =
-            inputBlobs[i]->template Get<Tensor<Context>>().dims();
-        const auto& cached = cachedInputSizes_[i];
-        if (current != cached) {
-          return false;
-        }
-      }
-      return true;
-    };
-
-    if (cacheEqual()) {
-      return;
-    }
-    LOG(INFO) << "Cached blobs not equal, running :updateOutput to reshape";
-    lua_State* L = state_.L();
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-    lua_rawgeti(L, LUA_REGISTRYINDEX, self_);
-    lua_getfield(L, -1, "updateOutput");
-    lua_pushvalue(L, -2); // self
-    if (inputBlobs.size() == 1) {
-      const auto& tc = inputBlobs[0]->template Get<Tensor<Context>>();
-      auto* inputData = state_.newTensorAs(tc);
-      luaT_pushudata(L, inputData, torch::Torch<Context>::Traits::tensorTy);
-    } else if (inputBlobs.size() > 1) {
-      lua_createtable(L, inputBlobs.size(), 0);
-      for (auto i = 0; i < inputBlobs.size(); ++i) {
-        const auto* blob = inputBlobs[i];
-        const auto& tc = blob->template Get<Tensor<Context>>();
-        auto* inputData = state_.newTensorAs(tc);
-        luaT_pushudata(L, inputData, torch::Torch<Context>::Traits::tensorTy);
-        lua_rawseti(L, -2, i + 1);
-      }
-    }
-    int err = lua_pcall(L, 2, 0, 0);
-    CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L, -1));
-    if (paramBlobs.size() != 0) {
-      lua_getfield(L, -1, "parameters");
-      lua_pushvalue(L, -2);
-      int err2 = lua_pcall(L, 1, LUA_MULTRET, 0);
-      CAFFE_ENFORCE_EQ(err2, 0);
-      CAFFE_ENFORCE_EQ(lua_gettop(L), 3);
-      lua_pushnil(L);
-      int i = 0;
-      while (lua_next(L, -3) && i < paramBlobs.size()) {
-        CAFFE_ENFORCE(
-            luaT_isudata(L, -1, torch::Torch<Context>::Traits::tensorTy));
-        auto* param =
-            static_cast<typename torch::Torch<Context>::Traits::Tensor*>(
-                luaT_toudata(L, -1, torch::Torch<Context>::Traits::tensorTy));
-        auto paramShape = state_.tensorShape(param);
-        auto* blob = paramBlobs[i];
-        auto* tc = blob->template GetMutable<Tensor<Context>>();
-        if (tc->size() == 0) {
-          tc->Resize(paramShape);
-          tc->template mutable_data<float>();
-        } else {
-          CAFFE_ENFORCE(tc->dims() == paramShape);
-        }
-        lua_pop(L, 1);
-        i++;
-      }
-      CAFFE_ENFORCE_EQ(i, paramBlobs.size());
-      lua_pop(L, 2);
-    }
-    lua_getfield(L, -1, "output");
-    if (outputBlobs.size() == 0) {
-    } else if (outputBlobs.size() == 1) {
-      CAFFE_ENFORCE(
-          luaT_isudata(L, -1, torch::Torch<Context>::Traits::tensorTy));
-      auto* output =
-          static_cast<typename torch::Torch<Context>::Traits::Tensor*>(
-              luaT_toudata(L, -1, torch::Torch<Context>::Traits::tensorTy));
-      auto outputShape = state_.tensorShape(output);
-      auto* blob = outputBlobs[0];
-      auto* tc = blob->template GetMutable<Tensor<Context>>();
-      tc->Resize(outputShape);
-      tc->template mutable_data<float>();
-    } else {
-      lua_pushnil(L);
-      auto i = 0;
-      while (lua_next(L, -2) && i < outputBlobs.size()) {
-        CAFFE_ENFORCE(
-            luaT_isudata(L, -1, torch::Torch<Context>::Traits::tensorTy));
-        auto* output =
-            static_cast<typename torch::Torch<Context>::Traits::Tensor*>(
-                luaT_toudata(L, -1, torch::Torch<Context>::Traits::tensorTy));
-        auto outputShape = state_.tensorShape(output);
-        auto* blob = outputBlobs[i];
-        auto* tc = blob->template GetMutable<Tensor<Context>>();
-        if (tc->size() == 0) {
-          tc->Resize(outputShape);
-          tc->template mutable_data<float>();
-        } else {
-          CAFFE_ENFORCE(tc->dims() == outputShape);
-        }
-        ++i;
-      }
-      CAFFE_ENFORCE_EQ(i, outputBlobs.size());
-    }
-    lua_pop(L, 2);
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-
-    cachedInputSizes_.clear();
-    for (const auto* blob : inputBlobs) {
-      const auto& dims = blob->template Get<Tensor<Context>>().dims();
-      cachedInputSizes_.push_back(dims);
-    }
-  }
-
- protected:
-  torch::Torch<Context> state_;
-  int self_{0};
-  std::vector<std::vector<TIndex>> cachedInputSizes_;
-};
-
-template <typename Context>
-class TorchOp : public TorchOpBase<Context> {
- public:
-  USE_OPERATOR_CONTEXT_FUNCTIONS;
-  using OperatorBase::Outputs;
-  using OperatorBase::Inputs;
-  using TorchOpBase<Context>::state_;
-  using TorchOpBase<Context>::self_;
-
-  using TorchOpBase<Context>::TorchOpBase;
-
-  bool RunOnDevice() final {
-    const auto numInputs =
-        OperatorBase::GetSingleArgument<int>("num_inputs", 1);
-    const auto numParams =
-        OperatorBase::GetSingleArgument<int>("num_params", 0);
-    const auto numOutputs =
-        OperatorBase::GetSingleArgument<int>("num_outputs", 1);
-    CAFFE_ENFORCE_EQ(InputSize(), numInputs + numParams);
-    CAFFE_ENFORCE_EQ(OutputSize(), numOutputs);
-
-    std::vector<Blob*> inputBlobs;
-    for (auto i = 0; i < numInputs; ++i) {
-      inputBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    std::vector<Blob*> paramBlobs;
-    for (auto i = numInputs; i < numInputs + numParams; ++i) {
-      paramBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    // Outputs must already be pre-sized
-    this->reshapeBlobs(inputBlobs, paramBlobs, Outputs());
-
-    lua_State* L = state_.L();
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-    state_.setContext(&context_);
-
-    // Deserialize self table
-    lua_rawgeti(L, LUA_REGISTRYINDEX, self_);
-
-    auto torchOutputs = state_.pushTable(Outputs());
-    // set the output field
-    lua_setfield(L, -2, "output");
-    // set the parameters
-    if (numParams != 0) {
-      // get the parameters into the stack
-      lua_getfield(L, -1, "parameters");
-      lua_pushvalue(L, -2);
-      int err = lua_pcall(L, 1, 1, 0);
-      CAFFE_ENFORCE_EQ(err, 0);
-      // iterate the parameters table to put tblobs inside
-      lua_pushnil(L);
-      auto i = 0;
-      while (lua_next(L, -2) && i < numParams) {
-        CAFFE_ENFORCE(
-            luaT_isudata(L, -1, state_.tensorTy(*paramBlobs[i])),
-            luaT_typename(L, -1));
-        auto* udata = luaT_toudata(L, -1, state_.tensorTy(*paramBlobs[i]));
-        state_.setTensor(
-            static_cast<typename torch::Torch<Context>::Traits::Tensor*>(udata),
-            const_cast<Blob*>(paramBlobs[i]));
-        i++;
-        lua_pop(L, 1);
-      }
-      CAFFE_ENFORCE_EQ(i, numParams);
-      lua_pop(L, 1); // pop the parameter table
-    }
-    // call updateOutput
-    // | self
-    lua_getfield(L, -1, "updateOutput");
-    // | self | updateOutput
-    lua_pushvalue(L, -2);
-    // | self | updateOutput | self
-    auto torchInputs = state_.pushTable(inputBlobs);
-    // | self | updateOutput | self | inputs
-    int err = lua_pcall(L, 2, 1, 0); // doesn't need the output
-    CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L, -1));
-    state_.verifyOutputs(Outputs(), torchOutputs);
-    lua_pop(L, 2);
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-    return true;
-  }
-};
-
-template <typename Context>
-class TorchInitOp : public TorchOpBase<Context> {
- public:
-  USE_OPERATOR_CONTEXT_FUNCTIONS;
-  using OperatorBase::Outputs;
-  using OperatorBase::Inputs;
-  using TorchOpBase<Context>::TorchOpBase;
-
-  bool RunOnDevice() final {
-    const auto numInputs =
-        OperatorBase::GetSingleArgument<int>("num_inputs", 1);
-    const auto numParams =
-        OperatorBase::GetSingleArgument<int>("num_params", 0);
-    const auto numOutputs =
-        OperatorBase::GetSingleArgument<int>("num_outputs", 1);
-    std::vector<Blob*> inputBlobs;
-    for (auto i = 0; i < numInputs; ++i) {
-      inputBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    std::vector<Blob*> paramBlobs;
-    for (auto i = numInputs; i < numInputs + numParams; ++i) {
-      paramBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    this->reshapeBlobs(inputBlobs, paramBlobs, Outputs());
-    return true;
-  }
-};
-
-template <typename Context>
-class TorchGradientOp : public TorchOpBase<Context> {
- public:
-  USE_OPERATOR_CONTEXT_FUNCTIONS;
-  using OperatorBase::Outputs;
-  using OperatorBase::Inputs;
-  using TorchOpBase<Context>::state_;
-  using TorchOpBase<Context>::self_;
-  using TorchOpBase<Context>::TorchOpBase;
-
-  bool RunOnDevice() final {
-    const auto numInputs =
-        OperatorBase::GetSingleArgument<int>("num_inputs", 1);
-    const auto numParams =
-        OperatorBase::GetSingleArgument<int>("num_params", 0);
-    const auto numOutputs =
-        OperatorBase::GetSingleArgument<int>("num_outputs", 1);
-    lua_State* L = state_.L();
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-    // inputs, params, outputs, grad outputs
-    CAFFE_ENFORCE_EQ(InputSize(), numInputs + numParams + 2 * numOutputs);
-    // grad inputs, grad params
-    CAFFE_ENFORCE_EQ(OutputSize(), numInputs + numParams);
-    state_.setContext(&context_);
-
-    std::vector<Blob*> outputBlobs;
-    for (auto i = numInputs + numParams; i < numInputs + numParams + numOutputs;
-         ++i) {
-      outputBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    std::vector<Blob*> inputBlobs;
-    for (auto i = 0; i < numInputs; ++i) {
-      inputBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    std::vector<Blob*> gradOutputBlobs;
-    for (auto i = numInputs + numParams + numOutputs;
-         i < numInputs + numParams + numOutputs + numOutputs;
-         ++i) {
-      gradOutputBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    std::vector<Blob*> gradInputBlobs;
-    for (auto i = 0; i < numInputs; ++i) {
-      gradInputBlobs.push_back(Outputs()[i]);
-    }
-    std::vector<Blob*> paramBlobs;
-    for (auto i = numInputs; i < numInputs + numParams; ++i) {
-      paramBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    std::vector<Blob*> gradParamBlobs;
-    for (auto i = numInputs; i < numInputs + numParams; ++i) {
-      gradParamBlobs.push_back(Outputs()[i]);
-    }
-
-    // Ensure shapes are correct.
-    for (auto i = 0; i < OutputSize(); ++i) {
-      Output(i)->ResizeLike(Input(i));
-      Output(i)->template mutable_data<float>();
-    }
-
-    lua_rawgeti(L, LUA_REGISTRYINDEX, self_);
-    state_.pushTable(outputBlobs);
-    lua_setfield(L, -2, "output");
-
-    const auto& torchGradInputs = state_.pushTable(gradInputBlobs);
-    lua_setfield(L, -2, "gradInput");
-    if (numParams != 0) {
-      // get the parameters into the stack
-      lua_getfield(L, -1, "parameters");
-      lua_pushvalue(L, -2);
-      int err = lua_pcall(L, 1, LUA_MULTRET, 0);
-      CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L, -1));
-      // iterate the parameters table to put tblobs inside
-      lua_pushnil(L);
-      auto i = 0;
-      while (lua_next(L, -3) && i < numParams) {
-        CAFFE_ENFORCE(luaT_isudata(L, -1, state_.tensorTy(*paramBlobs[i])));
-        auto* udata = luaT_toudata(L, -1, state_.tensorTy(*paramBlobs[i]));
-        state_.setTensor(
-            static_cast<typename torch::Torch<Context>::Traits::Tensor*>(udata),
-            const_cast<Blob*>(paramBlobs[i]));
-        i++;
-        lua_pop(L, 1);
-      }
-      CAFFE_ENFORCE_EQ(i, numParams);
-      // iterate the grad of params
-      lua_pushnil(L);
-      i = 0;
-      while (lua_next(L, -2) && i < numParams) {
-        CAFFE_ENFORCE(luaT_isudata(L, -1, state_.tensorTy(*gradParamBlobs[i])));
-        auto* udata = luaT_toudata(L, -1, state_.tensorTy(*gradParamBlobs[i]));
-        state_.setTensor(
-            static_cast<typename torch::Torch<Context>::Traits::Tensor*>(udata),
-            const_cast<Blob*>(gradParamBlobs[i]));
-        i++;
-        lua_pop(L, 1);
-      }
-      CAFFE_ENFORCE_EQ(i, numParams);
-      lua_pop(L, 2); // pop the parameters
-    }
-    lua_getfield(L, -1, "zeroGradParameters");
-    lua_pushvalue(L, -2);
-    CAFFE_ENFORCE_EQ(lua_pcall(L, 1, 0, 0), 0);
-    state_.pushTable(inputBlobs);
-    state_.pushTable(gradOutputBlobs);
-    // call
-    lua_getfield(L, -3, "accGradParameters");
-    lua_pushvalue(L, -4);
-    lua_pushvalue(L, -4);
-    lua_pushvalue(L, -4);
-    lua_pushnumber(L, 1);
-    int err = lua_pcall(L, 4, 0, 0); // doesn't need the output
-    CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L, -1));
-    lua_getfield(L, -3, "updateGradInput");
-    lua_pushvalue(L, -4);
-    lua_pushvalue(L, -4);
-    lua_pushvalue(L, -4);
-    err = lua_pcall(L, 3, 1, 0); // doesn't need the output
-    CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L, -1));
-    state_.verifyOutputs(gradInputBlobs, torchGradInputs);
-    lua_pop(L, 4);
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-    return true;
-  }
-};
-}
diff --git a/caffe2/contrib/torch/torch_op_gpu.cpp b/caffe2/contrib/torch/torch_op_gpu.cpp
deleted file mode 100644
index 5cfea19cba6f2..0000000000000
--- a/caffe2/contrib/torch/torch_op_gpu.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#include "caffe2/core/context_gpu.h"
-#include "torch_op.h"
-
-extern "C" {
-#include <THCStorage.h>
-#include <THCTensor.h>
-#include <THCStream.h>
-}
-
-namespace caffe2 {
-
-namespace torch {
-
-template <>
-struct TyTraits<CUDAContext> {
-  static const char* moduleTy;
-  static const char* prelude;
-  static const char* tensorTy;
-  using Tensor = THCudaTensor;
-};
-
-const char* TyTraits<CUDAContext>::tensorTy = "torch.CudaTensor";
-const char* TyTraits<CUDAContext>::moduleTy = "cuda";
-const char* TyTraits<CUDAContext>::prelude = R"(
-        require 'torch'
-        require 'nn'
-        require 'cunn'
-)";
-
-THCState* cudaState(Torch<CUDAContext>* t) {
-  auto* L = t->L();
-  lua_getglobal(L, "cutorch");
-  CAFFE_ENFORCE(!lua_isnil(L, -1));
-  lua_getfield(L, -1, "_state");
-  CAFFE_ENFORCE(!lua_isnil(L, -1));
-  THCState* state = reinterpret_cast<THCState*>(lua_touserdata(L, -1));
-  lua_pop(L, 2);
-  return state;
-}
-
-template <>
-void Torch<CUDAContext>::setContext(CUDAContext* context) {
-  THCState *state = cudaState(this);
-  THCStream* stream = THCState_getStream(state);
-  THCudaCheck(cudaStreamDestroy(stream->stream));
-  stream->stream = context->cuda_stream();
-}
-
-template <>
-void Torch<CUDAContext>::setTensor(typename Traits::Tensor* t, Blob* blob) {
-  CAFFE_ENFORCE_EQ(tensorTy(*blob), Traits::tensorTy);
-  auto* cs = cudaState(this);
-  auto* tc = blob->template GetMutable<Tensor<CUDAContext>>();
-  CAFFE_ENFORCE_EQ(THCudaTensor_nElement(cs, t), tc->size());
-  THCudaStorage* storage = THCudaStorage_newWithData(
-      cs, tc->template mutable_data<float>(), tc->size());
-  THCudaStorage_clearFlag(cs, storage, TH_STORAGE_FREEMEM);
-  THCudaStorage* original = t->storage;
-  t->storage = storage;
-  THCudaStorage_free(cs, original);
-}
-
-template <>
-typename Torch<CUDAContext>::Traits::Tensor* Torch<CUDAContext>::blobToTensor(
-    Blob* blob) {
-  CAFFE_ENFORCE_EQ(tensorTy(*blob), Traits::tensorTy);
-  auto* cs = cudaState(this);
-  auto* tc = blob->template GetMutable<Tensor<CUDAContext>>();
-
-  size_t size = tc->size();
-  THLongStorage* thshape = THLongStorage_newWithSize(tc->ndim());
-  for (int i = 0; i < tc->ndim(); ++i) {
-    THLongStorage_set(thshape, i, tc->dim(i));
-  }
-  THCudaStorage* storage =
-      THCudaStorage_newWithData(cs, tc->template mutable_data<float>(), size);
-  THCudaStorage_clearFlag(cs, storage, TH_STORAGE_FREEMEM);
-  auto* th = THCudaTensor_newWithStorage(cs, storage, 0, thshape, nullptr);
-  THCudaStorage_free(cs, storage);
-  THLongStorage_free(thshape);
-  CAFFE_ENFORCE_EQ(
-      THCudaTensor_storage(cs, th)->data, tc->template mutable_data<float>());
-  return th;
-}
-
-template <>
-std::vector<TIndex> Torch<CUDAContext>::tensorShape(
-    typename Traits::Tensor* t) {
-  auto* cs = cudaState(this);
-  auto* size = t->size;
-  return std::vector<TIndex>(size, size + THCudaTensor_nDimension(cs, t));
-}
-
-template <>
-typename Torch<CUDAContext>::Traits::Tensor* Torch<CUDAContext>::newTensorAs(
-    const Tensor<CUDAContext>& tc) {
-  auto* cs = cudaState(this);
-  THLongStorage* thshape = THLongStorage_newWithSize(tc.ndim());
-  for (uint32_t i = 0; i < tc.ndim(); ++i) {
-    THLongStorage_set(thshape, i, tc.dim(i));
-  }
-  THCudaTensor* d = THCudaTensor_newWithSize(cs, thshape, nullptr);
-  THLongStorage_free(thshape);
-  return d;
-}
-}
-
-REGISTER_CUDA_OPERATOR(Torch, TorchOp<CUDAContext>);
-REGISTER_CUDA_OPERATOR(TorchGradient, TorchGradientOp<CUDAContext>);
-}
diff --git a/caffe2/contrib/torch/torch_ops_test.py b/caffe2/contrib/torch/torch_ops_test.py
deleted file mode 100644
index dd9c080946469..0000000000000
--- a/caffe2/contrib/torch/torch_ops_test.py
+++ /dev/null
@@ -1,135 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-from caffe2.python import core, dyndep
-import caffe2.python.hypothesis_test_util as hu
-
-from hypothesis import given
-import hypothesis.strategies as st
-import numpy as np
-import os
-import unittest
-
-try:
-    from libfb.py import parutil
-except ImportError as e:
-    # If libfb not found, skip all tests in this file
-    raise unittest.SkipTest(str(e))
-
-core.GlobalInit(["python", "--caffe2_log_level=0"])
-
-dyndep.InitOpsLibrary('@/caffe2/caffe2/contrib/torch:torch_ops')
-
-RUNTIME = parutil.get_runtime_path()
-if 'LUA_PATH' not in os.environ:
-    os.environ['LUA_PATH'] = ";".join([
-        os.path.join(RUNTIME, '_lua', '?.lua'),
-        os.path.join(RUNTIME, '_lua', '?', 'init.lua'),
-    ])
-    os.environ['LUA_CPATH'] = os.path.join(RUNTIME, '_lua', '?.so')
-
-
-class TorchOpTest(hu.HypothesisTestCase):
-    @given(n=st.integers(min_value=1, max_value=10),
-           i=st.integers(min_value=1, max_value=10),
-           h=st.integers(min_value=2, max_value=10))
-    def test_feed(self, n, i, h):
-        op = core.CreateOperator(
-            "Torch", ["x", "W", "b"], ["y"],
-            init=b"nn.Linear({i}, {h})".format(h=h, i=i),
-            num_inputs=1,
-            num_params=2,
-            num_outputs=1
-        )
-        x = np.random.randn(n, i).astype(np.float32)
-        W = np.random.randn(h, i).astype(np.float32)
-        b = np.random.randn(h).astype(np.float32)
-        self.ws.create_blob("x").feed(x)
-        self.ws.create_blob("W").feed(W)
-        self.ws.create_blob("b").feed(b)
-        self.ws.run(op)
-        y = self.ws.blobs["y"].fetch()
-        print("y", y)
-        y = y.reshape((n, h))
-        np.testing.assert_allclose(y, np.dot(x, W.T) + b, atol=1e-4, rtol=1e-4)
-
-    @given(n=st.integers(min_value=1, max_value=10),
-           i=st.integers(min_value=1, max_value=10),
-           h=st.integers(min_value=2, max_value=10),
-           **hu.gcs)
-    def test_gradient(self, n, i, h, gc, dc):
-        op = core.CreateOperator(
-            "Torch", ["x", "W", "b"], ["y"],
-            init=b"nn.Linear({i}, {h})".format(h=h, i=i),
-            num_inputs=1,
-            num_params=2,
-            num_outputs=1
-        )
-        x = np.random.randn(n, i).astype(np.float32)
-        W = np.random.randn(h, i).astype(np.float32)
-        b = np.random.randn(h).astype(np.float32)
-        inputs = [x, W, b]
-        self.assertDeviceChecks(dc, op, inputs, [0])
-        for i, _ in enumerate(inputs):
-            self.assertGradientChecks(gc, op, inputs, i, [0])
-
-    @given(n=st.integers(min_value=1, max_value=10),
-           i=st.integers(min_value=1, max_value=10),
-           h=st.integers(min_value=2, max_value=10),
-           iters=st.integers(min_value=1, max_value=100))
-    def test_iterated(self, n, i, h, iters):
-        x = np.random.randn(n, i).astype(np.float32)
-        W = np.random.randn(h, i).astype(np.float32)
-        b = np.random.randn(h).astype(np.float32)
-        self.ws.create_blob("x").feed(x)
-        self.ws.create_blob("W").feed(W)
-        self.ws.create_blob("b").feed(b)
-        net = core.Net("op")
-        net.Torch(
-            ["x", "W", "b"], ["y"],
-            init=b"nn.Linear({i}, {h})".format(h=h, i=i),
-            num_inputs=1,
-            num_params=2,
-            num_outputs=1
-        )
-        print(net.Proto())
-        net_ = self.ws.create_net(net)
-        for i in range(iters):
-            if i % 1000 == 0:
-                print(i)
-            net_.run()
-
-        y = self.ws.blobs["y"].fetch()
-        y = y.reshape((n, h))
-        np.testing.assert_allclose(y, np.dot(x, W.T) + b, atol=1e-4, rtol=1e-4)
-
-    def test_leakage_torch(self):
-        n = 1
-        i = 100
-        h = 1000
-        iters = 2000
-        x = np.random.randn(n, i).astype(np.float32)
-        W = np.random.randn(h, i).astype(np.float32)
-        b = np.random.randn(h).astype(np.float32)
-        self.ws.create_blob("x").feed(x)
-        self.ws.create_blob("W").feed(W)
-        self.ws.create_blob("b").feed(b)
-        net = core.Net("op")
-        net.Torch(
-            ["x", "W", "b"], ["y"],
-            init=b"nn.Linear({i}, {h})".format(h=h, i=i),
-            num_inputs=1,
-            num_params=2,
-            num_outputs=1
-        )
-        net_ = self.ws.create_net(net)
-        for i in range(iters):
-            if i % 1000 == 0:
-                print(i)
-            net_.run()
-
-        y = self.ws.blobs["y"].fetch()
-        y = y.reshape((n, h))
-        np.testing.assert_allclose(y, np.dot(x, W.T) + b, atol=1e-4, rtol=1e-4)

From 50b6152da7d93fe730d75d632af316c83dc2e1ec Mon Sep 17 00:00:00 2001
From: Frank Jiang <ffjiang@fb.com>
Date: Tue, 12 Jun 2018 09:55:00 -0700
Subject: [PATCH 015/118] Fix linearWarmup multiplier check

The multiplier needs to be non-negative, not strictly positive.
---
 caffe2/sgd/learning_rate_op.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/caffe2/sgd/learning_rate_op.h b/caffe2/sgd/learning_rate_op.h
index 41b314239e987..0a47b6c5fd6d5 100644
--- a/caffe2/sgd/learning_rate_op.h
+++ b/caffe2/sgd/learning_rate_op.h
@@ -118,7 +118,7 @@ class LearningRateOp final : public Operator<Context> {
           arg_prefix + "start_multiplier", 0.);
       int num_iter = OperatorBase::template GetSingleArgument<int>(
           arg_prefix + "num_iter", 0);
-      DCHECK_GT(start_multiplier, 0);
+      DCHECK_GE(start_multiplier, 0);
       return new LinearWarmupLearningRate<T>(start_multiplier, num_iter);
     } else if (policy == "constantWarmup") {
       T multiplier = OperatorBase::template GetSingleArgument<float>(

From 67271b477e0b1e2a48f8630baa25e1b7eed513b6 Mon Sep 17 00:00:00 2001
From: Yangqing Jia <jiayq@fb.com>
Date: Tue, 12 Jun 2018 09:55:31 -0700
Subject: [PATCH 016/118] Revert D3314316

This is after 2 years and we do not seem to have a use case for this one, so
for the sake of clean API design we should potentially remove this. This would
allow us to potentially pass in arguments to optionally construct an object,
although it is indeed a little bit unclear how we can reuse existing objects if
constructor arguments are passed in. In any case, we may want to remove this
dangling feature.
---
 caffe2/python/onnx/tests/onnx_backend_test.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/caffe2/python/onnx/tests/onnx_backend_test.py b/caffe2/python/onnx/tests/onnx_backend_test.py
index b3c7493c96d33..4c9c3ea848fba 100644
--- a/caffe2/python/onnx/tests/onnx_backend_test.py
+++ b/caffe2/python/onnx/tests/onnx_backend_test.py
@@ -47,7 +47,8 @@
                      '|test_rnn_seq_length'
                      '|test_operator_add.*_cuda'
                      '|test_operator_lstm_cuda'
-                     '|test_operator_rnn.*_cuda)')
+                     '|test_operator_rnn.*_cuda'
+                     '|test_lrn_default_cuda)')
 
 # Temporarily skip some ONNX backend tests with broadcasting.
 backend_test.exclude('(test_xor_bcast'

From cf35a7ef8f4f0d95aac67bf68ad06980295caeeb Mon Sep 17 00:00:00 2001
From: Peizhao Zhang <stzpz@fb.com>
Date: Tue, 12 Jun 2018 09:56:05 -0700
Subject: [PATCH 017/118] Speedup generate proposals by partial_sort.

Speedup generate proposals by partial_sort.

FACEBOOK:
- Saw speed improvement for training with this op.
- Yanghan benchmarked the op on a small dataset and see consistent 100% improvement on speed (6ms -> 3ms) on 420 input resolution. See next diff for details.
---
 caffe2/operators/generate_proposals_op.cc | 52 +++++++++++++++--------
 1 file changed, 35 insertions(+), 17 deletions(-)

diff --git a/caffe2/operators/generate_proposals_op.cc b/caffe2/operators/generate_proposals_op.cc
index bb1f2f6bf2bdd..6caf0b19e48ff 100644
--- a/caffe2/operators/generate_proposals_op.cc
+++ b/caffe2/operators/generate_proposals_op.cc
@@ -103,7 +103,6 @@ void GenerateProposalsOp<CPUContext>::ProposalsForOneImage(
     const utils::ConstTensorView<float>& scores_tensor,
     ERArrXXf* out_boxes,
     EArrXf* out_probs) const {
-  const auto& pre_nms_topN = rpn_pre_nms_topN_;
   const auto& post_nms_topN = rpn_post_nms_topN_;
   const auto& nms_thresh = rpn_nms_thresh_;
   const auto& min_size = rpn_min_size_;
@@ -139,11 +138,39 @@ void GenerateProposalsOp<CPUContext>::ProposalsForOneImage(
   Eigen::Map<ERMatXf>(scores.data(), H * W, A) =
       Eigen::Map<const ERMatXf>(scores_tensor.data(), A, H * W).transpose();
 
+  std::vector<int> order(scores.size());
+  std::iota(order.begin(), order.end(), 0);
+  if (rpn_pre_nms_topN_ <= 0 || rpn_pre_nms_topN_ >= scores.size()) {
+    // 4. sort all (proposal, score) pairs by score from highest to lowest
+    // 5. take top pre_nms_topN (e.g. 6000)
+    std::sort(order.begin(), order.end(), [&scores](int lhs, int rhs) {
+      return scores[lhs] > scores[rhs];
+    });
+  } else {
+    // Avoid sorting possibly large arrays; First partition to get top K
+    // unsorted and then sort just those (~20x faster for 200k scores)
+    std::partial_sort(
+        order.begin(),
+        order.begin() + rpn_pre_nms_topN_,
+        order.end(),
+        [&scores](int lhs, int rhs) { return scores[lhs] > scores[rhs]; });
+    order.resize(rpn_pre_nms_topN_);
+  }
+
+  ERArrXXf bbox_deltas_sorted;
+  ERArrXXf all_anchors_sorted;
+  EArrXf scores_sorted;
+  utils::GetSubArrayRows(
+      bbox_deltas, utils::AsEArrXt(order), &bbox_deltas_sorted);
+  utils::GetSubArrayRows(
+      all_anchors.array(), utils::AsEArrXt(order), &all_anchors_sorted);
+  utils::GetSubArray(scores, utils::AsEArrXt(order), &scores_sorted);
+
   // Transform anchors into proposals via bbox transformations
   static const std::vector<float> bbox_weights{1.0, 1.0, 1.0, 1.0};
   auto proposals = utils::bbox_transform(
-      all_anchors.array(),
-      bbox_deltas,
+      all_anchors_sorted,
+      bbox_deltas_sorted,
       bbox_weights,
       utils::BBOX_XFORM_CLIP_DEFAULT,
       correct_transform_coords_);
@@ -154,30 +181,21 @@ void GenerateProposalsOp<CPUContext>::ProposalsForOneImage(
 
   // 3. remove predicted boxes with either height or width < min_size
   auto keep = utils::filter_boxes(proposals, min_size, im_info);
-  DCHECK_LE(keep.size(), scores.size());
-
-  // 4. sort all (proposal, score) pairs by score from highest to lowest
-  // 5. take top pre_nms_topN (e.g. 6000)
-  std::sort(keep.begin(), keep.end(), [&scores](int lhs, int rhs) {
-    return scores[lhs] > scores[rhs];
-  });
-
-  if (pre_nms_topN > 0 && pre_nms_topN < keep.size()) {
-    keep.resize(pre_nms_topN);
-  }
+  DCHECK_LE(keep.size(), scores_sorted.size());
 
   // 6. apply loose nms (e.g. threshold = 0.7)
   // 7. take after_nms_topN (e.g. 300)
   // 8. return the top proposals (-> RoIs top)
   if (post_nms_topN > 0 && post_nms_topN < keep.size()) {
-    keep = utils::nms_cpu(proposals, scores, keep, nms_thresh, post_nms_topN);
+    keep = utils::nms_cpu(
+        proposals, scores_sorted, keep, nms_thresh, post_nms_topN);
   } else {
-    keep = utils::nms_cpu(proposals, scores, keep, nms_thresh);
+    keep = utils::nms_cpu(proposals, scores_sorted, keep, nms_thresh);
   }
 
   // Generate outputs
   utils::GetSubArrayRows(proposals, utils::AsEArrXt(keep), out_boxes);
-  utils::GetSubArray(scores, utils::AsEArrXt(keep), out_probs);
+  utils::GetSubArray(scores_sorted, utils::AsEArrXt(keep), out_probs);
 }
 
 template <>

From be9e5a86ae5349e4a1c4806ab8a7ebe42ad85396 Mon Sep 17 00:00:00 2001
From: Peizhao Zhang <stzpz@fb.com>
Date: Tue, 12 Jun 2018 09:56:10 -0700
Subject: [PATCH 018/118] More parallel processing friendly for CPP version of
 GenerateProposals.

More parallel processing friendly for CPP version of GenerateProposals.
---
 caffe2/operators/generate_proposals_op.cc | 35 ++++++++++++++---------
 1 file changed, 21 insertions(+), 14 deletions(-)

diff --git a/caffe2/operators/generate_proposals_op.cc b/caffe2/operators/generate_proposals_op.cc
index 6caf0b19e48ff..49cb0315eb3f9 100644
--- a/caffe2/operators/generate_proposals_op.cc
+++ b/caffe2/operators/generate_proposals_op.cc
@@ -242,14 +242,15 @@ bool GenerateProposalsOp<CPUContext>::RunOnDevice() {
   out_rois->Resize(0, roi_col_count);
   out_rois_probs->Resize(0);
 
-  // Use openmp for acceleration?
+  std::vector<ERArrXXf> im_boxes(num_images);
+  std::vector<EArrXf> im_probs(num_images);
   for (int i = 0; i < num_images; i++) {
     auto cur_im_info = im_info.row(i);
     auto cur_bbox_deltas = GetSubTensorView<float>(bbox_deltas, i);
     auto cur_scores = GetSubTensorView<float>(scores, i);
 
-    ERArrXXf im_i_boxes;
-    EArrXf im_i_probs;
+    ERArrXXf& im_i_boxes = im_boxes[i];
+    EArrXf& im_i_probs = im_probs[i];
     ProposalsForOneImage(
         cur_im_info,
         all_anchors,
@@ -257,25 +258,31 @@ bool GenerateProposalsOp<CPUContext>::RunOnDevice() {
         cur_scores,
         &im_i_boxes,
         &im_i_probs);
+  }
 
+  int roi_counts = 0;
+  for (int i = 0; i < num_images; i++) {
+    roi_counts += im_boxes[i].rows();
+  }
+  out_rois->Extend(roi_counts, 50, &context_);
+  out_rois_probs->Extend(roi_counts, 50, &context_);
+  float* out_rois_ptr = out_rois->mutable_data<float>();
+  float* out_rois_probs_ptr = out_rois_probs->mutable_data<float>();
+  for (int i = 0; i < num_images; i++) {
+    const ERArrXXf& im_i_boxes = im_boxes[i];
+    const EArrXf& im_i_probs = im_probs[i];
     int csz = im_i_boxes.rows();
-    int cur_start_idx = out_rois->dim(0);
-
-    out_rois->Extend(csz, 50, &context_);
-    out_rois_probs->Extend(csz, 50, &context_);
 
     // write rois
-    Eigen::Map<ERArrXXf> cur_rois(
-        out_rois->mutable_data<float>() + cur_start_idx * roi_col_count,
-        csz,
-        5);
+    Eigen::Map<ERArrXXf> cur_rois(out_rois_ptr, csz, 5);
     cur_rois.col(0).setConstant(i);
     cur_rois.block(0, 1, csz, 4) = im_i_boxes;
 
     // write rois_probs
-    Eigen::Map<EArrXf>(
-        out_rois_probs->mutable_data<float>() + cur_start_idx, csz) =
-        im_i_probs;
+    Eigen::Map<EArrXf>(out_rois_probs_ptr, csz) = im_i_probs;
+
+    out_rois_ptr += csz * roi_col_count;
+    out_rois_probs_ptr += csz;
   }
 
   return true;

From 42083812a06d7fbe83f81cf13f516b1aadb479cd Mon Sep 17 00:00:00 2001
From: Qinqing Zheng <zqq@fb.com>
Date: Tue, 12 Jun 2018 09:56:31 -0700
Subject: [PATCH 019/118] [DT] [43/n] Lift stop conditions inside reader code
 back to flow control

1. Split multi_reader function into local_reader and remote_reader
2. Lifted stop conditions inside Limiter back to flow control
3. Split epoch flow building logic into 3 cases:
  - single machine (1 reader, 1 trainer on trainer0 node, no PS)
  - (1 reader + 1 trainer) on trainer0 node, has PS
  - multiple readers, readers do not share nodes with trainers, might have PS or not
---
 caffe2/ideep/operators/utility_ops.cc | 35 +++++++++++++--------------
 1 file changed, 17 insertions(+), 18 deletions(-)

diff --git a/caffe2/ideep/operators/utility_ops.cc b/caffe2/ideep/operators/utility_ops.cc
index ca6a1437825a8..9a2ec875d426b 100644
--- a/caffe2/ideep/operators/utility_ops.cc
+++ b/caffe2/ideep/operators/utility_ops.cc
@@ -6,29 +6,29 @@ namespace caffe2 {
 
 class CopyCPUToIDEEPOp final : public IDEEPOperator {
  public:
-   USE_SIMPLE_IDEEP_CTOR_DTOR(CopyCPUToIDEEPOp);
-   USE_IDEEP_DEF_ALIASES();
+  USE_SIMPLE_IDEEP_CTOR_DTOR(CopyCPUToIDEEPOp);
+  USE_IDEEP_DEF_ALIASES();
 
-   bool RunOnDevice() override {
-     const auto& X = OperatorBase::Input<TensorCPU>(0);
-     auto* Y = OperatorBase::OutputBlob(0);
-     itensor::dims src_dims(X.dims().begin(), X.dims().end());
-     if (!(Y->template IsType<itensor>() &&
-           Y->Get<itensor>().get_data_type() == itensor::data_type::f32) ||
-         Y->Get<itensor>().get_dims() != src_dims) {
-       Y->Reset(new itensor());
-       Y->GetMutable<itensor>()->resize(src_dims, itensor::data_type::f32);
-     }
-     Y->GetMutable<itensor>()->reorder_from(
-         src_dims, itensor::data_type::f32, X.raw_data());
-     return true;
+  bool RunOnDevice() override {
+    const auto& X = OperatorBase::Input<TensorCPU>(0);
+    auto* Y = OperatorBase::OutputBlob(0);
+    itensor::dims src_dims(X.dims().begin(), X.dims().end());
+    if (!(Y->template IsType<itensor>() &&
+          Y->Get<itensor>().get_data_type() == itensor::data_type::f32) ||
+        Y->Get<itensor>().get_dims() != src_dims) {
+      Y->Reset(new itensor());
+      Y->GetMutable<itensor>()->resize(src_dims, itensor::data_type::f32);
+    }
+    Y->GetMutable<itensor>()->reorder_from(
+        src_dims, itensor::data_type::f32, X.raw_data());
+    return true;
   }
 };
 
 class CopyIDEEPToCPUOp final : public IDEEPOperator {
  public:
-   USE_SIMPLE_IDEEP_CTOR_DTOR(CopyIDEEPToCPUOp);
-   USE_IDEEP_DEF_ALIASES();
+  USE_SIMPLE_IDEEP_CTOR_DTOR(CopyIDEEPToCPUOp);
+  USE_IDEEP_DEF_ALIASES();
   bool RunOnDevice() override {
     const auto& X = OperatorBase::Input<itensor>(0);
     auto* Y = OperatorBase::Output<TensorCPU>(0);
@@ -53,4 +53,3 @@ OPERATOR_SCHEMA(CopyIDEEPToCPU)
     .Output(0, "cpu_blob", "The output TensorCPU to copy to");
 
 } // namespace caffe2
-

From f5ab3fa86cd843d83420231315a9eba97d6ba854 Mon Sep 17 00:00:00 2001
From: Anders Papitto <andersj@fb.com>
Date: Tue, 12 Jun 2018 09:58:03 -0700
Subject: [PATCH 020/118] Resolve conflicts for torch/_thnn/utils.py

---
 tools/autograd/gen_python_functions.py |  7 +++++--
 tools/autograd/utils.py                |  8 +++++---
 tools/nnwrap/generate_wrappers.py      | 24 +++++++++++++++---------
 tools/setup_helpers/generate_code.py   | 15 +++++++++------
 torch/_thnn/utils.py                   |  7 +++++--
 5 files changed, 39 insertions(+), 22 deletions(-)

diff --git a/tools/autograd/gen_python_functions.py b/tools/autograd/gen_python_functions.py
index 3b4d4216a20dc..6729f3674dad9 100644
--- a/tools/autograd/gen_python_functions.py
+++ b/tools/autograd/gen_python_functions.py
@@ -6,12 +6,15 @@
 from collections import defaultdict
 import re
 from .nested_dict import nested_dict
-from tools.shared.module_loader import import_module
 from .gen_autograd import template_path
 from .gen_variable_type import should_trace
 from .utils import write
 
-CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
+try:
+    from src.ATen.code_template import CodeTemplate
+except ImportError:
+    from tools.shared.module_loader import import_module
+    CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
 
 # These functions require manual Python bindings or are not exposed to Python
 SKIP_PYTHON_BINDINGS = [
diff --git a/tools/autograd/utils.py b/tools/autograd/utils.py
index 608b7ea2d8c38..6758e71ffc97e 100644
--- a/tools/autograd/utils.py
+++ b/tools/autograd/utils.py
@@ -1,6 +1,5 @@
 import re
 import os
-from tools.shared.module_loader import import_module
 from .nested_dict import nested_dict
 
 
@@ -9,8 +8,11 @@
     'split_name_params', 'write',
 ]
 
-
-CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
+try:
+    from src.ATen.code_template import CodeTemplate
+except ImportError:
+    from tools.shared.module_loader import import_module
+    CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
 
 try:
     # use faster C loader if available
diff --git a/tools/nnwrap/generate_wrappers.py b/tools/nnwrap/generate_wrappers.py
index f496f1e0e999b..c08eb6eee1cd3 100644
--- a/tools/nnwrap/generate_wrappers.py
+++ b/tools/nnwrap/generate_wrappers.py
@@ -95,35 +95,41 @@ def wrap_function(name, type, arguments):
     return declaration
 
 
-def generate_wrappers(nn_root=None):
-    wrap_nn(os.path.join(nn_root, 'THNN', 'generic', 'THNN.h') if nn_root else None)
-    wrap_cunn(os.path.join(nn_root, 'THCUNN', 'generic', 'THCUNN.h') if nn_root else None)
+def generate_wrappers(nn_root=None, install_dir=None):
+    wrap_nn(os.path.join(nn_root, 'THNN', 'generic', 'THNN.h') if nn_root else None, install_dir)
+    wrap_cunn(os.path.join(nn_root, 'THCUNN', 'generic', 'THCUNN.h') if nn_root else None, install_dir)
 
 
-def wrap_nn(thnn_h_path):
+def wrap_nn(thnn_h_path, install_dir):
     wrapper = '#include <TH/TH.h>\n\n\n'
     nn_functions = thnn_utils.parse_header(thnn_h_path or thnn_utils.THNN_H_PATH)
     for fn in nn_functions:
         for t in ['Float', 'Double']:
             wrapper += wrap_function(fn.name, t, fn.arguments)
-    with open('torch/csrc/nn/THNN.cwrap', 'w') as f:
+    install_dir = install_dir or 'torch/csrc/nn'
+    try:
+        os.makedirs(install_dir)
+    except OSError:
+        pass
+    with open(os.path.join(install_dir, 'THNN.cwrap'), 'w') as f:
         f.write(wrapper)
-    cwrap('torch/csrc/nn/THNN.cwrap', plugins=[
+    cwrap(os.path.join(install_dir, 'THNN.cwrap'), plugins=[
         NNExtension('torch._C._THNN'),
         NullableArguments(),
     ])
 
 
-def wrap_cunn(thcunn_h_path=None):
+def wrap_cunn(thcunn_h_path, install_dir):
     wrapper = '#include <TH/TH.h>\n'
     wrapper += '#include <THC/THC.h>\n\n\n'
     cunn_functions = thnn_utils.parse_header(thcunn_h_path or thnn_utils.THCUNN_H_PATH)
     for fn in cunn_functions:
         for t in ['CudaHalf', 'Cuda', 'CudaDouble']:
             wrapper += wrap_function(fn.name, t, fn.arguments)
-    with open('torch/csrc/nn/THCUNN.cwrap', 'w') as f:
+    install_dir = install_dir or 'torch/csrc/nn'
+    with open(os.path.join(install_dir, 'THCUNN.cwrap'), 'w') as f:
         f.write(wrapper)
-    cwrap('torch/csrc/nn/THCUNN.cwrap', plugins=[
+    cwrap(os.path.join(install_dir, 'THCUNN.cwrap'), plugins=[
         NNExtension('torch._C._THCUNN'),
         NullableArguments(),
         AutoGPU(has_self=False),
diff --git a/tools/setup_helpers/generate_code.py b/tools/setup_helpers/generate_code.py
index 8065082a6aaac..de24ae805cbd4 100644
--- a/tools/setup_helpers/generate_code.py
+++ b/tools/setup_helpers/generate_code.py
@@ -65,7 +65,8 @@ def generate_code_ninja(w):
 
 def generate_code(ninja_global=None,
                   declarations_path=None,
-                  nn_path=None):
+                  nn_path=None,
+                  install_dir=None):
     # if ninja is enabled, we just register this file as something
     # ninja will need to call if needed
     if ninja_global is not None:
@@ -80,14 +81,14 @@ def generate_code(ninja_global=None,
 
     # Build THNN/THCUNN.cwrap and then THNN/THCUNN.cpp. These are primarily
     # used by the legacy NN bindings.
-    generate_nn_wrappers(nn_path)
+    generate_nn_wrappers(nn_path, install_dir)
 
     # Build ATen based Variable classes
-    autograd_gen_dir = 'torch/csrc/autograd/generated'
-    jit_gen_dir = 'torch/csrc/jit/generated'
+    autograd_gen_dir = install_dir or 'torch/csrc/autograd/generated'
+    jit_gen_dir = install_dir or 'torch/csrc/jit/generated'
     for d in (autograd_gen_dir, jit_gen_dir):
         if not os.path.exists(d):
-            os.mkdir(d)
+            os.makedirs(d)
     gen_autograd(declarations_path or DECLARATIONS_PATH, autograd_gen_dir)
     gen_jit_dispatch(declarations_path or DECLARATIONS_PATH, jit_gen_dir)
 
@@ -97,10 +98,12 @@ def main():
     parser.add_argument('--declarations-path')
     parser.add_argument('--nn-path')
     parser.add_argument('--ninja-global')
+    parser.add_argument('--install_dir')
     options = parser.parse_args()
     generate_code(options.ninja_global,
                   options.declarations_path,
-                  options.nn_path)
+                  options.nn_path,
+                  options.install_dir)
 
 
 if __name__ == "__main__":
diff --git a/torch/_thnn/utils.py b/torch/_thnn/utils.py
index ab164e02e6559..f32ae2a680f51 100644
--- a/torch/_thnn/utils.py
+++ b/torch/_thnn/utils.py
@@ -2,8 +2,11 @@
 import itertools
 import importlib
 
-THNN_H_PATH = os.path.join(os.path.dirname(__file__), '..', 'lib', 'THNN.h')
-THCUNN_H_PATH = os.path.join(os.path.dirname(__file__), '..', 'lib', 'THCUNN.h')
+try:
+    THNN_H_PATH = get_file_path('torch/lib/THNN.h')
+    THCUNN_H_PATH = get_file_path('torch/lib/THCUNN.h')
+except:
+    pass
 
 
 def _unpickle_backend(backend_name):

From b286a421204401796b63c3c41ca4c5a97155a3f1 Mon Sep 17 00:00:00 2001
From: Aleksandr Ulanov <avulanov@fb.com>
Date: Tue, 12 Jun 2018 09:59:45 -0700
Subject: [PATCH 021/118] [Caffe2] Handle image decoding errors

Image decoding errors can make the whole training fail. This diff is to handle them
1.Catch imdecode exceptions and check if decoded image has zero columns or rows. This is counted as decoding errors.
2.Replace the image with empty in case of error
3.Count the number of errors and throw runtime exception if the rate reaches given number

The empty image data is kept. It might introduce noise in the training data.
---
 caffe2/image/image_input_op.h | 86 ++++++++++++++++++++++++++---------
 1 file changed, 64 insertions(+), 22 deletions(-)

diff --git a/caffe2/image/image_input_op.h b/caffe2/image/image_input_op.h
index 0a4f09fc8b97e..bd9796e588f18 100644
--- a/caffe2/image/image_input_op.h
+++ b/caffe2/image/image_input_op.h
@@ -139,9 +139,13 @@ class ImageInputOp final
   vector<int> random_scale_;
   bool random_scaling_;
 
-
   // Working variables
   std::vector<std::mt19937> randgen_per_thread_;
+
+  // number of exceptions produced by opencv while reading image data
+  std::atomic<long> num_decode_errors_in_batch_{0};
+  // opencv exceptions tolerance
+  float max_decode_error_ratio_;
 };
 
 template <class Context>
@@ -197,8 +201,12 @@ ImageInputOp<Context>::ImageInputOp(
       // output type only supported with CUDA and use_gpu_transform for now
       output_type_(
           cast::GetCastDataType(ArgumentHelper(operator_def), "output_type")),
-      random_scale_(
-          OperatorBase::template GetRepeatedArgument<int>("random_scale", {-1,-1})) {
+      random_scale_(OperatorBase::template GetRepeatedArgument<int>(
+          "random_scale",
+          {-1, -1})),
+      max_decode_error_ratio_(OperatorBase::template GetSingleArgument<float>(
+          "max_decode_error_ratio",
+          0.0)) {
   if ((random_scale_[0] == -1) || (random_scale_[1] == -1)) {
     random_scaling_ = false;
   } else {
@@ -448,13 +456,23 @@ bool ImageInputOp<Context>::GetImageAndLabelAndInfoFromDBValue(
     prefetched_label_.mutable_data<int>()[item_id] = datum.label();
     if (datum.encoded()) {
       // encoded image in datum.
-      src = cv::imdecode(
-          cv::Mat(
-              1,
-              datum.data().size(),
-              CV_8UC1,
-              const_cast<char*>(datum.data().data())),
-          color_ ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);
+      // count the number of exceptions from opencv imdecode
+      try {
+        src = cv::imdecode(
+            cv::Mat(
+                1,
+                datum.data().size(),
+                CV_8UC1,
+                const_cast<char*>(datum.data().data())),
+            color_ ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);
+        if (src.rows == 0 or src.cols == 0) {
+          num_decode_errors_in_batch_++;
+          src = cv::Mat::zeros(cv::Size(224, 224), CV_8UC3);
+        }
+      } catch (cv::Exception& e) {
+        num_decode_errors_in_batch_++;
+        src = cv::Mat::zeros(cv::Size(224, 224), CV_8UC3);
+      }
     } else {
       // Raw image in datum.
       CAFFE_ENFORCE(datum.channels() == 3 || datum.channels() == 1);
@@ -487,6 +505,7 @@ bool ImageInputOp<Context>::GetImageAndLabelAndInfoFromDBValue(
     CAFFE_ENFORCE(protos.ParseFromString(value));
     const TensorProto& image_proto = protos.protos(0);
     const TensorProto& label_proto = protos.protos(1);
+    // add handle protos
     vector<TensorProto> additional_output_protos;
     int start = additional_inputs_offset_;
     int end = start + additional_inputs_count_;
@@ -512,13 +531,23 @@ bool ImageInputOp<Context>::GetImageAndLabelAndInfoFromDBValue(
       const string& encoded_image_str = image_proto.string_data(0);
       int encoded_size = encoded_image_str.size();
       // We use a cv::Mat to wrap the encoded str so we do not need a copy.
-      src = cv::imdecode(
-          cv::Mat(
-              1,
-              &encoded_size,
-              CV_8UC1,
-              const_cast<char*>(encoded_image_str.data())),
-          color_ ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);
+      // count the number of exceptions from opencv imdecode
+      try {
+        src = cv::imdecode(
+            cv::Mat(
+                1,
+                &encoded_size,
+                CV_8UC1,
+                const_cast<char*>(encoded_image_str.data())),
+            color_ ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);
+        if (src.rows == 0 or src.cols == 0) {
+          num_decode_errors_in_batch_++;
+          src = cv::Mat::zeros(cv::Size(224, 224), CV_8UC3);
+        }
+      } catch (cv::Exception& e) {
+        num_decode_errors_in_batch_++;
+        src = cv::Mat::zeros(cv::Size(224, 224), CV_8UC3);
+      }
     } else if (image_proto.data_type() == TensorProto::BYTE) {
       // raw image content.
       int src_c = (image_proto.dims_size() == 3) ? image_proto.dims(2) : 1;
@@ -536,6 +565,7 @@ bool ImageInputOp<Context>::GetImageAndLabelAndInfoFromDBValue(
       LOG(FATAL) << "Unknown image data type.";
     }
 
+    // TODO: if image decoding was unsuccessful, set label to 0
     if (label_proto.data_type() == TensorProto::FLOAT) {
       if (label_type_ == SINGLE_LABEL || label_type_ == SINGLE_LABEL_WEIGHTED) {
         DCHECK_EQ(label_proto.float_data_size(), 1);
@@ -728,6 +758,7 @@ bool ImageInputOp<Context>::GetImageAndLabelAndInfoFromDBValue(
         *img = scaled_img;
       }
   }
+
   // TODO(Yangqing): return false if any error happens.
   return true;
 }
@@ -1030,9 +1061,8 @@ void ImageInputOp<Context>::DecodeAndTransform(
   cv::Mat img;
   // Decode the image
   PerImageArg info;
-  CHECK(GetImageAndLabelAndInfoFromDBValue(value, &img, info, item_id,
-    randgen));
-
+  CHECK(
+      GetImageAndLabelAndInfoFromDBValue(value, &img, info, item_id, randgen));
   // Factor out the image transformation
   TransformImage<Context>(img, channels, image_data,
     color_jitter_, img_saturation_, img_brightness_, img_contrast_,
@@ -1054,8 +1084,8 @@ void ImageInputOp<Context>::DecodeAndTransposeOnly(
   cv::Mat img;
   // Decode the image
   PerImageArg info;
-  CHECK(GetImageAndLabelAndInfoFromDBValue(value, &img, info, item_id,
-    randgen));
+  CHECK(
+      GetImageAndLabelAndInfoFromDBValue(value, &img, info, item_id, randgen));
 
   // Factor out the image transformation
   CropTransposeImage<Context>(img, channels, image_data, crop_, mirror_,
@@ -1154,6 +1184,15 @@ bool ImageInputOp<Context>::Prefetch() {
   }
   thread_pool_->waitWorkComplete();
 
+  // we allow to get at most max_decode_error_ratio from
+  // opencv imdecode until raising a runtime exception
+  if ((float)num_decode_errors_in_batch_ / batch_size_ >
+      max_decode_error_ratio_) {
+    throw std::runtime_error(
+        "max_decode_error_ratio exceeded " +
+        caffe2::to_string(max_decode_error_ratio_));
+  }
+
   // If the context is not CPUContext, we will need to do a copy in the
   // prefetch function as well.
   if (!std::is_same<Context, CPUContext>::value) {
@@ -1165,6 +1204,9 @@ bool ImageInputOp<Context>::Prefetch() {
           prefetched_additional_outputs_[i], &context_);
     }
   }
+
+  num_decode_errors_in_batch_ = 0;
+
   return true;
 }
 

From 894387c84d911465839d04b31895fab43fa5bbd7 Mon Sep 17 00:00:00 2001
From: Viswanath Sivakumar <viswanath@fb.com>
Date: Tue, 12 Jun 2018 09:59:51 -0700
Subject: [PATCH 022/118] Update MKL exporter to IDEEP ops

TSIA
---
 caffe2/python/mkl/rewrite_graph.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/caffe2/python/mkl/rewrite_graph.py b/caffe2/python/mkl/rewrite_graph.py
index 60460f3d94627..c81383a3ea97a 100644
--- a/caffe2/python/mkl/rewrite_graph.py
+++ b/caffe2/python/mkl/rewrite_graph.py
@@ -69,7 +69,6 @@ def mkl_tmp(name):
         net.ParseFromString(
                 C.transform_optimizeForIDEEP(net.SerializeToString()))
 
-
 def rewrite_model_helper_simple(model, ideep=True):
     model = copy.deepcopy(model)
     # All parameter initialization should run on MKL

From 070a68460e18e05cb9f6b6fb552b13511782f03b Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 10:00:08 -0700
Subject: [PATCH 023/118] [Caffe2] GlobalInit is thread safe, fixing the
 comment

With the mutex and lock, GlobalInit is thread safe.
Update the comments.
---
 caffe2/core/init.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/caffe2/core/init.h b/caffe2/core/init.h
index 4ea7883fd90a1..db3e411c53ea8 100644
--- a/caffe2/core/init.h
+++ b/caffe2/core/init.h
@@ -125,7 +125,7 @@ class GlobalInitIsCalledGuard {
  * successive calls will parse flags and re-set caffe2 logging levels from
  * flags as needed, but NOT re-run early init and init functions.
  *
- * GlobalInit is *NOT* thread-safe and should not be called concurrently.
+ * GlobalInit is also thread-safe and can be called concurrently.
  */
 bool GlobalInit(int* pargc, char*** argv);
 

From 6a17efa728a47d6922a661e600e3f2cef9be6cd5 Mon Sep 17 00:00:00 2001
From: Anders Papitto <andersj@fb.com>
Date: Tue, 12 Jun 2018 10:00:11 -0700
Subject: [PATCH 024/118] Back out "Add support for generating ATen files
 during fbcode build"

Original commit changeset: 28970ddba353

@override-unit-failures
(Note: this ignores all push blocking failures!)
---
 aten/src/ATen/Declarations.yaml        | 32527 +++++++++++++++++++++++
 aten/src/ATen/gen.py                   |    16 +-
 tools/autograd/gen_python_functions.py |     7 +-
 tools/autograd/utils.py                |     8 +-
 tools/nnwrap/generate_wrappers.py      |    24 +-
 tools/setup_helpers/generate_code.py   |    15 +-
 torch/_thnn/utils.py                   |     7 +-
 7 files changed, 32555 insertions(+), 49 deletions(-)
 create mode 100644 aten/src/ATen/Declarations.yaml

diff --git a/aten/src/ATen/Declarations.yaml b/aten/src/ATen/Declarations.yaml
new file mode 100644
index 0000000000000..e865a8ab30c66
--- /dev/null
+++ b/aten/src/ATen/Declarations.yaml
@@ -0,0 +1,32527 @@
+- name: storage_offset
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: resize_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: numel
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: set_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Storage
+    name: storage
+    type: Storage &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: set_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Storage
+    name: sourceStorage
+    type: Storage &
+  - dynamic_type: int64_t
+    name: storage_offset
+    type: int64_t
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: IntList
+    name: stride
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: set_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: set_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: _fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: value
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: is_contiguous
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: is_set_to
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: masked_fill_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  - dynamic_type: real
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: masked_fill_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: value
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: masked_scatter_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: masked_select_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: masked_select
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nonzero_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nonzero
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: contiguous
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clone
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: view
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: resize_as_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: the_template
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_select_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_select
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _indexCopy_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: take_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: take
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: put_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: accumulate
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_add_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: real
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: value
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: unfold
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dimension
+    type: int64_t
+  - dynamic_type: int64_t
+    name: size
+    type: int64_t
+  - dynamic_type: int64_t
+    name: step
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: _range_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: accreal
+    name: start
+    type: Scalar
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _range
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: accreal
+    name: start
+    type: Scalar
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _arange_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: accreal
+    name: start
+    type: Scalar
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _arange
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: accreal
+    name: start
+    type: Scalar
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _arange_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _arange
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: scatter_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: src
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: scatter_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: real
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: scatter_add_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: src
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gather_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gather
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: data_ptr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: void*
+    name: result
+    type: void*
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: true
+- name: equal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __and___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __and__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __and___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __and__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __iand__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __iand__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __or___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __or__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __or___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __or__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ior__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ior__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __xor___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __xor__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __xor___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __xor__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ixor__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ixor__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __lshift___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __lshift__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __lshift___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __lshift__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ilshift__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ilshift__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __rshift___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __rshift__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __rshift___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __rshift__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __irshift__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __irshift__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: min
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: min_indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: min
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: min_indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: min
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: min_indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: max
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: max_indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: max
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: max_indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: max
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: max_indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kthvalue_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: k
+    type: int64_t
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kthvalue
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: k
+    type: int64_t
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mode_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mode
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: median_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: median
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: median
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sort_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: descending
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sort
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: descending
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: topk_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: k
+    type: int64_t
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: largest
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: sorted
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: topk
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: k
+    type: int64_t
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: largest
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: sorted
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: all_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: all
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: all
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: any_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: any
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: any
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: get_device
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _abs_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _abs
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sigmoid_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sigmoid_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sigmoid
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log10_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log10
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log1p_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log1p
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log2_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log2
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lgamma_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lgamma
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lgamma_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: digamma_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: digamma
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: digamma_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: polygamma_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: n
+    type: int64_t
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: polygamma
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: int64_t
+    name: n
+    type: int64_t
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: polygamma_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: n
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _exp_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _exp
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _expm1_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _expm1
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cos_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cos
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _acos_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _acos
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cosh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cosh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sin_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _asin_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _asin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sinh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sinh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tan_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tan
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _atan_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _atan
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_tanh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_tanh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _erf_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _erf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: erfinv_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: erfinv_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: erfinv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sqrt_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sqrt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _rsqrt_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _rsqrt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _ceil_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _ceil
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _floor_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _floor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _round_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _round
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _trunc_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _trunc
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: frac_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: frac_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: frac
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mean_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mean
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mean
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: var_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: var
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: var
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: std_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: std
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: std
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: norm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: p
+    python_default_init: 2
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: p
+    python_default_init: 2
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 2
+    default_init: 2
+    dynamic_type: real
+    name: p
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: renorm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: p
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: real
+    name: maxnorm
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: renorm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: p
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: real
+    name: maxnorm
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: renorm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: p
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: real
+    name: maxnorm
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: dist
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 2
+    default_init: 2
+    dynamic_type: real
+    name: p
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reciprocal_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reciprocal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reciprocal_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: neg_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: neg
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: neg_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan2_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan2
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan2_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: exponent
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: exponent
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: exponent
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: exponent
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: real
+    name: base
+    type: Scalar
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: real
+    name: base
+    type: Scalar
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: exponent
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: exponent
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lerp_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: end
+    type: const Tensor &
+  - dynamic_type: real
+    name: weight
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lerp
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: end
+    type: const Tensor &
+  - dynamic_type: real
+    name: weight
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lerp_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: end
+    type: const Tensor &
+  - dynamic_type: real
+    name: weight
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _linspace_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: real
+    name: start
+    type: Scalar
+  - dynamic_type: real
+    name: end
+    type: Scalar
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _linspace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: real
+    name: start
+    type: Scalar
+  - dynamic_type: real
+    name: end
+    type: Scalar
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _logspace_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: real
+    name: start
+    type: Scalar
+  - dynamic_type: real
+    name: end
+    type: Scalar
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _logspace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: real
+    name: start
+    type: Scalar
+  - dynamic_type: real
+    name: end
+    type: Scalar
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: histc_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: bins
+    type: int64_t
+  - default: 0
+    default_init: 0
+    dynamic_type: real
+    name: min
+    type: Scalar
+  - default: 0
+    default_init: 0
+    dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: histc
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: bins
+    type: int64_t
+  - default: 0
+    default_init: 0
+    dynamic_type: real
+    name: min
+    type: Scalar
+  - default: 0
+    default_init: 0
+    dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: zero_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sumall
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_sum_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _prodall
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_prod_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cumsum_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cumsum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cumprod_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cumprod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sign_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sign
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sign_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: trace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: other
+    type: SparseTensor
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: other
+    type: SparseTensor
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: SparseTensor
+    name: other
+    type: SparseTensor
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_min_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_min
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_min_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_max_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_max
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_max_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dot
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tril_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tril
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tril_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: triu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: triu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: triu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cross_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cross
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: diag_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: diag
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: mat1
+    type: SparseTensor
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: mat1
+    type: SparseTensor
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: SparseTensor
+    name: mat1
+    type: SparseTensor
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addmv_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addmv
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addmv_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addr_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addr
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addr_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _ger_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _ger
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _mv_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _mv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _mm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _mm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: bmm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: bmm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addbmm_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addbmm
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addbmm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: baddbmm_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: baddbmm
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: baddbmm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcmul_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcmul
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcmul_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcdiv_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcdiv
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcdiv_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _gesv_single_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: solution
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: lu
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: solution
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: lu
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _gesv_single
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: solution
+    type: Tensor
+  - dynamic_type: Tensor
+    name: lu
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gels_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gels
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: trtrs_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: transpose
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: unitriangular
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: trtrs
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: transpose
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: unitriangular
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: symeig_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: eigenvectors
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: symeig
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: eigenvectors
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eig_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: eigenvectors
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eig
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: eigenvectors
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: svd_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res3
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: some
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res3
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: svd
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: some
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res3
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: inverse_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: inverse
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potrf_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potrf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potrs_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potrs
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potri_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potri
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pstrf_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  - default: -1
+    default_init: -1
+    dynamic_type: real
+    name: tol
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pstrf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  - default: -1
+    default_init: -1
+    dynamic_type: real
+    name: tol
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: IntegerTensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: qr_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: qr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: geqrf_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: geqrf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: orgqr_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: orgqr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ormqr_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input3
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: left
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: transpose
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ormqr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input3
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: left
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: transpose
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrifact_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: pivots
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    kwarg_only: true
+    name: pivot
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: pivots
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrifact
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    kwarg_only: true
+    name: pivot
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  - dynamic_type: IntegerTensor
+    name: pivots
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrifact_with_info_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: pivots
+    output: true
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: info
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    kwarg_only: true
+    name: pivot
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: pivots
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: info
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrifact_with_info
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    kwarg_only: true
+    name: pivot
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  - dynamic_type: IntegerTensor
+    name: pivots
+    type: Tensor
+  - dynamic_type: IntegerTensor
+    name: info
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrisolve_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: LU_data
+    type: const Tensor &
+  - dynamic_type: IntegerTensor
+    name: LU_pivots
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrisolve
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: LU_data
+    type: const Tensor &
+  - dynamic_type: IntegerTensor
+    name: LU_pivots
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: random_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: from
+    type: int64_t
+  - dynamic_type: int64_t
+    name: to
+    type: int64_t
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: random_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: to
+    type: int64_t
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: random_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multinomial_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: num_samples
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: replacement
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multinomial
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: num_samples
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: replacement
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: uniform_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: double
+    name: from
+    type: double
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: to
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mean
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: std
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: mean
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: std
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: double
+    name: mean
+    type: double
+  - dynamic_type: Tensor
+    name: std
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: double
+    name: mean
+    type: double
+  - dynamic_type: Tensor
+    name: std
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: std
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: std
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: double
+    name: mean
+    type: double
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: std
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cauchy_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: double
+    name: median
+    type: double
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: sigma
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_normal_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: mean
+    type: double
+  - default: 2
+    default_init: 2
+    dynamic_type: double
+    name: std
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: exponential_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: lambd
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: geometric_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: double
+    name: p
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_bernoulli_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_bernoulli
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dirichlet_grad_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: x
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: alpha
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: total
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dirichlet_grad
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: x
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: alpha
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: total
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Storage
+    name: storage
+    type: Storage &
+  - dynamic_type: int64_t
+    name: storageOffset
+    type: int64_t
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: IntList
+    name: stride
+    type: IntList
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    type: IntList
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tensor
+  method_prefix_derived: ''
+  arguments: []
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sparse_coo_tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: values
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sparse_coo_tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: values
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: alias
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sparse_coo_tensor_unsafe
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: values
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _copy_ignoring_overlaps_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: src
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: as_strided_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    type: IntList
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: storage_offset
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: as_strided
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    type: IntList
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: storage_offset
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: as_strided_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    type: IntList
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: storage_offset
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sparse_raw_resize_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: int64_t
+    name: nDimI
+    type: int64_t
+  - dynamic_type: int64_t
+    name: nDimV
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cat_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    output: true
+    type: Tensor &
+  - dynamic_type: TensorList
+    name: tensors
+    type: TensorList
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cat
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: TensorList
+    name: tensors
+    type: TensorList
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sparse_mask
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: mask
+    type: SparseTensor
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: SparseTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: to_dense
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dimI
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dimV
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _nnz
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: coalesce
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: is_coalesced
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _indices
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _values
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hspmm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hspmm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: kl_div
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: p
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: p
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: p
+    type: Scalar
+  - dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: p
+    type: Scalar
+  - dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: p
+    type: Scalar
+  - dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: p
+    type: Scalar
+  - dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - is_target
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - is_target
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: is_target
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: is_target
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: is_target
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: is_target
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: is_target
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: -100
+    default_init: -100
+    dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - total_weight
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: -100
+    default_init: -100
+    dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - total_weight
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: total_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: total_weight
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: total_weight
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: total_weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: total_weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: -100
+    default_init: -100
+    dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - total_weight
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: -100
+    default_init: -100
+    dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - total_weight
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: total_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: total_weight
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: total_weight
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: total_weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: total_weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: elu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: elu_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: elu_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: glu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: glu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: glu_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: glu_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: glu_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: glu_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.5
+    default_init: 0.5
+    dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.5
+    default_init: 0.5
+    dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.01
+    default_init: 0.01
+    dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.01
+    default_init: 0.01
+    dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0.01
+    default_init: 0.01
+    dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - buffer
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - buffer
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: buffer
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: buffer
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: buffer
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: buffer
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: buffer
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prelu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prelu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prelu_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prelu_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prelu_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prelu_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: '{{true, true}}'
+    default_init: '{{true, true}}'
+    dynamic_type: std::array<bool,2>
+    name: output_mask
+    type: std::array<bool,2>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - default: 0.125
+    default_init: 0.125
+    dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    default_init: 0.3333333333333333
+    dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: training
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - default: 0.125
+    default_init: 0.125
+    dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    default_init: 0.3333333333333333
+    dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: training
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - default: 0.125
+    default_init: 0.125
+    dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    default_init: 0.3333333333333333
+    dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: training
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softplus_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - default: 20
+    default_init: 20
+    dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softplus
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - default: 20
+    default_init: 20
+    dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softplus_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softplus_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softplus_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softplus_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.5
+    default_init: 0.5
+    dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softshrink
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.5
+    default_init: 0.5
+    dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: threshold
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: threshold_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: threshold_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: random_samples
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: random_samples
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: random_samples
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: random_samples
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 4
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 4
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 5
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 5
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _tanh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: momentum
+    type: double
+  - dynamic_type: double
+    name: eps
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - save_mean
+  - save_std
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: momentum
+    type: double
+  - dynamic_type: double
+    name: eps
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - save_mean
+  - save_std
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: save_mean
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: save_std
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: momentum
+    type: double
+  - dynamic_type: double
+    name: eps
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: save_mean
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: save_std
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: momentum
+    type: double
+  - dynamic_type: double
+    name: eps
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: save_mean
+    type: Tensor
+  - dynamic_type: Tensor
+    name: save_std
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: eps
+    type: double
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_std
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: eps
+    type: double
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_std
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - default: '{{true, true}}'
+    default_init: '{{true, true}}'
+    dynamic_type: std::array<bool,2>
+    name: output_mask
+    type: std::array<bool,2>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cast_uint8_t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_int8_t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_double
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_float
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_int
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_int64_t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_int16_t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_Half
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cudnn_rnn_flatten_weight
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: weight_arr
+    type: TensorList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: weight_stride0
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: input_size
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: hidden_size
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_layers
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: batch_first
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: bidirectional
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cudnn_rnn
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: weight
+    type: TensorList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: weight_stride0
+    type: int64_t
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight_buf
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: hx
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: cx
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: hidden_size
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_layers
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: batch_first
+    type: bool
+  - dynamic_type: double
+    is_nullable: false
+    name: dropout
+    type: double
+  - dynamic_type: bool
+    is_nullable: false
+    name: train
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: bidirectional
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: batch_sizes
+    type: IntList
+  - dynamic_type: BoolTensor
+    is_nullable: true
+    name: dropout_state
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result3
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result4
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cudnn_rnn_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: weight
+    type: TensorList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: weight_stride0
+    type: int64_t
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight_buf
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: hx
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: cx
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_hy
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_cy
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: hidden_size
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_layers
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: batch_first
+    type: bool
+  - dynamic_type: double
+    is_nullable: false
+    name: dropout
+    type: double
+  - dynamic_type: bool
+    is_nullable: false
+    name: train
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: bidirectional
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: batch_sizes
+    type: IntList
+  - dynamic_type: BoolTensor
+    is_nullable: true
+    name: dropout_state
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: reserve
+    type: const Tensor &
+  - dynamic_type: std::array<bool,4>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,4>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  - dynamic_type: TensorList
+    name: result3
+    type: std::vector<Tensor>
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cudnn_init_dropout_state
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: self_ty
+    type: const Type &
+  - dynamic_type: double
+    is_nullable: false
+    name: dropout
+    type: double
+  - dynamic_type: bool
+    is_nullable: false
+    name: train
+    type: bool
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dropout_seed
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: abs
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: abs_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: abs_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: acos
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: acos_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: acos_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_size
+    size: 1
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_size
+    size: 1
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: allclose
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  - default: 1.0e-05
+    dynamic_type: double
+    is_nullable: false
+    name: rtol
+    type: double
+  - default: 1.0e-08
+    dynamic_type: double
+    is_nullable: false
+    name: atol
+    type: double
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: equal_nan
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addmv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addmv_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addmv_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addr_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addr_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: arange
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: arange_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: arange
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: arange_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: argmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: argmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _argmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: argmin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: argmin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _argmin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: asin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: asin_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: asin_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: atan_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: batch_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    is_nullable: false
+    name: training
+    type: bool
+  - dynamic_type: double
+    is_nullable: false
+    name: momentum
+    type: double
+  - dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enabled
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: p
+    type: const Tensor &
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: double
+    is_nullable: false
+    name: p
+    type: double
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: p
+    type: const Tensor &
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: double
+    is_nullable: false
+    name: p
+    type: double
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bilinear
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cat
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cat_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ceil
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ceil_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ceil_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: chunk
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: chunks
+    type: int64_t
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: TensorList
+    name: result
+    type: std::vector<Tensor>
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_is_acceptable
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: convolution
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: transposed
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _convolution
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: transposed
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enabled
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _convolution_nogroup
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: transposed
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _convolution_double_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: ggI
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: ggW
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: ggb
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: gO
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: transposed
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enabled
+    type: bool
+  - dynamic_type: std::array<bool,3>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 1
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 1
+    type: IntList
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 1
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 2
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 2
+    type: IntList
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 2
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 3
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 3
+    type: IntList
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 3
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_tbc
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pad
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_tbc_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pad
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_transpose1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 1
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 1
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    size: 1
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 1
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_transpose2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 2
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 2
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    size: 2
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_transpose3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 3
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 3
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    size: 3
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cos
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cos_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cos_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cosh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cosh_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cosh_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cosine_embedding_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: target
+    type: const Tensor &
+  - default: 0.0
+    dynamic_type: double
+    is_nullable: false
+    name: margin
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: size_average
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_affine_grid_generator
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: theta
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: N
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: C
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: H
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: W
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: grid
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_affine_grid_generator_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: N
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: C
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: H
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: W
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: grad_theta
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_batch_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    is_nullable: false
+    name: training
+    type: bool
+  - dynamic_type: double
+    is_nullable: false
+    name: exponential_average_factor
+    type: double
+  - dynamic_type: double
+    is_nullable: false
+    name: epsilon
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_batch_norm_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_var
+    type: const Tensor &
+  - dynamic_type: double
+    is_nullable: false
+    name: epsilon
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_backward_input
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: self_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  - dynamic_type: std::array<bool,3>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_backward_bias
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_backward_weight
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: weight_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  - dynamic_type: std::array<bool,3>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose_backward_bias
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose_backward_input
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose_backward_weight
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: weight_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_grid_sampler
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grid
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_grid_sampler_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grid
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: grad_self
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_grid
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cumsum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumsum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumsum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumsum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumprod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumprod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumprod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumprod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: det
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: diagflat
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: offset
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: diagonal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: offset
+    type: int64_t
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim1
+    type: int64_t
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim2
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: dot
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: tensor
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: dot_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: tensor
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: einsum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: std::string
+    is_nullable: false
+    name: equation
+    type: std::string
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - default: -1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: padding_idx
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: sparse
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: padding_idx
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: sparse
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_dense_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: padding_idx
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: embedding_renorm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: double
+    is_nullable: false
+    name: max_norm
+    type: double
+  - dynamic_type: double
+    is_nullable: false
+    name: norm_type
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: embedding_sparse_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: padding_idx
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_bag
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offsets
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: sparse
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result3
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: embedding_bag_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offsets
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offset2bag
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: bag_size
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: maximum_indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: sparse
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_bag_sparse_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offsets
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offset2bag
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: bag_size
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_bag_dense_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offsets
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offset2bag
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: bag_size
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: maximum_indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: empty
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: empty_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: empty_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: empty_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: erf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: erf_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: erf_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: exp
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: exp_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: exp_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: expm1
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: expm1_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: expm1_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: expand
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    kwarg_only: true
+    name: implicit
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: expand_as
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: eye
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: n
+    type: int64_t
+  - default: -1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: m
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: eye_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: n
+    type: int64_t
+  - default: -1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: m
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: value
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: floor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: floor_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: floor_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: full
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: fill_value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: full_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: fill_value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: full_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: fill_value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: full_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: fill_value
+    type: Scalar
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hinge_embedding_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: target
+    type: const Tensor &
+  - default: 1.0
+    dynamic_type: double
+    is_nullable: false
+    name: margin
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: size_average
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ger
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ger_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: gesv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: gesv_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: solution
+    output: true
+    type: Tensor &
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: lu
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _gesv_helper
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: group_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_groups
+    type: int64_t
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - default: 1.0e-05
+    dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enabled
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: fft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ifft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rfft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: onesided
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: irfft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: onesided
+    type: bool
+  - default: '{}'
+    dynamic_type: IntList
+    is_nullable: false
+    name: signal_sizes
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _fft_with_size
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: complex_input
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: complex_output
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: inverse
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: checked_signal_sizes
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: onesided
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_sizes
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: indices
+    type: TensorList
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: index_copy_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: index_put_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: indices
+    type: TensorList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: values
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: isclose
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  - default: 1.0e-05
+    dynamic_type: double
+    is_nullable: false
+    name: rtol
+    type: double
+  - default: 1.0e-08
+    dynamic_type: double
+    is_nullable: false
+    name: atol
+    type: double
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: equal_nan
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_cuda
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_distributed
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_floating_point
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_nonzero
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_same_size
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_signed
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_sparse
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: layer_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: normalized_shape
+    type: IntList
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - default: 1.0e-05
+    dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enable
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: linspace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 100
+    dynamic_type: int64_t
+    is_nullable: false
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: linspace_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 100
+    dynamic_type: int64_t
+    is_nullable: false
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log10
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log10_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log10_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log1p
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log1p_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log1p_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log2
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log2_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log2_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: logdet
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: logspace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 100
+    dynamic_type: int64_t
+    is_nullable: false
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: logspace_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 100
+    dynamic_type: int64_t
+    is_nullable: false
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log_softmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_softmax_backward_data
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: output
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: logsumexp
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: logsumexp_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: margin_ranking_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: target
+    type: const Tensor &
+  - default: 0.0
+    dynamic_type: double
+    is_nullable: false
+    name: margin
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: size_average
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: matmul
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: matmul_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_values
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: kernel_size
+    size: 1
+    type: IntList
+  - default: '{}'
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 1
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 1
+    type: IntList
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: min_values
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mkldnn_convolution
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mkldnn_convolution_backward_input
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: self_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: bias_defined
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mkldnn_convolution_backward_weights
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: weight_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: bias_defined
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mkldnn_convolution_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: std::array<bool,3>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mm_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mv_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: narrow
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: start
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: length
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ones
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ones_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ones_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ones_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: pairwise_distance
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: x1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: x2
+    type: const Tensor &
+  - default: 2
+    dynamic_type: double
+    is_nullable: false
+    name: p
+    type: double
+  - default: 1.0e-06
+    dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: permute
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dims
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: pin_memory
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rand
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rand_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rand_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rand_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: low
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: low
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: low
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: low
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randn
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randn_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randn_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randn_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randperm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: n
+    type: int64_t
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randperm_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: n
+    type: int64_t
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: range
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: range_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: repeat
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: repeats
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reshape
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: shape
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: RoiPooling2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: rois
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pooledHeight
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pooledWidth
+    type: int64_t
+  - dynamic_type: double
+    is_nullable: false
+    name: spatialScale
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: RoiPooling2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: rois
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pooledHeight
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pooledWidth
+    type: int64_t
+  - dynamic_type: double
+    is_nullable: false
+    name: spatialScale
+    type: double
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: gradOutput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: argmaxes
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: round
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: round_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: round_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: 0.125
+    dynamic_type: Scalar
+    is_nullable: false
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    dynamic_type: Scalar
+    is_nullable: false
+    name: upper
+    type: Scalar
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: training
+    type: bool
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - default: 0.125
+    dynamic_type: Scalar
+    is_nullable: false
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    dynamic_type: Scalar
+    is_nullable: false
+    name: upper
+    type: Scalar
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: training
+    type: bool
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: relu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: relu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rsqrt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rsqrt_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rsqrt_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: select
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: index
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: selu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: selu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sin_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sin_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sinh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sinh_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sinh_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: size
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: slice
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: start
+    type: int64_t
+  - default: 9223372036854775807
+    dynamic_type: int64_t
+    is_nullable: false
+    name: end
+    type: int64_t
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: step
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: slogdet
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: smm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softmax_backward_data
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: output
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: split
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: split_size
+    type: int64_t
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: TensorList
+    name: result
+    type: std::vector<Tensor>
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: split_with_sizes
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: split_sizes
+    type: IntList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: TensorList
+    name: result
+    type: std::vector<Tensor>
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: squeeze
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: squeeze
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: squeeze_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: squeeze_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sspaddmm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sspaddmm_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: stack
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: stack_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: stft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: frame_length
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: hop
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: fft_size
+    python_default_init: frame_length
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: onesided
+    type: bool
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: window
+    type: const Tensor &
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: pad_end
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: stride
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sum_cuda_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sqrt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sqrt_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sqrt_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _prod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: t_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: tan
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: tan_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tan_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tanh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: tanh_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tanh_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: transpose
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim0
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim1
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: transpose_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim0
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim1
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _trilinear
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: i1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: i2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: i3
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: expand1
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: expand2
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: expand3
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: sumdim
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: unroll_dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: triplet_margin_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: anchor
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: positive
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: negative
+    type: const Tensor &
+  - default: 1.0
+    dynamic_type: double
+    is_nullable: false
+    name: margin
+    type: double
+  - default: 2
+    dynamic_type: double
+    is_nullable: false
+    name: p
+    type: double
+  - default: 1.0e-06
+    dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: swap
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: size_average
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: trunc
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: trunc_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: trunc_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: type_as
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _unique
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: sorted
+    type: bool
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: return_inverse
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _unsafe_view
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: unsqueeze
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: unsqueeze_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: view_as
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: where
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    is_nullable: false
+    name: condition
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _s_where
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    is_nullable: false
+    name: condition
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: zeros
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: zeros_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: zeros_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: zeros_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _standard_gamma_grad
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _standard_gamma
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: poisson
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
diff --git a/aten/src/ATen/gen.py b/aten/src/ATen/gen.py
index 84de0bc10e6b0..c1be0c0563408 100644
--- a/aten/src/ATen/gen.py
+++ b/aten/src/ATen/gen.py
@@ -4,10 +4,6 @@
 import yaml
 from collections import OrderedDict
 
-import sys
-from os import path
-sys.path.append(path.dirname(path.abspath(__file__)))
-
 import cwrap_parser
 import nn_parse
 import native_parse
@@ -27,7 +23,6 @@
 
 parser = argparse.ArgumentParser(description='Generate ATen source files')
 parser.add_argument('files', help='cwrap files', nargs='+')
-
 parser.add_argument(
     '-s',
     '--source-path',
@@ -38,11 +33,12 @@
     '--output-dependencies',
     help='output a list of dependencies into the given file and exit')
 parser.add_argument(
-    '-d', '--install_dir', help='output directory', default='ATen')
+    '-d', '--output-dir', help='output directory', default='ATen')
 options = parser.parse_args()
 
-if options.install_dir is not None and not os.path.exists(options.install_dir):
-    os.makedirs(options.install_dir)
+
+if options.output_dir is not None and not os.path.exists(options.output_dir):
+    os.makedirs(options.output_dir)
 
 
 class FileManager(object):
@@ -52,7 +48,7 @@ def __init__(self):
         self.undeclared_files = []
 
     def will_write(self, filename):
-        filename = '{}/{}'.format(options.install_dir, filename)
+        filename = '{}/{}'.format(options.output_dir, filename)
         if self.outputs_written:
             raise Exception("'will_write' can only be called before " +
                             "the call to write_outputs, refactor so outputs are registered " +
@@ -78,7 +74,7 @@ def write_outputs(self, filename):
         self.outputs_written = True
 
     def write(self, filename, s, env=None):
-        filename = '{}/{}'.format(options.install_dir, filename)
+        filename = '{}/{}'.format(options.output_dir, filename)
         if isinstance(s, CodeTemplate):
             assert env is not None
             env['generated_comment'] = "@" + "generated by aten/src/ATen/gen.py"
diff --git a/tools/autograd/gen_python_functions.py b/tools/autograd/gen_python_functions.py
index 6729f3674dad9..3b4d4216a20dc 100644
--- a/tools/autograd/gen_python_functions.py
+++ b/tools/autograd/gen_python_functions.py
@@ -6,15 +6,12 @@
 from collections import defaultdict
 import re
 from .nested_dict import nested_dict
+from tools.shared.module_loader import import_module
 from .gen_autograd import template_path
 from .gen_variable_type import should_trace
 from .utils import write
 
-try:
-    from src.ATen.code_template import CodeTemplate
-except ImportError:
-    from tools.shared.module_loader import import_module
-    CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
+CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
 
 # These functions require manual Python bindings or are not exposed to Python
 SKIP_PYTHON_BINDINGS = [
diff --git a/tools/autograd/utils.py b/tools/autograd/utils.py
index 6758e71ffc97e..608b7ea2d8c38 100644
--- a/tools/autograd/utils.py
+++ b/tools/autograd/utils.py
@@ -1,5 +1,6 @@
 import re
 import os
+from tools.shared.module_loader import import_module
 from .nested_dict import nested_dict
 
 
@@ -8,11 +9,8 @@
     'split_name_params', 'write',
 ]
 
-try:
-    from src.ATen.code_template import CodeTemplate
-except ImportError:
-    from tools.shared.module_loader import import_module
-    CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
+
+CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
 
 try:
     # use faster C loader if available
diff --git a/tools/nnwrap/generate_wrappers.py b/tools/nnwrap/generate_wrappers.py
index c08eb6eee1cd3..f496f1e0e999b 100644
--- a/tools/nnwrap/generate_wrappers.py
+++ b/tools/nnwrap/generate_wrappers.py
@@ -95,41 +95,35 @@ def wrap_function(name, type, arguments):
     return declaration
 
 
-def generate_wrappers(nn_root=None, install_dir=None):
-    wrap_nn(os.path.join(nn_root, 'THNN', 'generic', 'THNN.h') if nn_root else None, install_dir)
-    wrap_cunn(os.path.join(nn_root, 'THCUNN', 'generic', 'THCUNN.h') if nn_root else None, install_dir)
+def generate_wrappers(nn_root=None):
+    wrap_nn(os.path.join(nn_root, 'THNN', 'generic', 'THNN.h') if nn_root else None)
+    wrap_cunn(os.path.join(nn_root, 'THCUNN', 'generic', 'THCUNN.h') if nn_root else None)
 
 
-def wrap_nn(thnn_h_path, install_dir):
+def wrap_nn(thnn_h_path):
     wrapper = '#include <TH/TH.h>\n\n\n'
     nn_functions = thnn_utils.parse_header(thnn_h_path or thnn_utils.THNN_H_PATH)
     for fn in nn_functions:
         for t in ['Float', 'Double']:
             wrapper += wrap_function(fn.name, t, fn.arguments)
-    install_dir = install_dir or 'torch/csrc/nn'
-    try:
-        os.makedirs(install_dir)
-    except OSError:
-        pass
-    with open(os.path.join(install_dir, 'THNN.cwrap'), 'w') as f:
+    with open('torch/csrc/nn/THNN.cwrap', 'w') as f:
         f.write(wrapper)
-    cwrap(os.path.join(install_dir, 'THNN.cwrap'), plugins=[
+    cwrap('torch/csrc/nn/THNN.cwrap', plugins=[
         NNExtension('torch._C._THNN'),
         NullableArguments(),
     ])
 
 
-def wrap_cunn(thcunn_h_path, install_dir):
+def wrap_cunn(thcunn_h_path=None):
     wrapper = '#include <TH/TH.h>\n'
     wrapper += '#include <THC/THC.h>\n\n\n'
     cunn_functions = thnn_utils.parse_header(thcunn_h_path or thnn_utils.THCUNN_H_PATH)
     for fn in cunn_functions:
         for t in ['CudaHalf', 'Cuda', 'CudaDouble']:
             wrapper += wrap_function(fn.name, t, fn.arguments)
-    install_dir = install_dir or 'torch/csrc/nn'
-    with open(os.path.join(install_dir, 'THCUNN.cwrap'), 'w') as f:
+    with open('torch/csrc/nn/THCUNN.cwrap', 'w') as f:
         f.write(wrapper)
-    cwrap(os.path.join(install_dir, 'THCUNN.cwrap'), plugins=[
+    cwrap('torch/csrc/nn/THCUNN.cwrap', plugins=[
         NNExtension('torch._C._THCUNN'),
         NullableArguments(),
         AutoGPU(has_self=False),
diff --git a/tools/setup_helpers/generate_code.py b/tools/setup_helpers/generate_code.py
index de24ae805cbd4..8065082a6aaac 100644
--- a/tools/setup_helpers/generate_code.py
+++ b/tools/setup_helpers/generate_code.py
@@ -65,8 +65,7 @@ def generate_code_ninja(w):
 
 def generate_code(ninja_global=None,
                   declarations_path=None,
-                  nn_path=None,
-                  install_dir=None):
+                  nn_path=None):
     # if ninja is enabled, we just register this file as something
     # ninja will need to call if needed
     if ninja_global is not None:
@@ -81,14 +80,14 @@ def generate_code(ninja_global=None,
 
     # Build THNN/THCUNN.cwrap and then THNN/THCUNN.cpp. These are primarily
     # used by the legacy NN bindings.
-    generate_nn_wrappers(nn_path, install_dir)
+    generate_nn_wrappers(nn_path)
 
     # Build ATen based Variable classes
-    autograd_gen_dir = install_dir or 'torch/csrc/autograd/generated'
-    jit_gen_dir = install_dir or 'torch/csrc/jit/generated'
+    autograd_gen_dir = 'torch/csrc/autograd/generated'
+    jit_gen_dir = 'torch/csrc/jit/generated'
     for d in (autograd_gen_dir, jit_gen_dir):
         if not os.path.exists(d):
-            os.makedirs(d)
+            os.mkdir(d)
     gen_autograd(declarations_path or DECLARATIONS_PATH, autograd_gen_dir)
     gen_jit_dispatch(declarations_path or DECLARATIONS_PATH, jit_gen_dir)
 
@@ -98,12 +97,10 @@ def main():
     parser.add_argument('--declarations-path')
     parser.add_argument('--nn-path')
     parser.add_argument('--ninja-global')
-    parser.add_argument('--install_dir')
     options = parser.parse_args()
     generate_code(options.ninja_global,
                   options.declarations_path,
-                  options.nn_path,
-                  options.install_dir)
+                  options.nn_path)
 
 
 if __name__ == "__main__":
diff --git a/torch/_thnn/utils.py b/torch/_thnn/utils.py
index f32ae2a680f51..6433ebdd1f26f 100644
--- a/torch/_thnn/utils.py
+++ b/torch/_thnn/utils.py
@@ -2,11 +2,8 @@
 import itertools
 import importlib
 
-try:
-    THNN_H_PATH = get_file_path('torch/lib/THNN.h')
-    THCUNN_H_PATH = get_file_path('torch/lib/THCUNN.h')
-except:
-    pass
+THNN_H_PATH = get_file_path('torch/lib/THNN.h')
+THCUNN_H_PATH = get_file_path('torch/lib/THCUNN.h')
 
 
 def _unpickle_backend(backend_name):

From 2977db0757e30eea88cffd1e914db5b683c25c5e Mon Sep 17 00:00:00 2001
From: Xiaolong Wang <xlwang@fb.com>
Date: Tue, 12 Jun 2018 10:00:18 -0700
Subject: [PATCH 025/118] [DT]: fix predictor save

similar to D6610058, here we add the fix for distributed online training
---
 caffe2/python/predictor/predictor_py_utils.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/caffe2/python/predictor/predictor_py_utils.py b/caffe2/python/predictor/predictor_py_utils.py
index ce7cfaebafd73..22d044472b838 100644
--- a/caffe2/python/predictor/predictor_py_utils.py
+++ b/caffe2/python/predictor/predictor_py_utils.py
@@ -97,6 +97,16 @@ def GetBlobs(meta_net_def, key):
     return blobs
 
 
+def GetBlobsByTypePrefix(meta_net_def, blob_type_prefix):
+    blob_map = {}
+    for b in meta_net_def.blobs:
+        if b.key.startswith(blob_type_prefix):
+            for blob in b.value:
+                if blob not in blob_map:
+                    blob_map[blob] = len(blob_map)
+    return sorted(blob_map, key=lambda blob: blob_map[blob])
+
+
 def GetNet(meta_net_def, key):
     return _ProtoMapGet(meta_net_def.nets, key)
 

From 8ae0cdb362c1df12a1a877885c71b7e669c88e55 Mon Sep 17 00:00:00 2001
From: Yangqing Jia <jiayq@fb.com>
Date: Tue, 12 Jun 2018 10:00:26 -0700
Subject: [PATCH 026/118] Remove net_singlethread_async_gpu.cc

Closes https://github.com/caffe2/caffe2/pull/2528

This removes net_singlethread_async_gpu.cc as part of our effort to clean
CUDAContext and the net executors.
---
 caffe2/core/net_singlethread_async_gpu.cc | 218 ----------------------
 1 file changed, 218 deletions(-)
 delete mode 100644 caffe2/core/net_singlethread_async_gpu.cc

diff --git a/caffe2/core/net_singlethread_async_gpu.cc b/caffe2/core/net_singlethread_async_gpu.cc
deleted file mode 100644
index 0eba1bdc26bed..0000000000000
--- a/caffe2/core/net_singlethread_async_gpu.cc
+++ /dev/null
@@ -1,218 +0,0 @@
-#include <condition_variable>
-#include <mutex>
-#include <stack>
-
-#if !defined(_MSC_VER) && !defined(__APPLE__)
-#include <sched.h>
-#endif
-
-#include "caffe2/core/context_gpu.h"
-#include "caffe2/core/net_simple.h"
-#include "caffe2/core/operator.h"
-#include "caffe2/proto/caffe2.pb.h"
-
-namespace caffe2 {
-
-namespace gpu_single_thread {
-
-struct Task {
-  std::vector<std::unique_ptr<OperatorBase>>* ops_;
-  std::condition_variable* cv_;
-  std::mutex* mtx_;
-  int stream_id_;
-  bool done_ = false;
-};
-
-class GPUExecutor {
- public:
-  explicit GPUExecutor(int gpu_id) : gpu_id_(gpu_id) {}
-
-  ~GPUExecutor() {
-    queue_.NoMoreJobs();
-    thread_.join();
-  }
-
-  void RunJob(Task* task) {
-    queue_.Push(task);
-  }
-
-  void start() {
-    thread_ = std::thread(&GPUExecutor::WorkerFunction, this);
-  }
-
-  static std::shared_ptr<GPUExecutor> Get(int gpu);
-  static void Release(int gpu);
-
- private:
-  void set_affinity();
-  void WorkerFunction();
-
-  std::thread thread_;
-  int gpu_id_;
-  SimpleQueue<Task*> queue_;
-  static std::shared_ptr<GPUExecutor> executors_[CAFFE2_COMPILE_TIME_MAX_GPUS];
-  static std::mutex gpu_mtx_[CAFFE2_COMPILE_TIME_MAX_GPUS];
-};
-
-std::shared_ptr<GPUExecutor>
-    GPUExecutor::executors_[CAFFE2_COMPILE_TIME_MAX_GPUS];
-std::mutex GPUExecutor::gpu_mtx_[CAFFE2_COMPILE_TIME_MAX_GPUS];
-
-std::shared_ptr<GPUExecutor> GPUExecutor::Get(int gpu) {
-  std::lock_guard<std::mutex> grd(gpu_mtx_[gpu]);
-  if (!executors_[gpu].get()) {
-    executors_[gpu].reset(new GPUExecutor(gpu));
-    executors_[gpu].get()->start();
-  }
-  return executors_[gpu];
-}
-
-void GPUExecutor::Release(int gpu) {
-  std::lock_guard<std::mutex> grd(gpu_mtx_[gpu]);
-  if (executors_[gpu].use_count() == 1) {
-    executors_[gpu].reset();
-  }
-}
-
-void GPUExecutor::set_affinity() {
-// TODO: find a Windows-compatible affinity setting approach.
-// Currently, set_affinity has no effect in Windows. The code is still
-// correct with possible slowdowns.
-#if !defined(_MSC_VER) && !defined(__APPLE__)
-  /* Set CPU affinity */
-  int num_cores = std::thread::hardware_concurrency();
-  if (num_cores > 0) {
-    cpu_set_t mask;
-    CPU_ZERO(&mask);
-
-    CPU_SET(gpu_id_ % num_cores, &mask);
-    if (sched_setaffinity(0, sizeof(cpu_set_t), &mask)) {
-      LOG(WARNING) << "Could not set CPU affinity";
-    }
-  }
-#endif
-}
-
-// Worker that takes list of operators from the queue
-// and executes them.
-void GPUExecutor::WorkerFunction() {
-  int stream_id_seq = 0;
-  std::stack<int> streams;
-  set_affinity();
-
-  while (true) {
-    Task* task = nullptr;
-    vector<Task*> task_batch;
-
-    if (!queue_.Pop(&task)) {
-      return;
-    }
-    int num_tasks = 1 + queue_.size();
-
-    // Grab all tasks currently in queue so we can run them in parallel
-    // Since we have only one producer, we know this does not block
-
-    // TODO: launch ops in "zig-zag" manner so that we can start multiple
-    // streams as simultaneously as possible
-    for (int i = num_tasks - 1; i >= 0; i--) {
-      assert(task != nullptr);
-      if (streams.empty()) {
-        task->stream_id_ = stream_id_seq++;
-      } else {
-        task->stream_id_ = streams.top();
-        streams.pop();
-      }
-
-      for (auto& op : *task->ops_) {
-        op->RunAsync(task->stream_id_);
-      }
-      task_batch.push_back(task);
-
-      // Get the next one
-      if (i > 0) {
-        if (!queue_.Pop(&task)) {
-          return;
-        }
-      }
-    }
-
-    // Wait for the currently executing streams
-    for (auto& pendtask : task_batch) {
-      cudaStream_t stream =
-          CUDAContext::cuda_stream(gpu_id_, pendtask->stream_id_);
-      CUDA_ENFORCE(cudaStreamSynchronize(stream));
-      streams.push(pendtask->stream_id_);
-      std::unique_lock<std::mutex> lk(*pendtask->mtx_);
-      pendtask->done_ = true;
-      pendtask->cv_->notify_one();
-    }
-  }
-}
-
-class SingleThreadAsyncNet : public SimpleNet {
- public:
-  using SimpleNet::SimpleNet;
-
-  ~SingleThreadAsyncNet() {
-    if (executor_.get()) {
-      // Explicitly reset my holding of the exeuctor so it can be
-      // killed.
-      executor_.reset();
-      GPUExecutor::Release(gpu_id_);
-    }
-  }
-
-  bool Run() override {
-    if (!executor_.get()) {
-      initialize();
-    }
-
-    // Dispatch jobs to the gpu-specific executor thread
-    std::unique_lock<std::mutex> lk(mutex_);
-    Task t;
-    t.ops_ = &operators_;
-    t.cv_ = &cv_;
-    t.mtx_ = &mutex_;
-    t.done_ = false;
-    executor_.get()->RunJob(&t);
-
-    while (!t.done_) {
-      cv_.wait(lk);
-    }
-
-    return true;
-  }
-
- private:
-  std::condition_variable cv_;
-  std::mutex mutex_;
-
-  void initialize() {
-    std::lock_guard<std::mutex> grd(mutex_);
-
-    /* Check the gpu id of this net and check that only one
-       GPU has operators on this net */
-    gpu_id_ = (-1);
-    for (auto& op : operators_) {
-      if (op->device_option().device_type() == CUDA) {
-        if (gpu_id_ < 0) {
-          gpu_id_ = op->device_option().cuda_gpu_id();
-        } else {
-          CAFFE_ENFORCE_EQ(
-              gpu_id_,
-              op->device_option().cuda_gpu_id(),
-              "One net can only have operators for one GPU");
-        }
-      }
-    }
-    executor_ = GPUExecutor::Get(gpu_id_);
-  }
-
-  int gpu_id_;
-  std::shared_ptr<GPUExecutor> executor_;
-};
-
-REGISTER_NET(singlethread_async, SingleThreadAsyncNet)
-
-} // namespace gpu_single_thread
-} // namespace caffe2

From 9b05bb5d6ccf07f6607aaf6caa26a0a798ca83c8 Mon Sep 17 00:00:00 2001
From: Ilia Cherniavskii <iliacher@fb.com>
Date: Tue, 12 Jun 2018 10:00:30 -0700
Subject: [PATCH 027/118] Inline DFS task execution

Add a DFS inline task execution mode in executor
---
 caffe2/core/net_async_scheduling.cc | 33 ++++++++++++++++++++++-------
 caffe2/core/net_async_scheduling.h  |  3 ++-
 2 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/caffe2/core/net_async_scheduling.cc b/caffe2/core/net_async_scheduling.cc
index 87c2a4b0c237f..fb9ddd22f1524 100644
--- a/caffe2/core/net_async_scheduling.cc
+++ b/caffe2/core/net_async_scheduling.cc
@@ -12,7 +12,16 @@ namespace caffe2 {
 AsyncSchedulingNet::AsyncSchedulingNet(
     const std::shared_ptr<const NetDef>& net_def,
     Workspace* ws)
-    : AsyncNetBase(net_def, ws), running_(false) {}
+    : AsyncNetBase(net_def, ws), running_(false), use_dfs_scheduling_(false) {
+  for (int arg_idx = 0; arg_idx < net_def->arg_size(); ++arg_idx) {
+    auto& arg = net_def->arg(arg_idx);
+    if (arg.has_name() && arg.name() == "deferrable_mode") {
+      CAFFE_ENFORCE(arg.has_i(), "deferrable_mode should be an int");
+      use_dfs_scheduling_ = arg.i() == 1; // corr. to DFS scheduling
+      break;
+    }
+  }
+}
 
 void AsyncSchedulingNet::reset() {
   AsyncNetBase::reset();
@@ -27,12 +36,11 @@ void AsyncSchedulingNet::Wait() {
   }
 }
 
-void AsyncSchedulingNet::schedule(int task_id) {
+void AsyncSchedulingNet::schedule(int task_id, bool run_inline) {
   if (!testAndSetScheduled(task_id)) {
     return;
   }
-  const auto& device_option = event(task_id).GetDeviceOption();
-  pool(device_option)->run([this, task_id]() {
+  auto schedule_func = [this, task_id]() {
     if (success_) {
       int stream_id = 0;
       if (streams_per_gpu_ > 1) {
@@ -56,7 +64,9 @@ void AsyncSchedulingNet::schedule(int task_id) {
         // - in all other cases, check parents with canSchedule
         if (!success_ || always_schedule_child_ || finish_chain_ ||
             canSchedule(child_id)) {
-          schedule(child_id);
+          // if DFS scheduling is enabled, run children inline,
+          // ignore DFS scheduling in callbacks
+          schedule(child_id, use_dfs_scheduling_);
         } else {
           bool parent_failed = false;
           bool parent_needs_polling = false;
@@ -95,7 +105,7 @@ void AsyncSchedulingNet::schedule(int task_id) {
           if (parent_failed) {
             // one of parents failed, set failure flag and wrap up execution
             success_ = false;
-            schedule(child_id);
+            schedule(child_id, use_dfs_scheduling_);
           } else if (parent_needs_polling) {
             // some parents are blocking us from scheduling a child and don't
             // support callbacks, using polling
@@ -112,7 +122,7 @@ void AsyncSchedulingNet::schedule(int task_id) {
             }
           } else {
             // we're ready to schedule a child
-            schedule(child_id);
+            schedule(child_id, use_dfs_scheduling_);
           }
         }
       }
@@ -127,7 +137,14 @@ void AsyncSchedulingNet::schedule(int task_id) {
     if (cur_processed_tasks == tasks_num) {
       finishRun();
     }
-  });
+  };
+
+  if (run_inline) {
+    schedule_func();
+  } else {
+    const auto& device_option = event(task_id).GetDeviceOption();
+    pool(device_option)->run(schedule_func);
+  }
 }
 
 void AsyncSchedulingNet::parentCallback(int parent_id) {
diff --git a/caffe2/core/net_async_scheduling.h b/caffe2/core/net_async_scheduling.h
index 718181887b564..0a15760f765b2 100644
--- a/caffe2/core/net_async_scheduling.h
+++ b/caffe2/core/net_async_scheduling.h
@@ -18,7 +18,7 @@ class AsyncSchedulingNet : public AsyncNetBase {
   bool RunAsync() override;
 
   void pollAndSchedule(int task_id);
-  void schedule(int task_id);
+  void schedule(int task_id, bool run_inline = false);
   void reset() override;
   virtual void finishRun();
   void parentCallback(int parent_id);
@@ -27,6 +27,7 @@ class AsyncSchedulingNet : public AsyncNetBase {
   std::condition_variable running_cv_;
   std::atomic<bool> running_;
   std::atomic<bool> success_;
+  bool use_dfs_scheduling_;
 
   std::atomic<int> processed_tasks_num_;
 

From 7368bbcf2a2f53eb8f369c86aaf4826257e9c301 Mon Sep 17 00:00:00 2001
From: Sebastian Messmer <messmer@fb.com>
Date: Tue, 12 Jun 2018 10:01:01 -0700
Subject: [PATCH 028/118] Add c10 folder to fbcode

This adds the c10 folder and its test cases to fbcode. Build flags are mostly taken from aten.
---
 CMakeLists.txt        |  3 +++
 c10/CMakeLists.txt    | 50 +++++++++++++++++++++++++++++++++++++++++++
 c10/dummy.cpp         |  3 +++
 c10/dummy.h           |  3 +++
 c10/dummy_test.cpp    |  6 ++++++
 caffe2/CMakeLists.txt |  1 +
 6 files changed, 66 insertions(+)
 create mode 100644 c10/CMakeLists.txt
 create mode 100644 c10/dummy.cpp
 create mode 100644 c10/dummy.h
 create mode 100644 c10/dummy_test.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index eb3c876f0a948..82fac5b5415b5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -297,6 +297,9 @@ if(BUILD_CAFFE2)
   add_subdirectory(caffe/proto)
 endif()
 
+# ---[ Shared build
+add_subdirectory(c10)
+
 # ---[ Main build
 add_subdirectory(caffe2)
 
diff --git a/c10/CMakeLists.txt b/c10/CMakeLists.txt
new file mode 100644
index 0000000000000..1cb1d31d76d32
--- /dev/null
+++ b/c10/CMakeLists.txt
@@ -0,0 +1,50 @@
+project(c10 CXX C)
+
+set(LIB_SOURCES
+        dummy.cpp
+)
+
+set(TEST_SOURCES
+        dummy_test.cpp
+)
+
+if(MSVC)
+  # TODO Also add some warning options that MSVC can understand
+  set(WARNING_OPTIONS "")
+else()
+  set(WARNING_OPTIONS
+        -Wall
+        -Wextra
+        -Wold-style-cast
+        -Wno-missing-braces
+        -Wcast-align
+        -Wcast-qual
+        -Wctor-dtor-privacy
+        -Wdisabled-optimization
+        -Wformat=2
+        -Winit-self
+        -Wmissing-include-dirs
+        -Woverloaded-virtual
+        -Wredundant-decls
+        -Wshadow
+        -Wsign-promo
+        -Wstrict-overflow=5
+        -fdiagnostics-show-option
+        -Wconversion
+        -Wpedantic
+        -Wno-gnu-zero-variadic-macro-arguments
+        -Wundef
+        -Werror
+        )
+endif()
+
+add_library(${PROJECT_NAME} OBJECT ${LIB_SOURCES})
+target_compile_options(${PROJECT_NAME} PRIVATE ${WARNING_OPTIONS})
+
+if(BUILD_TEST)
+    add_executable(${PROJECT_NAME}_test ${TEST_SOURCES} $<TARGET_OBJECTS:${PROJECT_NAME}>)
+    add_test(NAME ${PROJECT_NAME}_test COMMAND $<TARGET_FILE:${PROJECT_NAME}_test>)
+    target_compile_options(${PROJECT_NAME}_test PRIVATE ${WARNING_OPTIONS})
+    target_link_libraries(${PROJECT_NAME}_test gtest_main)
+    install(TARGETS ${PROJECT_NAME}_test DESTINATION test)
+endif()
diff --git a/c10/dummy.cpp b/c10/dummy.cpp
new file mode 100644
index 0000000000000..7eb029f2618e7
--- /dev/null
+++ b/c10/dummy.cpp
@@ -0,0 +1,3 @@
+// This is going to be replaced with actual c10 files
+
+#include <c10/dummy.h>
diff --git a/c10/dummy.h b/c10/dummy.h
new file mode 100644
index 0000000000000..c4be4d6b80872
--- /dev/null
+++ b/c10/dummy.h
@@ -0,0 +1,3 @@
+#pragma once
+
+// This is going to be replaced with actual c10 files
diff --git a/c10/dummy_test.cpp b/c10/dummy_test.cpp
new file mode 100644
index 0000000000000..4e32bef2cd3aa
--- /dev/null
+++ b/c10/dummy_test.cpp
@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+#include <c10/dummy.h>
+
+TEST(DummyTest, dummy) {
+    EXPECT_TRUE(true);
+}
diff --git a/caffe2/CMakeLists.txt b/caffe2/CMakeLists.txt
index cc21ed93a1948..6b15d4c0b8d94 100644
--- a/caffe2/CMakeLists.txt
+++ b/caffe2/CMakeLists.txt
@@ -178,6 +178,7 @@ if(BUILD_CAFFE2)
 endif()
 
 # Compile exposed libraries.
+list(APPEND Caffe2_CPU_SRCs $<TARGET_OBJECTS:c10>)
 add_library(caffe2 ${Caffe2_CPU_SRCS})
 if (BUILD_CAFFE2)
   caffe2_interface_library(caffe2_protos caffe2_protos_whole)

From d59ea24038bb263032d52e7cad11eaaf9e0951e1 Mon Sep 17 00:00:00 2001
From: Minxing Liu <mxliu@fb.com>
Date: Tue, 12 Jun 2018 10:01:19 -0700
Subject: [PATCH 029/118] add dependencies for online trainer

Add some dependencies so that the online model can use DataPipeline and PredictionTransform operators

Relevent post: https://fb.intern.facebook.com/groups/1324375037655677/permalink/1740993462660497/
---
 caffe2/python/mkl/rewrite_graph.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/caffe2/python/mkl/rewrite_graph.py b/caffe2/python/mkl/rewrite_graph.py
index c81383a3ea97a..157b0251db9ac 100644
--- a/caffe2/python/mkl/rewrite_graph.py
+++ b/caffe2/python/mkl/rewrite_graph.py
@@ -67,7 +67,8 @@ def mkl_tmp(name):
     # Fuse Conv-Relu for IDEEP
     if ideep:
         net.ParseFromString(
-                C.transform_optimizeForIDEEP(net.SerializeToString()))
+            C.transform_optimizeForIDEEP(net.SerializeToString()))
+
 
 def rewrite_model_helper_simple(model, ideep=True):
     model = copy.deepcopy(model)

From a1e65ecf4c5a590d28343152b418904955ffce68 Mon Sep 17 00:00:00 2001
From: James Reed <jamesreed@fb.com>
Date: Tue, 12 Jun 2018 10:01:23 -0700
Subject: [PATCH 030/118] Resolve conflicts for tools/jit/gen_jit_dispatch.py

---
 tools/jit/gen_jit_dispatch.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/jit/gen_jit_dispatch.py b/tools/jit/gen_jit_dispatch.py
index 27fb9a9aa5c83..f1bf2d97726a7 100644
--- a/tools/jit/gen_jit_dispatch.py
+++ b/tools/jit/gen_jit_dispatch.py
@@ -100,6 +100,8 @@ def is_jit_op(decl):
     # Only support a single TensorList arg
     if sum(arg['simple_type'] == 'TensorList' for arg in arguments) > 1:
         return False
+    if any(arg['simple_type'] == 'std::string' for arg in arguments):
+        return False
 
     return ((not decl['api_name'].endswith('_') or is_magic_method(decl['api_name'])) and
             not decl['name'].endswith('_out') and

From daed3239766bb8b22d471e94c1989fb3f6a5c7c9 Mon Sep 17 00:00:00 2001
From: Chenguang Xi <cxi@fb.com>
Date: Tue, 12 Jun 2018 10:04:08 -0700
Subject: [PATCH 031/118] [Fix] sparse regularization in distributed training

---
 caffe2/operators/sparse_normalize_op_gpu.cu |  9 +++++++++
 caffe2/python/layer_model_helper.py         | 18 ++++++++++++++----
 2 files changed, 23 insertions(+), 4 deletions(-)
 create mode 100644 caffe2/operators/sparse_normalize_op_gpu.cu

diff --git a/caffe2/operators/sparse_normalize_op_gpu.cu b/caffe2/operators/sparse_normalize_op_gpu.cu
new file mode 100644
index 0000000000000..d5e6cc73d1910
--- /dev/null
+++ b/caffe2/operators/sparse_normalize_op_gpu.cu
@@ -0,0 +1,9 @@
+#include "caffe2/core/context_gpu.h"
+#include "caffe2/operators/operator_fallback_gpu.h"
+#include "caffe2/operators/sparse_normalize_op.h"
+
+namespace caffe2 {
+REGISTER_CUDA_OPERATOR(
+    SparseNormalize,
+    GPUFallbackOp<SparseNormalizeOp<float, CPUContext>>);
+}
diff --git a/caffe2/python/layer_model_helper.py b/caffe2/python/layer_model_helper.py
index 34914d7a8b7e4..f142fd195237a 100644
--- a/caffe2/python/layer_model_helper.py
+++ b/caffe2/python/layer_model_helper.py
@@ -5,7 +5,7 @@
 from __future__ import print_function
 from __future__ import unicode_literals
 
-from caffe2.python import core, model_helper, schema, scope, utils
+from caffe2.python import core, model_helper, schema, scope, utils, muji
 from caffe2.python.modeling.parameter_info import (
     ParameterInfo,
 )
@@ -549,12 +549,22 @@ def apply_regularizers_after_optimizer(
         grad_map,
         blob_to_device=None,
     ):
+        CPU = muji.OnCPU()
+        # if given, blob_to_device is a map from blob to device_option
+        blob_to_device = blob_to_device or {}
         for param, regularizer in viewitems(self.param_to_reg):
             if regularizer is None or not regularizer.apply_after_optimizer:
                 continue
             assert isinstance(regularizer, Regularizer)
-            regularizer(
-                train_net, train_init_net, param, grad_map.get(str(param)))
+            device = get_param_device(
+                param,
+                grad_map.get(str(param)),
+                param_to_device=blob_to_device,
+                default_device=CPU,
+            )
+            with core.DeviceScope(device):
+                regularizer(
+                    train_net, train_init_net, param, grad_map.get(str(param)))
 
     def apply_post_grad_net_modifiers(
         self,
@@ -592,7 +602,7 @@ def apply_optimizers(
         grad_map,
         blob_to_device=None,
     ):
-        CPU = core.DeviceOption(caffe2_pb2.CPU)
+        CPU = muji.OnCPU()
         # if given, blob_to_device is a map from blob to device_option
         blob_to_device = blob_to_device or {}
         for param, optimizer in viewitems(self.param_to_optim):

From 0d374e9c16eb3ed1c0fe389d9edb5e42599f44e8 Mon Sep 17 00:00:00 2001
From: Zhishuai Zhang <zhishuaizhang@fb.com>
Date: Tue, 12 Jun 2018 10:04:44 -0700
Subject: [PATCH 032/118] Support advanced pooling options in sum processor

* support advanced pooling options in sum processor
* remove redundant code
* support attention in sum processor
---
 caffe2/operators/elementwise_add_op.cc |  6 +++
 caffe2/operators/elementwise_div_op.cc |  2 +
 caffe2/operators/elementwise_mul_op.cc |  2 +
 caffe2/operators/elementwise_sub_op.cc |  2 +
 caffe2/operators/log_op.cc             |  4 ++
 caffe2/operators/tanh_op.cc            | 55 ++++++++++++++++++++++++++
 6 files changed, 71 insertions(+)

diff --git a/caffe2/operators/elementwise_add_op.cc b/caffe2/operators/elementwise_add_op.cc
index 849006a3bb32b..0413da5e03418 100644
--- a/caffe2/operators/elementwise_add_op.cc
+++ b/caffe2/operators/elementwise_add_op.cc
@@ -6,4 +6,10 @@ REGISTER_CPU_OPERATOR(
     Add,
     BinaryElementwiseOp<NumericTypes, CPUContext, AddFunctor<CPUContext>>);
 
+} // namespace
+
+REGISTER_GRADIENT(Add, GetAddGradient);
+
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_div_op.cc b/caffe2/operators/elementwise_div_op.cc
index 73f0b23f7d1da..fd9cf4f4ba5f2 100644
--- a/caffe2/operators/elementwise_div_op.cc
+++ b/caffe2/operators/elementwise_div_op.cc
@@ -7,4 +7,6 @@ REGISTER_CPU_OPERATOR(
     Div,
     BinaryElementwiseOp<NumericTypes, CPUContext, DivFunctor<CPUContext>>);
 
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_mul_op.cc b/caffe2/operators/elementwise_mul_op.cc
index a55112a4b7c46..52f740b11f69c 100644
--- a/caffe2/operators/elementwise_mul_op.cc
+++ b/caffe2/operators/elementwise_mul_op.cc
@@ -6,4 +6,6 @@ REGISTER_CPU_OPERATOR(
     Mul,
     BinaryElementwiseOp<NumericTypes, CPUContext, MulFunctor<CPUContext>>);
 
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_sub_op.cc b/caffe2/operators/elementwise_sub_op.cc
index f906883a183bf..299c46640c763 100644
--- a/caffe2/operators/elementwise_sub_op.cc
+++ b/caffe2/operators/elementwise_sub_op.cc
@@ -6,4 +6,6 @@ REGISTER_CPU_OPERATOR(
     Sub,
     BinaryElementwiseOp<NumericTypes, CPUContext, SubFunctor<CPUContext>>);
 
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/log_op.cc b/caffe2/operators/log_op.cc
index 68e95e6f25ffb..28be919e9246e 100644
--- a/caffe2/operators/log_op.cc
+++ b/caffe2/operators/log_op.cc
@@ -9,6 +9,8 @@ REGISTER_CPU_OPERATOR(
     Log,
     UnaryElementwiseOp<TensorTypes<float>, CPUContext, LogFunctor<CPUContext>>);
 
+#if !CAFFE2_MOBILE
+
 OPERATOR_SCHEMA(Log)
     .NumInputs(1)
     .NumOutputs(1)
@@ -44,4 +46,6 @@ class GetLogGradient : public GradientMakerBase {
 
 REGISTER_GRADIENT(Log, GetLogGradient);
 
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/tanh_op.cc b/caffe2/operators/tanh_op.cc
index 69682256cdd49..d6a1b08a60c8b 100644
--- a/caffe2/operators/tanh_op.cc
+++ b/caffe2/operators/tanh_op.cc
@@ -18,12 +18,48 @@ bool TanhFunctor<CPUContext>::operator()<float>(
   return true;
 }
 
+<<<<<<< HEAD
+=======
+#if !CAFFE2_MOBILE
+
+template <>
+template <typename T>
+bool TanhGradientFunctor<CPUContext>::Forward(
+    const std::vector<int>& dY_dims,
+    const std::vector<int>& /* Y_dims */,
+    const T* dY,
+    const T* Y,
+    T* dX,
+    CPUContext* /* context */) const {
+  const int size = std::accumulate(
+      dY_dims.cbegin(), dY_dims.cend(), 1, std::multiplies<int>());
+  ConstEigenVectorArrayMap<T> dY_arr(dY, size);
+  ConstEigenVectorArrayMap<T> Y_arr(Y, size);
+  EigenVectorMap<T>(dX, size) = dY_arr * (1 - Y_arr * Y_arr);
+  return true;
+}
+
+#endif // !CAFFE2_MOBILE
+
+>>>>>>> 8ac1a59... Support advanced pooling options in sum processor
 REGISTER_CPU_OPERATOR(
     Tanh,
     UnaryElementwiseOp<
         TensorTypes<float>,
         CPUContext,
         TanhFunctor<CPUContext>>);
+<<<<<<< HEAD
+=======
+
+#if !CAFFE2_MOBILE
+
+REGISTER_CPU_OPERATOR(
+    TanhGradient,
+    BinaryElementwiseOp<
+        TensorTypes<float>,
+        CPUContext,
+        TanhGradientFunctor<CPUContext>>);
+>>>>>>> 8ac1a59... Support advanced pooling options in sum processor
 
 OPERATOR_SCHEMA(Tanh)
     .NumInputs(1)
@@ -93,4 +129,23 @@ print("X:\n", workspace.FetchBlob("X"))
 
 OPERATOR_SCHEMA(TanhGradient).NumInputs(2).NumOutputs(1).AllowInplace({{0, 0}});
 
+namespace {
+
+class GetTanhGradient : public GradientMakerBase {
+  using GradientMakerBase::GradientMakerBase;
+  std::vector<OperatorDef> GetGradientDefs() override {
+    return SingleGradientDef(
+        "TanhGradient",
+        "",
+        std::vector<std::string>{GO(0), O(0)},
+        std::vector<std::string>{GI(0)});
+  }
+};
+
+} // namespace
+
+REGISTER_GRADIENT(Tanh, GetTanhGradient);
+
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2

From f114ef6c0ed691f62608e632372f3ce29d31ffef Mon Sep 17 00:00:00 2001
From: Duc Ngo <duc@fb.com>
Date: Tue, 12 Jun 2018 10:04:54 -0700
Subject: [PATCH 033/118] Improve shard logging in net tracing code

Make it handle arbitrary shard ids instead of just one digit ids.
---
 caffe2/core/net_async_tracing.cc      | 66 +++++++++++++++++----------
 caffe2/core/net_async_tracing.h       |  4 ++
 caffe2/core/net_async_tracing_test.cc | 42 +++++++++++++++++
 3 files changed, 88 insertions(+), 24 deletions(-)
 create mode 100644 caffe2/core/net_async_tracing_test.cc

diff --git a/caffe2/core/net_async_tracing.cc b/caffe2/core/net_async_tracing.cc
index 0d3f83aba277e..b2c4a1952b785 100644
--- a/caffe2/core/net_async_tracing.cc
+++ b/caffe2/core/net_async_tracing.cc
@@ -46,32 +46,15 @@ void Tracer::recordEvent(const TracerEvent& event) {
   events_.push_back(event);
 }
 
+// Forward
+int getUniqueShardId(const OperatorDef& op_def);
+
 // Special handling of shard blob annotations
 std::string Tracer::opTraceName(const OperatorBase* op) {
-  if (!op->has_debug_def()) {
-    return op->type();
-  }
-
-  const auto& op_def = op->debug_def();
-  std::unordered_set<int> shards;
-  const std::string kShard = "shard:";
-  int shard = 0;
-  for (const auto& input : op_def.input()) {
-    auto pos = input.find(kShard);
-    if (pos != std::string::npos) {
-      shard = input[pos + kShard.length()] - '0';
-      shards.insert(shard);
-    }
-  }
-  for (const auto& output : op_def.output()) {
-    auto pos = output.find(kShard);
-    if (pos != std::string::npos) {
-      shard = output[pos + kShard.length()] - '0';
-      shards.insert(shard);
-    }
-  }
-  if (shards.size() == 1) {
-    return op->type() + ":" + caffe2::to_string(shard);
+  int unique_shard_id =
+      op->has_debug_def() ? getUniqueShardId(op->debug_def()) : -1;
+  if (unique_shard_id != -1) {
+    return op->type() + ":" + caffe2::to_string(unique_shard_id);
   } else {
     return op->type();
   }
@@ -327,6 +310,41 @@ TracerGuard::~TracerGuard() {
   }
 }
 
+int extractShardId(const std::string& name) {
+  const std::string kShard = "shard:";
+  // We sometimes have multiple shards, but actually need the last one, hence
+  // using rfind here. Hacky but it works till we pass shard id in graph
+  // metadata.
+  auto pos = name.rfind(kShard);
+  if (pos != std::string::npos) {
+    int left_pos = pos + kShard.length();
+    int right_pos = left_pos;
+    while (right_pos < name.length() && isdigit(name[right_pos])) {
+      right_pos++;
+    }
+    return std::stoi(name.substr(left_pos, right_pos - left_pos));
+  } else {
+    return -1;
+  }
+}
+
+// Return unique shard id, or -1 if it is not unique.
+int getUniqueShardId(const OperatorDef& op_def) {
+  int unique_shard_id = -1;
+  for (const auto& names : {op_def.input(), op_def.output()}) {
+    for (const auto& name : names) {
+      int shard_id = extractShardId(name);
+      if (shard_id != -1) {
+        if (unique_shard_id != -1) {
+          return -1;
+        }
+        unique_shard_id = shard_id;
+      }
+    }
+  }
+  return unique_shard_id;
+}
+
 bool isTraceableNet(const std::string& net_name) {
   auto tracing_nets = caffe2::split(',', FLAGS_caffe2_net_async_names_to_trace);
   return !net_name.empty() &&
diff --git a/caffe2/core/net_async_tracing.h b/caffe2/core/net_async_tracing.h
index ace94e0f74f48..54c362c191146 100644
--- a/caffe2/core/net_async_tracing.h
+++ b/caffe2/core/net_async_tracing.h
@@ -104,6 +104,10 @@ class TracerGuard {
   Tracer* tracer_;
 };
 
+// Extract the shard id from name of the form "...shard:123..."
+// Return -1 if there is no shard found
+int extractShardId(const std::string& name);
+
 bool isTraceableNet(const std::string& net_name);
 
 std::shared_ptr<Tracer> create(const NetBase* net, const std::string& net_name);
diff --git a/caffe2/core/net_async_tracing_test.cc b/caffe2/core/net_async_tracing_test.cc
new file mode 100644
index 0000000000000..095d4f83838bb
--- /dev/null
+++ b/caffe2/core/net_async_tracing_test.cc
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "caffe2/core/net_async_tracing.h"
+
+namespace caffe2 {
+
+namespace tracing {
+
+void testExtractShardId(const string& name, int expectedId) {
+  EXPECT_EQ(extractShardId(name), expectedId);
+}
+
+TEST(NetAsyncTracingTest, ExtractShardId) {
+  testExtractShardId("ABCDEFshard:1705!!A", 1705);
+  // Should use the last one
+  testExtractShardId("ABCDEFshard:4324!!Ashard:01220b", 1220);
+  // Nothing to extract
+  testExtractShardId("ABCDEFsha:222", -1);
+  // Regular cases
+  testExtractShardId("FC:shard:0", 0);
+  testExtractShardId("FC:shard:10", 10);
+  testExtractShardId("FC:shard:15", 15);
+}
+
+} // namespace tracing
+
+} // namespace caffe2

From a9ba1631bbb0bd71dba368b230326219eaf752bf Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 10:05:34 -0700
Subject: [PATCH 034/118] [Caffe2] Call GlobalInit in predictor only in mobile

FACEBOOK:
Calling GlobalInit long after the program starts may not be safe. There are issues if the following happens:

User does not call GlobalInit and initFacebook after program starts
User sets a flag manually: https://fburl.com/mcsumw7d
User calls OSS predictor.
OSS predictor calls GlobalInit
GlobalInit calls initFacebook
initFacebook resets all flags: https://fburl.com/tolszha1
Thus, the user manually set flags are overwritten

This would happen anytime GlobalInit is called long after the program starts.
I suppose the intention of the user in this case is not to call GlobalInit throughout the program,
but use Caffe2 regardless (is that desired?)
But adding GlobalInit in the OSS predictor would automatically call GlobalInit when using Caffe2.

This issue doesn't exist in mobile, since initFacebook is not called on mobile.

For now, guard the GlobalInit in predictor for mobile only.
May want to ensure the GlobalInit is always called at the start of the program. @[3501714:kutta] has seen weird issues when not calling GlobalInit at the start of the program on server side. He has made some progress on this.
---
 caffe2/core/predictor.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/caffe2/core/predictor.cc b/caffe2/core/predictor.cc
index e82aa098ce6e8..bbe487b3ac6cd 100644
--- a/caffe2/core/predictor.cc
+++ b/caffe2/core/predictor.cc
@@ -92,8 +92,9 @@ Predictor::Predictor(
   if (run_init) {
     CAFFE_ENFORCE(ws_.RunNetOnce(init_net));
   }
-
+#if CAFFE2_MOBILE
   GlobalInit();
+#endif
 
   if (optimization) {
 #ifdef CAFFE2_OPTIMIZER

From 30a8c611dedec3325535821a83af920544da856f Mon Sep 17 00:00:00 2001
From: Bram Wasti <bwasti@fb.com>
Date: Tue, 12 Jun 2018 10:06:06 -0700
Subject: [PATCH 035/118] resolve conflicts for
 caffe2/core/logging_is_google_glog.h and test/test_torch.py

---
 aten/src/ATen/Declarations.yaml               | 14 +++++-----
 aten/src/ATen/gen.py                          | 16 ++++++-----
 .../include/nomnigraph/Support/Common.h       | 18 +++++++++++++
 caffe2/core/nomnigraph/ops.def                |  6 +++++
 caffe2/opt/converter.cc                       | 27 +++++++++++++++++++
 5 files changed, 68 insertions(+), 13 deletions(-)

diff --git a/aten/src/ATen/Declarations.yaml b/aten/src/ATen/Declarations.yaml
index e865a8ab30c66..71715505f9d59 100644
--- a/aten/src/ATen/Declarations.yaml
+++ b/aten/src/ATen/Declarations.yaml
@@ -22710,7 +22710,7 @@
   abstract: true
   auto_gpu: true
   with_gil: false
-- name: _cast_uint8_t
+- name: _cast_Byte
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22735,7 +22735,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_int8_t
+- name: _cast_Char
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22760,7 +22760,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_double
+- name: _cast_Double
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22785,7 +22785,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_float
+- name: _cast_Float
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22810,7 +22810,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_int
+- name: _cast_Int
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22835,7 +22835,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_int64_t
+- name: _cast_Long
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22860,7 +22860,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_int16_t
+- name: _cast_Short
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
diff --git a/aten/src/ATen/gen.py b/aten/src/ATen/gen.py
index c1be0c0563408..84de0bc10e6b0 100644
--- a/aten/src/ATen/gen.py
+++ b/aten/src/ATen/gen.py
@@ -4,6 +4,10 @@
 import yaml
 from collections import OrderedDict
 
+import sys
+from os import path
+sys.path.append(path.dirname(path.abspath(__file__)))
+
 import cwrap_parser
 import nn_parse
 import native_parse
@@ -23,6 +27,7 @@
 
 parser = argparse.ArgumentParser(description='Generate ATen source files')
 parser.add_argument('files', help='cwrap files', nargs='+')
+
 parser.add_argument(
     '-s',
     '--source-path',
@@ -33,12 +38,11 @@
     '--output-dependencies',
     help='output a list of dependencies into the given file and exit')
 parser.add_argument(
-    '-d', '--output-dir', help='output directory', default='ATen')
+    '-d', '--install_dir', help='output directory', default='ATen')
 options = parser.parse_args()
 
-
-if options.output_dir is not None and not os.path.exists(options.output_dir):
-    os.makedirs(options.output_dir)
+if options.install_dir is not None and not os.path.exists(options.install_dir):
+    os.makedirs(options.install_dir)
 
 
 class FileManager(object):
@@ -48,7 +52,7 @@ def __init__(self):
         self.undeclared_files = []
 
     def will_write(self, filename):
-        filename = '{}/{}'.format(options.output_dir, filename)
+        filename = '{}/{}'.format(options.install_dir, filename)
         if self.outputs_written:
             raise Exception("'will_write' can only be called before " +
                             "the call to write_outputs, refactor so outputs are registered " +
@@ -74,7 +78,7 @@ def write_outputs(self, filename):
         self.outputs_written = True
 
     def write(self, filename, s, env=None):
-        filename = '{}/{}'.format(options.output_dir, filename)
+        filename = '{}/{}'.format(options.install_dir, filename)
         if isinstance(s, CodeTemplate):
             assert env is not None
             env['generated_comment'] = "@" + "generated by aten/src/ATen/gen.py"
diff --git a/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h b/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
index 9a39ab2405cf5..9731d048a31fa 100644
--- a/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
+++ b/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
@@ -14,6 +14,24 @@
 #include <functional>
 #include <list>
 
+// These #defines are useful when writing passes as the collapse
+//
+// if (!cond) {
+//   continue; // or break; or return;
+// }
+//
+// into a single line without negation
+
+#define NOM_REQUIRE_OR_(_cond, _expr) \
+  if (!(_cond)) {                     \
+    _expr;                            \
+  }
+
+#define NOM_REQUIRE_OR_CONT(_cond) NOM_REQUIRE_OR_(_cond, continue)
+#define NOM_REQUIRE_OR_BREAK(_cond) NOM_REQUIRE_OR_(_cond, break)
+#define NOM_REQUIRE_OR_RET_NULL(_cond) NOM_REQUIRE_OR_(_cond, return nullptr)
+#define NOM_REQUIRE_OR_RET(_cond) NOM_REQUIRE_OR_(_cond, return )
+
 // Implements accessors for a generic type T. If the type is not
 // specified (i.e., void template type) then the partial specification
 // gives an empty type.
diff --git a/caffe2/core/nomnigraph/ops.def b/caffe2/core/nomnigraph/ops.def
index 6240ff2b04391..9182c80fbd76b 100644
--- a/caffe2/core/nomnigraph/ops.def
+++ b/caffe2/core/nomnigraph/ops.def
@@ -55,6 +55,8 @@ BatchNormalization
 FC
 GivenTensorFill
 Concat
+- Axis : int : -1
+- AddAxis : bool : false
 Softmax
 ChannelShuffle
 Add
@@ -81,3 +83,7 @@ Int8ConvRelu : ConvRelu
 Int8SumRelu : SumRelu
 Int8AveragePoolRelu : AveragePoolRelu
 Int8MaxPoolRelu : MaxPoolRelu
+
+BatchMatMul
+BatchGather
+ConcatBatchMatMulBatchGatherOp
diff --git a/caffe2/opt/converter.cc b/caffe2/opt/converter.cc
index e0f8dd160b08a..33700204625a8 100644
--- a/caffe2/opt/converter.cc
+++ b/caffe2/opt/converter.cc
@@ -128,6 +128,33 @@ convertToOperatorDef(caffe2::OperatorDef op) {
     nnOp = util::make_unique<repr::BatchNormalization>();
   }
 
+  if (op.type() == "Concat") {
+    nnOp = util::make_unique<repr::Concat>();
+    auto c = dyn_cast<repr::Concat>(nnOp.get());
+    if (argMap.count("axis")) {
+      assert(argMap["axis"].has_i() && "Invalid axis argument");
+      int axis = static_cast<int>(argMap["axis"].i());
+      c->setAxis(axis);
+    }
+    if (argMap.count("add_axis")) {
+      assert(argMap["add_axis"].has_i() && "Invalid add_axis argument");
+      int add_axis = static_cast<int>(argMap["add_axis"].i());
+      c->setAddAxis(!!add_axis);
+    }
+  }
+
+  if (op.type() == "Flatten") {
+    nnOp = util::make_unique<repr::Flatten>();
+  }
+
+  if (op.type() == "BatchGather") {
+    nnOp = util::make_unique<repr::BatchGather>();
+  }
+
+  if (op.type() == "BatchMatMul") {
+    nnOp = util::make_unique<repr::BatchMatMul>();
+  }
+
   if (!nnOp) {
     nnOp = util::make_unique<repr::GenericOperator>(op.type());
   }

From 035904fc6b67509dd514aabfefc5aaea647d0e78 Mon Sep 17 00:00:00 2001
From: Xiaomeng Yang <yangxm@fb.com>
Date: Tue, 12 Jun 2018 10:08:55 -0700
Subject: [PATCH 036/118] Add empty fix for SumLikeReduceOp

Add empty fix for SumLikeReduceOp
---
 caffe2/operators/elementwise_ops.cu | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/caffe2/operators/elementwise_ops.cu b/caffe2/operators/elementwise_ops.cu
index 73b60c69ef0cd..b564d8ae8005f 100644
--- a/caffe2/operators/elementwise_ops.cu
+++ b/caffe2/operators/elementwise_ops.cu
@@ -172,6 +172,12 @@ bool SumReduceLikeOp<CUDAContext>::DoRunWithType() {
   C->ResizeLike(B);
   const T* Adata = A.template data<T>();
   auto* Cdata = C->template mutable_data<T>();
+
+  if (C->size() == 0) {
+    // output is empty, nothing to do, not even launching the CUDA kernel
+    return true;
+  }
+
   if (B.size() == 1) {
     device_reduce<T>(Adata, Cdata, count, &sum_buffer_, &context_);
   } else {

From c9abde2281b0912a4cfce6df24c3a7365bb580f7 Mon Sep 17 00:00:00 2001
From: Andrey Malevich <amalevich@fb.com>
Date: Tue, 12 Jun 2018 10:10:08 -0700
Subject: [PATCH 037/118] Revert D7962948: [caffe2][nomnigraph] Concat elim for
 sparseNN

This reverts commit f7f434dc5c34ca6058b9765d2ef615453d2276a9

@bypass-lint

An infra SEV is better than not reverting this diff.
If you copy this password, see you in SEV Review!
@cause_a_sev_many_files
---
 .../include/nomnigraph/Support/Common.h       | 18 ------
 caffe2/core/nomnigraph/ops.def                |  6 --
 caffe2/operators/elementwise_add_op.cc        |  6 --
 caffe2/operators/elementwise_div_op.cc        |  2 -
 caffe2/operators/elementwise_mul_op.cc        |  2 -
 caffe2/operators/elementwise_sub_op.cc        |  2 -
 caffe2/operators/log_op.cc                    |  4 --
 caffe2/operators/tanh_op.cc                   | 55 -------------------
 caffe2/opt/converter.cc                       | 29 +---------
 9 files changed, 1 insertion(+), 123 deletions(-)

diff --git a/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h b/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
index 9731d048a31fa..9a39ab2405cf5 100644
--- a/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
+++ b/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
@@ -14,24 +14,6 @@
 #include <functional>
 #include <list>
 
-// These #defines are useful when writing passes as the collapse
-//
-// if (!cond) {
-//   continue; // or break; or return;
-// }
-//
-// into a single line without negation
-
-#define NOM_REQUIRE_OR_(_cond, _expr) \
-  if (!(_cond)) {                     \
-    _expr;                            \
-  }
-
-#define NOM_REQUIRE_OR_CONT(_cond) NOM_REQUIRE_OR_(_cond, continue)
-#define NOM_REQUIRE_OR_BREAK(_cond) NOM_REQUIRE_OR_(_cond, break)
-#define NOM_REQUIRE_OR_RET_NULL(_cond) NOM_REQUIRE_OR_(_cond, return nullptr)
-#define NOM_REQUIRE_OR_RET(_cond) NOM_REQUIRE_OR_(_cond, return )
-
 // Implements accessors for a generic type T. If the type is not
 // specified (i.e., void template type) then the partial specification
 // gives an empty type.
diff --git a/caffe2/core/nomnigraph/ops.def b/caffe2/core/nomnigraph/ops.def
index 9182c80fbd76b..6240ff2b04391 100644
--- a/caffe2/core/nomnigraph/ops.def
+++ b/caffe2/core/nomnigraph/ops.def
@@ -55,8 +55,6 @@ BatchNormalization
 FC
 GivenTensorFill
 Concat
-- Axis : int : -1
-- AddAxis : bool : false
 Softmax
 ChannelShuffle
 Add
@@ -83,7 +81,3 @@ Int8ConvRelu : ConvRelu
 Int8SumRelu : SumRelu
 Int8AveragePoolRelu : AveragePoolRelu
 Int8MaxPoolRelu : MaxPoolRelu
-
-BatchMatMul
-BatchGather
-ConcatBatchMatMulBatchGatherOp
diff --git a/caffe2/operators/elementwise_add_op.cc b/caffe2/operators/elementwise_add_op.cc
index 0413da5e03418..849006a3bb32b 100644
--- a/caffe2/operators/elementwise_add_op.cc
+++ b/caffe2/operators/elementwise_add_op.cc
@@ -6,10 +6,4 @@ REGISTER_CPU_OPERATOR(
     Add,
     BinaryElementwiseOp<NumericTypes, CPUContext, AddFunctor<CPUContext>>);
 
-} // namespace
-
-REGISTER_GRADIENT(Add, GetAddGradient);
-
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_div_op.cc b/caffe2/operators/elementwise_div_op.cc
index fd9cf4f4ba5f2..73f0b23f7d1da 100644
--- a/caffe2/operators/elementwise_div_op.cc
+++ b/caffe2/operators/elementwise_div_op.cc
@@ -7,6 +7,4 @@ REGISTER_CPU_OPERATOR(
     Div,
     BinaryElementwiseOp<NumericTypes, CPUContext, DivFunctor<CPUContext>>);
 
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_mul_op.cc b/caffe2/operators/elementwise_mul_op.cc
index 52f740b11f69c..a55112a4b7c46 100644
--- a/caffe2/operators/elementwise_mul_op.cc
+++ b/caffe2/operators/elementwise_mul_op.cc
@@ -6,6 +6,4 @@ REGISTER_CPU_OPERATOR(
     Mul,
     BinaryElementwiseOp<NumericTypes, CPUContext, MulFunctor<CPUContext>>);
 
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_sub_op.cc b/caffe2/operators/elementwise_sub_op.cc
index 299c46640c763..f906883a183bf 100644
--- a/caffe2/operators/elementwise_sub_op.cc
+++ b/caffe2/operators/elementwise_sub_op.cc
@@ -6,6 +6,4 @@ REGISTER_CPU_OPERATOR(
     Sub,
     BinaryElementwiseOp<NumericTypes, CPUContext, SubFunctor<CPUContext>>);
 
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/log_op.cc b/caffe2/operators/log_op.cc
index 28be919e9246e..68e95e6f25ffb 100644
--- a/caffe2/operators/log_op.cc
+++ b/caffe2/operators/log_op.cc
@@ -9,8 +9,6 @@ REGISTER_CPU_OPERATOR(
     Log,
     UnaryElementwiseOp<TensorTypes<float>, CPUContext, LogFunctor<CPUContext>>);
 
-#if !CAFFE2_MOBILE
-
 OPERATOR_SCHEMA(Log)
     .NumInputs(1)
     .NumOutputs(1)
@@ -46,6 +44,4 @@ class GetLogGradient : public GradientMakerBase {
 
 REGISTER_GRADIENT(Log, GetLogGradient);
 
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/tanh_op.cc b/caffe2/operators/tanh_op.cc
index d6a1b08a60c8b..69682256cdd49 100644
--- a/caffe2/operators/tanh_op.cc
+++ b/caffe2/operators/tanh_op.cc
@@ -18,48 +18,12 @@ bool TanhFunctor<CPUContext>::operator()<float>(
   return true;
 }
 
-<<<<<<< HEAD
-=======
-#if !CAFFE2_MOBILE
-
-template <>
-template <typename T>
-bool TanhGradientFunctor<CPUContext>::Forward(
-    const std::vector<int>& dY_dims,
-    const std::vector<int>& /* Y_dims */,
-    const T* dY,
-    const T* Y,
-    T* dX,
-    CPUContext* /* context */) const {
-  const int size = std::accumulate(
-      dY_dims.cbegin(), dY_dims.cend(), 1, std::multiplies<int>());
-  ConstEigenVectorArrayMap<T> dY_arr(dY, size);
-  ConstEigenVectorArrayMap<T> Y_arr(Y, size);
-  EigenVectorMap<T>(dX, size) = dY_arr * (1 - Y_arr * Y_arr);
-  return true;
-}
-
-#endif // !CAFFE2_MOBILE
-
->>>>>>> 8ac1a59... Support advanced pooling options in sum processor
 REGISTER_CPU_OPERATOR(
     Tanh,
     UnaryElementwiseOp<
         TensorTypes<float>,
         CPUContext,
         TanhFunctor<CPUContext>>);
-<<<<<<< HEAD
-=======
-
-#if !CAFFE2_MOBILE
-
-REGISTER_CPU_OPERATOR(
-    TanhGradient,
-    BinaryElementwiseOp<
-        TensorTypes<float>,
-        CPUContext,
-        TanhGradientFunctor<CPUContext>>);
->>>>>>> 8ac1a59... Support advanced pooling options in sum processor
 
 OPERATOR_SCHEMA(Tanh)
     .NumInputs(1)
@@ -129,23 +93,4 @@ print("X:\n", workspace.FetchBlob("X"))
 
 OPERATOR_SCHEMA(TanhGradient).NumInputs(2).NumOutputs(1).AllowInplace({{0, 0}});
 
-namespace {
-
-class GetTanhGradient : public GradientMakerBase {
-  using GradientMakerBase::GradientMakerBase;
-  std::vector<OperatorDef> GetGradientDefs() override {
-    return SingleGradientDef(
-        "TanhGradient",
-        "",
-        std::vector<std::string>{GO(0), O(0)},
-        std::vector<std::string>{GI(0)});
-  }
-};
-
-} // namespace
-
-REGISTER_GRADIENT(Tanh, GetTanhGradient);
-
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/opt/converter.cc b/caffe2/opt/converter.cc
index 33700204625a8..08f4ce9ae2ed2 100644
--- a/caffe2/opt/converter.cc
+++ b/caffe2/opt/converter.cc
@@ -128,33 +128,6 @@ convertToOperatorDef(caffe2::OperatorDef op) {
     nnOp = util::make_unique<repr::BatchNormalization>();
   }
 
-  if (op.type() == "Concat") {
-    nnOp = util::make_unique<repr::Concat>();
-    auto c = dyn_cast<repr::Concat>(nnOp.get());
-    if (argMap.count("axis")) {
-      assert(argMap["axis"].has_i() && "Invalid axis argument");
-      int axis = static_cast<int>(argMap["axis"].i());
-      c->setAxis(axis);
-    }
-    if (argMap.count("add_axis")) {
-      assert(argMap["add_axis"].has_i() && "Invalid add_axis argument");
-      int add_axis = static_cast<int>(argMap["add_axis"].i());
-      c->setAddAxis(!!add_axis);
-    }
-  }
-
-  if (op.type() == "Flatten") {
-    nnOp = util::make_unique<repr::Flatten>();
-  }
-
-  if (op.type() == "BatchGather") {
-    nnOp = util::make_unique<repr::BatchGather>();
-  }
-
-  if (op.type() == "BatchMatMul") {
-    nnOp = util::make_unique<repr::BatchMatMul>();
-  }
-
   if (!nnOp) {
     nnOp = util::make_unique<repr::GenericOperator>(op.type());
   }
@@ -514,4 +487,4 @@ caffe2::NetDef convertToCaffe2Proto(repr::NNModule &m, const caffe2::NetDef& old
   return predictNet;
 }
 
-} // namespace caffe2
+} // namespace caffe2 

From 68235c58dd258ab74261cb93670cbed83a65735a Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 12:04:09 -0700
Subject: [PATCH 038/118] Remove Declarations.yaml

---
 aten/src/ATen/Declarations.yaml | 32527 ------------------------------
 1 file changed, 32527 deletions(-)
 delete mode 100644 aten/src/ATen/Declarations.yaml

diff --git a/aten/src/ATen/Declarations.yaml b/aten/src/ATen/Declarations.yaml
deleted file mode 100644
index 71715505f9d59..0000000000000
--- a/aten/src/ATen/Declarations.yaml
+++ /dev/null
@@ -1,32527 +0,0 @@
-- name: storage_offset
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: resize_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: numel
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: set_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Storage
-    name: storage
-    type: Storage &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: set_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Storage
-    name: sourceStorage
-    type: Storage &
-  - dynamic_type: int64_t
-    name: storage_offset
-    type: int64_t
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: IntList
-    name: stride
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: set_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: set_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: _fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: value
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: is_contiguous
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: is_set_to
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: masked_fill_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  - dynamic_type: real
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: masked_fill_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: value
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: masked_scatter_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: masked_select_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: masked_select
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nonzero_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nonzero
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: contiguous
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clone
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: view
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: resize_as_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: the_template
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_select_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_select
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _indexCopy_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: take_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: take
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: put_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: accumulate
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_add_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: real
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: value
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: unfold
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dimension
-    type: int64_t
-  - dynamic_type: int64_t
-    name: size
-    type: int64_t
-  - dynamic_type: int64_t
-    name: step
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: _range_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: accreal
-    name: start
-    type: Scalar
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _range
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: accreal
-    name: start
-    type: Scalar
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _arange_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: accreal
-    name: start
-    type: Scalar
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _arange
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: accreal
-    name: start
-    type: Scalar
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _arange_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _arange
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: scatter_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: src
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: scatter_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: real
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: scatter_add_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: src
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gather_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gather
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: data_ptr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: void*
-    name: result
-    type: void*
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: true
-- name: equal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __and___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __and__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __and___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __and__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __iand__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __iand__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __or___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __or__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __or___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __or__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ior__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ior__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __xor___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __xor__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __xor___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __xor__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ixor__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ixor__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __lshift___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __lshift__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __lshift___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __lshift__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ilshift__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ilshift__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __rshift___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __rshift__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __rshift___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __rshift__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __irshift__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __irshift__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: min
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: min_indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: min
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: min_indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: min
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: min_indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: max
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: max_indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: max
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: max_indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: max
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: max_indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kthvalue_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: k
-    type: int64_t
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kthvalue
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: k
-    type: int64_t
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mode_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mode
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: median_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: median
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: median
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sort_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: descending
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sort
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: descending
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: topk_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: k
-    type: int64_t
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: largest
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: sorted
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: topk
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: k
-    type: int64_t
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: largest
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: sorted
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: all_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: all
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: all
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: any_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: any
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: any
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: get_device
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _abs_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _abs
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sigmoid_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sigmoid_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sigmoid
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log10_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log10
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log1p_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log1p
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log2_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log2
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lgamma_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lgamma
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lgamma_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: digamma_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: digamma
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: digamma_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: polygamma_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: n
-    type: int64_t
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: polygamma
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: int64_t
-    name: n
-    type: int64_t
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: polygamma_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: n
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _exp_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _exp
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _expm1_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _expm1
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cos_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cos
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _acos_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _acos
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cosh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cosh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sin_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _asin_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _asin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sinh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sinh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tan_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tan
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _atan_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _atan
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_tanh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_tanh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _erf_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _erf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: erfinv_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: erfinv_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: erfinv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sqrt_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sqrt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _rsqrt_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _rsqrt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _ceil_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _ceil
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _floor_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _floor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _round_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _round
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _trunc_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _trunc
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: frac_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: frac_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: frac
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mean_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mean
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mean
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: var_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: var
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: var
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: std_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: std
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: std
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: norm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: p
-    python_default_init: 2
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: p
-    python_default_init: 2
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 2
-    default_init: 2
-    dynamic_type: real
-    name: p
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: renorm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: p
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: real
-    name: maxnorm
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: renorm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: p
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: real
-    name: maxnorm
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: renorm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: p
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: real
-    name: maxnorm
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: dist
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 2
-    default_init: 2
-    dynamic_type: real
-    name: p
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reciprocal_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reciprocal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reciprocal_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: neg_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: neg
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: neg_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan2_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan2
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan2_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: exponent
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: exponent
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: exponent
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: exponent
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: real
-    name: base
-    type: Scalar
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: real
-    name: base
-    type: Scalar
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: exponent
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: exponent
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lerp_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: end
-    type: const Tensor &
-  - dynamic_type: real
-    name: weight
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lerp
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: end
-    type: const Tensor &
-  - dynamic_type: real
-    name: weight
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lerp_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: end
-    type: const Tensor &
-  - dynamic_type: real
-    name: weight
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _linspace_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: real
-    name: start
-    type: Scalar
-  - dynamic_type: real
-    name: end
-    type: Scalar
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _linspace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: real
-    name: start
-    type: Scalar
-  - dynamic_type: real
-    name: end
-    type: Scalar
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _logspace_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: real
-    name: start
-    type: Scalar
-  - dynamic_type: real
-    name: end
-    type: Scalar
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _logspace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: real
-    name: start
-    type: Scalar
-  - dynamic_type: real
-    name: end
-    type: Scalar
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: histc_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: bins
-    type: int64_t
-  - default: 0
-    default_init: 0
-    dynamic_type: real
-    name: min
-    type: Scalar
-  - default: 0
-    default_init: 0
-    dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: histc
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: bins
-    type: int64_t
-  - default: 0
-    default_init: 0
-    dynamic_type: real
-    name: min
-    type: Scalar
-  - default: 0
-    default_init: 0
-    dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: zero_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sumall
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_sum_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _prodall
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_prod_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cumsum_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cumsum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cumprod_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cumprod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sign_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sign
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sign_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: trace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: other
-    type: SparseTensor
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: other
-    type: SparseTensor
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: SparseTensor
-    name: other
-    type: SparseTensor
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_min_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_min
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_min_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_max_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_max
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_max_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dot
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tril_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tril
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tril_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: triu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: triu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: triu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cross_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cross
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: diag_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: diag
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: mat1
-    type: SparseTensor
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: mat1
-    type: SparseTensor
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: SparseTensor
-    name: mat1
-    type: SparseTensor
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addmv_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addmv
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addmv_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addr_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addr
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addr_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _ger_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _ger
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _mv_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _mv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _mm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _mm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: bmm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: bmm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addbmm_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addbmm
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addbmm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: baddbmm_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: baddbmm
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: baddbmm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcmul_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcmul
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcmul_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcdiv_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcdiv
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcdiv_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _gesv_single_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: solution
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: lu
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: solution
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: lu
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _gesv_single
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: solution
-    type: Tensor
-  - dynamic_type: Tensor
-    name: lu
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gels_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gels
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: trtrs_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: transpose
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: unitriangular
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: trtrs
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: transpose
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: unitriangular
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: symeig_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: eigenvectors
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: symeig
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: eigenvectors
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eig_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: eigenvectors
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eig
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: eigenvectors
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: svd_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res3
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: some
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res3
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: svd
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: some
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res3
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: inverse_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: inverse
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potrf_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potrf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potrs_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potrs
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potri_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potri
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pstrf_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  - default: -1
-    default_init: -1
-    dynamic_type: real
-    name: tol
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pstrf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  - default: -1
-    default_init: -1
-    dynamic_type: real
-    name: tol
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: IntegerTensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: qr_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: qr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: geqrf_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: geqrf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: orgqr_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: orgqr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ormqr_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input3
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: left
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: transpose
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ormqr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input3
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: left
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: transpose
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrifact_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: pivots
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    kwarg_only: true
-    name: pivot
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: pivots
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrifact
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    kwarg_only: true
-    name: pivot
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  - dynamic_type: IntegerTensor
-    name: pivots
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrifact_with_info_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: pivots
-    output: true
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: info
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    kwarg_only: true
-    name: pivot
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: pivots
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: info
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrifact_with_info
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    kwarg_only: true
-    name: pivot
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  - dynamic_type: IntegerTensor
-    name: pivots
-    type: Tensor
-  - dynamic_type: IntegerTensor
-    name: info
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrisolve_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: LU_data
-    type: const Tensor &
-  - dynamic_type: IntegerTensor
-    name: LU_pivots
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrisolve
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: LU_data
-    type: const Tensor &
-  - dynamic_type: IntegerTensor
-    name: LU_pivots
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: random_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: from
-    type: int64_t
-  - dynamic_type: int64_t
-    name: to
-    type: int64_t
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: random_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: to
-    type: int64_t
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: random_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multinomial_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: num_samples
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: replacement
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multinomial
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: num_samples
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: replacement
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: uniform_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: double
-    name: from
-    type: double
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: to
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mean
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: std
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: mean
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: std
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: double
-    name: mean
-    type: double
-  - dynamic_type: Tensor
-    name: std
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: double
-    name: mean
-    type: double
-  - dynamic_type: Tensor
-    name: std
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: std
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: std
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: double
-    name: mean
-    type: double
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: std
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cauchy_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: double
-    name: median
-    type: double
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: sigma
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_normal_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: mean
-    type: double
-  - default: 2
-    default_init: 2
-    dynamic_type: double
-    name: std
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: exponential_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: lambd
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: geometric_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: double
-    name: p
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_bernoulli_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_bernoulli
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dirichlet_grad_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: x
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: alpha
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: total
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dirichlet_grad
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: x
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: alpha
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: total
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Storage
-    name: storage
-    type: Storage &
-  - dynamic_type: int64_t
-    name: storageOffset
-    type: int64_t
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: IntList
-    name: stride
-    type: IntList
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    type: IntList
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tensor
-  method_prefix_derived: ''
-  arguments: []
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sparse_coo_tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: values
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sparse_coo_tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: values
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: alias
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sparse_coo_tensor_unsafe
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: values
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _copy_ignoring_overlaps_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: src
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: as_strided_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    type: IntList
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: storage_offset
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: as_strided
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    type: IntList
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: storage_offset
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: as_strided_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    type: IntList
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: storage_offset
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sparse_raw_resize_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: int64_t
-    name: nDimI
-    type: int64_t
-  - dynamic_type: int64_t
-    name: nDimV
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cat_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    output: true
-    type: Tensor &
-  - dynamic_type: TensorList
-    name: tensors
-    type: TensorList
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cat
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: TensorList
-    name: tensors
-    type: TensorList
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sparse_mask
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: mask
-    type: SparseTensor
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: SparseTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: to_dense
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dimI
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dimV
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _nnz
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: coalesce
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: is_coalesced
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _indices
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _values
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hspmm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hspmm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: kl_div
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: p
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: p
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: p
-    type: Scalar
-  - dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: p
-    type: Scalar
-  - dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: p
-    type: Scalar
-  - dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: p
-    type: Scalar
-  - dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - is_target
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - is_target
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: is_target
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: is_target
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: is_target
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: is_target
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: is_target
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: -100
-    default_init: -100
-    dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - total_weight
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: -100
-    default_init: -100
-    dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - total_weight
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: total_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: total_weight
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: total_weight
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: total_weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: total_weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: -100
-    default_init: -100
-    dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - total_weight
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: -100
-    default_init: -100
-    dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - total_weight
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: total_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: total_weight
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: total_weight
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: total_weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: total_weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: elu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: elu_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: elu_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: glu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: glu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: glu_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: glu_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: glu_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: glu_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.5
-    default_init: 0.5
-    dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.5
-    default_init: 0.5
-    dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.01
-    default_init: 0.01
-    dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.01
-    default_init: 0.01
-    dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0.01
-    default_init: 0.01
-    dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - buffer
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - buffer
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: buffer
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: buffer
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: buffer
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: buffer
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: buffer
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prelu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prelu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prelu_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prelu_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prelu_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prelu_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: '{{true, true}}'
-    default_init: '{{true, true}}'
-    dynamic_type: std::array<bool,2>
-    name: output_mask
-    type: std::array<bool,2>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - default: 0.125
-    default_init: 0.125
-    dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    default_init: 0.3333333333333333
-    dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: training
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - default: 0.125
-    default_init: 0.125
-    dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    default_init: 0.3333333333333333
-    dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: training
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - default: 0.125
-    default_init: 0.125
-    dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    default_init: 0.3333333333333333
-    dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: training
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softplus_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - default: 20
-    default_init: 20
-    dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softplus
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - default: 20
-    default_init: 20
-    dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softplus_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softplus_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softplus_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softplus_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.5
-    default_init: 0.5
-    dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softshrink
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.5
-    default_init: 0.5
-    dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: threshold
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: threshold_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: threshold_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: random_samples
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: random_samples
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: random_samples
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: random_samples
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 4
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 4
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 5
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 5
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _tanh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: momentum
-    type: double
-  - dynamic_type: double
-    name: eps
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - save_mean
-  - save_std
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: momentum
-    type: double
-  - dynamic_type: double
-    name: eps
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - save_mean
-  - save_std
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: save_mean
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: save_std
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: momentum
-    type: double
-  - dynamic_type: double
-    name: eps
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: save_mean
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: save_std
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: momentum
-    type: double
-  - dynamic_type: double
-    name: eps
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: save_mean
-    type: Tensor
-  - dynamic_type: Tensor
-    name: save_std
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: eps
-    type: double
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_std
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: eps
-    type: double
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_std
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - default: '{{true, true}}'
-    default_init: '{{true, true}}'
-    dynamic_type: std::array<bool,2>
-    name: output_mask
-    type: std::array<bool,2>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Byte
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Char
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Double
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Float
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Int
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Long
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Short
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Half
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cudnn_rnn_flatten_weight
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: weight_arr
-    type: TensorList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: weight_stride0
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: input_size
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: hidden_size
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_layers
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: batch_first
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: bidirectional
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cudnn_rnn
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: weight
-    type: TensorList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: weight_stride0
-    type: int64_t
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight_buf
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: hx
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: cx
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: hidden_size
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_layers
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: batch_first
-    type: bool
-  - dynamic_type: double
-    is_nullable: false
-    name: dropout
-    type: double
-  - dynamic_type: bool
-    is_nullable: false
-    name: train
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: bidirectional
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: batch_sizes
-    type: IntList
-  - dynamic_type: BoolTensor
-    is_nullable: true
-    name: dropout_state
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result3
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result4
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cudnn_rnn_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: weight
-    type: TensorList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: weight_stride0
-    type: int64_t
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight_buf
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: hx
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: cx
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_hy
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_cy
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: hidden_size
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_layers
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: batch_first
-    type: bool
-  - dynamic_type: double
-    is_nullable: false
-    name: dropout
-    type: double
-  - dynamic_type: bool
-    is_nullable: false
-    name: train
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: bidirectional
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: batch_sizes
-    type: IntList
-  - dynamic_type: BoolTensor
-    is_nullable: true
-    name: dropout_state
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: reserve
-    type: const Tensor &
-  - dynamic_type: std::array<bool,4>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,4>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  - dynamic_type: TensorList
-    name: result3
-    type: std::vector<Tensor>
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cudnn_init_dropout_state
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: self_ty
-    type: const Type &
-  - dynamic_type: double
-    is_nullable: false
-    name: dropout
-    type: double
-  - dynamic_type: bool
-    is_nullable: false
-    name: train
-    type: bool
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dropout_seed
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: abs
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: abs_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: abs_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: acos
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: acos_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: acos_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_size
-    size: 1
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_size
-    size: 1
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: allclose
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  - default: 1.0e-05
-    dynamic_type: double
-    is_nullable: false
-    name: rtol
-    type: double
-  - default: 1.0e-08
-    dynamic_type: double
-    is_nullable: false
-    name: atol
-    type: double
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: equal_nan
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addmv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addmv_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addmv_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addr_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addr_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: arange
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: arange_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: arange
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: arange_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: argmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: argmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _argmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: argmin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: argmin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _argmin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: asin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: asin_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: asin_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: atan_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: batch_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    is_nullable: false
-    name: training
-    type: bool
-  - dynamic_type: double
-    is_nullable: false
-    name: momentum
-    type: double
-  - dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enabled
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: p
-    type: const Tensor &
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: double
-    is_nullable: false
-    name: p
-    type: double
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: p
-    type: const Tensor &
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: double
-    is_nullable: false
-    name: p
-    type: double
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bilinear
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cat
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cat_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ceil
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ceil_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ceil_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: chunk
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: chunks
-    type: int64_t
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: TensorList
-    name: result
-    type: std::vector<Tensor>
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_is_acceptable
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: convolution
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: transposed
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _convolution
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: transposed
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enabled
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _convolution_nogroup
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: transposed
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _convolution_double_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: ggI
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: ggW
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: ggb
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: gO
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: transposed
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enabled
-    type: bool
-  - dynamic_type: std::array<bool,3>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 1
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 1
-    type: IntList
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 1
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 2
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 2
-    type: IntList
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 2
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 3
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 3
-    type: IntList
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 3
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_tbc
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pad
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_tbc_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pad
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_transpose1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 1
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 1
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    size: 1
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 1
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_transpose2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 2
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 2
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    size: 2
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_transpose3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 3
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 3
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    size: 3
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cos
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cos_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cos_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cosh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cosh_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cosh_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cosine_embedding_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: target
-    type: const Tensor &
-  - default: 0.0
-    dynamic_type: double
-    is_nullable: false
-    name: margin
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: size_average
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_affine_grid_generator
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: theta
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: N
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: C
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: H
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: W
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: grid
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_affine_grid_generator_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: N
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: C
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: H
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: W
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: grad_theta
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_batch_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    is_nullable: false
-    name: training
-    type: bool
-  - dynamic_type: double
-    is_nullable: false
-    name: exponential_average_factor
-    type: double
-  - dynamic_type: double
-    is_nullable: false
-    name: epsilon
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_batch_norm_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_var
-    type: const Tensor &
-  - dynamic_type: double
-    is_nullable: false
-    name: epsilon
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_backward_input
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: self_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  - dynamic_type: std::array<bool,3>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_backward_bias
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_backward_weight
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: weight_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  - dynamic_type: std::array<bool,3>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose_backward_bias
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose_backward_input
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose_backward_weight
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: weight_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_grid_sampler
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grid
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_grid_sampler_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grid
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: grad_self
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_grid
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cumsum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumsum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumsum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumsum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumprod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumprod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumprod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumprod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: det
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: diagflat
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: offset
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: diagonal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: offset
-    type: int64_t
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim1
-    type: int64_t
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim2
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: dot
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: tensor
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: dot_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: tensor
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: einsum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: std::string
-    is_nullable: false
-    name: equation
-    type: std::string
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - default: -1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: padding_idx
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: sparse
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: padding_idx
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: sparse
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_dense_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: padding_idx
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: embedding_renorm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: double
-    is_nullable: false
-    name: max_norm
-    type: double
-  - dynamic_type: double
-    is_nullable: false
-    name: norm_type
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: embedding_sparse_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: padding_idx
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_bag
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offsets
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: sparse
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result3
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: embedding_bag_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offsets
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offset2bag
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: bag_size
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: maximum_indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: sparse
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_bag_sparse_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offsets
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offset2bag
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: bag_size
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_bag_dense_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offsets
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offset2bag
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: bag_size
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: maximum_indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: empty
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: empty_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: empty_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: empty_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: erf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: erf_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: erf_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: exp
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: exp_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: exp_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: expm1
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: expm1_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: expm1_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: expand
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    kwarg_only: true
-    name: implicit
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: expand_as
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: eye
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: n
-    type: int64_t
-  - default: -1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: m
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: eye_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: n
-    type: int64_t
-  - default: -1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: m
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: value
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: floor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: floor_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: floor_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: full
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: fill_value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: full_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: fill_value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: full_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: fill_value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: full_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: fill_value
-    type: Scalar
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hinge_embedding_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: target
-    type: const Tensor &
-  - default: 1.0
-    dynamic_type: double
-    is_nullable: false
-    name: margin
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: size_average
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ger
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ger_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: gesv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: gesv_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: solution
-    output: true
-    type: Tensor &
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: lu
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _gesv_helper
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: group_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_groups
-    type: int64_t
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - default: 1.0e-05
-    dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enabled
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: fft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ifft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rfft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: onesided
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: irfft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: onesided
-    type: bool
-  - default: '{}'
-    dynamic_type: IntList
-    is_nullable: false
-    name: signal_sizes
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _fft_with_size
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: complex_input
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: complex_output
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: inverse
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: checked_signal_sizes
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: onesided
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_sizes
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: indices
-    type: TensorList
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: index_copy_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: index_put_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: indices
-    type: TensorList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: values
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: isclose
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  - default: 1.0e-05
-    dynamic_type: double
-    is_nullable: false
-    name: rtol
-    type: double
-  - default: 1.0e-08
-    dynamic_type: double
-    is_nullable: false
-    name: atol
-    type: double
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: equal_nan
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_cuda
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_distributed
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_floating_point
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_nonzero
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_same_size
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_signed
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_sparse
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: layer_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: normalized_shape
-    type: IntList
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - default: 1.0e-05
-    dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enable
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: linspace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 100
-    dynamic_type: int64_t
-    is_nullable: false
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: linspace_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 100
-    dynamic_type: int64_t
-    is_nullable: false
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log10
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log10_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log10_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log1p
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log1p_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log1p_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log2
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log2_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log2_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: logdet
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: logspace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 100
-    dynamic_type: int64_t
-    is_nullable: false
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: logspace_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 100
-    dynamic_type: int64_t
-    is_nullable: false
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log_softmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_softmax_backward_data
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: output
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: logsumexp
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: logsumexp_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: margin_ranking_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: target
-    type: const Tensor &
-  - default: 0.0
-    dynamic_type: double
-    is_nullable: false
-    name: margin
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: size_average
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: matmul
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: matmul_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_values
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: kernel_size
-    size: 1
-    type: IntList
-  - default: '{}'
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 1
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 1
-    type: IntList
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: min_values
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mkldnn_convolution
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mkldnn_convolution_backward_input
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: self_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: bias_defined
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mkldnn_convolution_backward_weights
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: weight_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: bias_defined
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mkldnn_convolution_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: std::array<bool,3>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mm_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mv_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: narrow
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: start
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: length
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ones
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ones_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ones_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ones_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: pairwise_distance
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: x1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: x2
-    type: const Tensor &
-  - default: 2
-    dynamic_type: double
-    is_nullable: false
-    name: p
-    type: double
-  - default: 1.0e-06
-    dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: permute
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dims
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: pin_memory
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rand
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rand_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rand_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rand_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: low
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: low
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: low
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: low
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randn
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randn_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randn_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randn_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randperm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: n
-    type: int64_t
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randperm_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: n
-    type: int64_t
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: range
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: range_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: repeat
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: repeats
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reshape
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: shape
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: RoiPooling2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: rois
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pooledHeight
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pooledWidth
-    type: int64_t
-  - dynamic_type: double
-    is_nullable: false
-    name: spatialScale
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: RoiPooling2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: rois
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pooledHeight
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pooledWidth
-    type: int64_t
-  - dynamic_type: double
-    is_nullable: false
-    name: spatialScale
-    type: double
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: gradOutput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: argmaxes
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: round
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: round_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: round_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: 0.125
-    dynamic_type: Scalar
-    is_nullable: false
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    dynamic_type: Scalar
-    is_nullable: false
-    name: upper
-    type: Scalar
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: training
-    type: bool
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - default: 0.125
-    dynamic_type: Scalar
-    is_nullable: false
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    dynamic_type: Scalar
-    is_nullable: false
-    name: upper
-    type: Scalar
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: training
-    type: bool
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: relu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: relu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rsqrt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rsqrt_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rsqrt_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: select
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: index
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: selu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: selu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sin_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sin_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sinh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sinh_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sinh_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: size
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: slice
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: start
-    type: int64_t
-  - default: 9223372036854775807
-    dynamic_type: int64_t
-    is_nullable: false
-    name: end
-    type: int64_t
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: step
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: slogdet
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: smm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softmax_backward_data
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: output
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: split
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: split_size
-    type: int64_t
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: TensorList
-    name: result
-    type: std::vector<Tensor>
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: split_with_sizes
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: split_sizes
-    type: IntList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: TensorList
-    name: result
-    type: std::vector<Tensor>
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: squeeze
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: squeeze
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: squeeze_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: squeeze_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sspaddmm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sspaddmm_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: stack
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: stack_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: stft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: frame_length
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: hop
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: fft_size
-    python_default_init: frame_length
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: onesided
-    type: bool
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: window
-    type: const Tensor &
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: pad_end
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: stride
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sum_cuda_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sqrt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sqrt_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sqrt_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _prod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: t
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: t_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: tan
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: tan_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tan_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tanh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: tanh_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tanh_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: transpose
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim0
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim1
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: transpose_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim0
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim1
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _trilinear
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: i1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: i2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: i3
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: expand1
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: expand2
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: expand3
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: sumdim
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: unroll_dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: triplet_margin_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: anchor
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: positive
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: negative
-    type: const Tensor &
-  - default: 1.0
-    dynamic_type: double
-    is_nullable: false
-    name: margin
-    type: double
-  - default: 2
-    dynamic_type: double
-    is_nullable: false
-    name: p
-    type: double
-  - default: 1.0e-06
-    dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: swap
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: size_average
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: trunc
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: trunc_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: trunc_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: type_as
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _unique
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: sorted
-    type: bool
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: return_inverse
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _unsafe_view
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: unsqueeze
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: unsqueeze_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: view_as
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: where
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    is_nullable: false
-    name: condition
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _s_where
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    is_nullable: false
-    name: condition
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: zeros
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: zeros_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: zeros_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: zeros_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _standard_gamma_grad
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _standard_gamma
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: poisson
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false

From 96ba36fd99a65a1d51d86d25fd38d2dc268db391 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 16:06:08 -0700
Subject: [PATCH 039/118] Include common.h

---
 caffe2/core/net_async_tracing.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/caffe2/core/net_async_tracing.cc b/caffe2/core/net_async_tracing.cc
index b2c4a1952b785..d9093e985391a 100644
--- a/caffe2/core/net_async_tracing.cc
+++ b/caffe2/core/net_async_tracing.cc
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "caffe2/core/common.h"
 #include "caffe2/core/net_async_tracing.h"
 
 #include "caffe2/utils/string_utils.h"

From c00043963da268783e5fb966f52ea9bb49e8253a Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 16:17:44 -0700
Subject: [PATCH 040/118] Change std::stoi to caffe2::stoi

---
 caffe2/core/net_async_tracing.cc | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/caffe2/core/net_async_tracing.cc b/caffe2/core/net_async_tracing.cc
index d9093e985391a..b19acb653dad0 100644
--- a/caffe2/core/net_async_tracing.cc
+++ b/caffe2/core/net_async_tracing.cc
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include "caffe2/core/common.h"
 #include "caffe2/core/net_async_tracing.h"
 
 #include "caffe2/utils/string_utils.h"
@@ -323,7 +322,7 @@ int extractShardId(const std::string& name) {
     while (right_pos < name.length() && isdigit(name[right_pos])) {
       right_pos++;
     }
-    return std::stoi(name.substr(left_pos, right_pos - left_pos));
+    return caffe2::stoi(name.substr(left_pos, right_pos - left_pos));
   } else {
     return -1;
   }

From d0c0a5065a11c7f52f5a51c8bb467231bf3e9e40 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 16:31:17 -0700
Subject: [PATCH 041/118] Add thread_name.cc to the CMake file

---
 caffe2/utils/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/caffe2/utils/CMakeLists.txt b/caffe2/utils/CMakeLists.txt
index 90d853c0e7da8..d774caceb4e19 100644
--- a/caffe2/utils/CMakeLists.txt
+++ b/caffe2/utils/CMakeLists.txt
@@ -9,6 +9,7 @@ set(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS}
         utils/bench_utils.cc
         utils/math_cpu.cc
         utils/math_utils.cc
+        utils/thread_name.cc
         )
 
 # ---[ threadpool/pthreadpool* is a local modification of the NNPACK

From cffc7d1f0bb373b81800c7d67dce5f8d33d25075 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 19:37:42 -0700
Subject: [PATCH 042/118] No need to subtract 1. Fix test segfaults

---
 caffe2/core/net.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/caffe2/core/net.cc b/caffe2/core/net.cc
index 19f1c4798c717..dfca11318669e 100644
--- a/caffe2/core/net.cc
+++ b/caffe2/core/net.cc
@@ -122,7 +122,7 @@ void checkExecutorOverride(std::string& net_type) {
   for (const auto& kv : defaultOverrides()) {
     overrides[kv.first] = kv.second;
   }
-  for (size_t idx = 0; idx < executors.size() - 1; idx += 2) {
+  for (size_t idx = 0; idx < executors.size(); idx += 2) {
     overrides[executors[idx]] = executors[idx + 1];
   }
   if (overrides.count(net_type)) {

From 77d8473d5293761063efacf45a67dbc308b208aa Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 22:01:46 -0700
Subject: [PATCH 043/118] Fix NetTest, ObserverTest

Fix tests

(cherry picked from commit 3767e66c3f365596cba3d46d3e7322c933a0ab41)
---
 caffe2/core/net_async_base.cc |  6 +++---
 caffe2/core/net_async_base.h  |  5 +++++
 caffe2/core/net_gpu_test.cc   |  2 +-
 caffe2/core/net_test.cc       | 24 ++++++++++--------------
 caffe2/core/observer_test.cc  |  1 -
 5 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/caffe2/core/net_async_base.cc b/caffe2/core/net_async_base.cc
index 89d579aeb4c1d..435b500cc045d 100644
--- a/caffe2/core/net_async_base.cc
+++ b/caffe2/core/net_async_base.cc
@@ -68,9 +68,9 @@ AsyncNetBase::AsyncNetBase(
     operators_.push_back(op_ptr);
   }
 
-  const auto& execution_chains = dag_utils::computeChains(operator_nodes_);
-  chains_.reserve(execution_chains.size());
-  for (const auto& kv : execution_chains) {
+  execution_chains_ = dag_utils::computeChains(operator_nodes_);
+  chains_.reserve(execution_chains_.size());
+  for (const auto& kv : execution_chains_) {
     chains_.push_back(kv.second);
   }
   chain_nodes_ = dag_utils::prepareChainGraphNodes(operator_nodes_, chains_);
diff --git a/caffe2/core/net_async_base.h b/caffe2/core/net_async_base.h
index c7047d2e64162..e93275da1bc03 100644
--- a/caffe2/core/net_async_base.h
+++ b/caffe2/core/net_async_base.h
@@ -48,6 +48,10 @@ class AsyncNetBase : public NetBase {
 
   bool RunAsync() override;
 
+  const dag_utils::ExecutionChains& TEST_execution_chains() const {
+    return execution_chains_;
+  }
+
  protected:
   bool canSchedule(
       int chain_id,
@@ -85,6 +89,7 @@ class AsyncNetBase : public NetBase {
   std::vector<dag_utils::OperatorNode> operator_nodes_;
   std::vector<std::vector<int>> chains_;
   std::vector<dag_utils::OpGraphNode> chain_nodes_; // chains' parents/children
+  dag_utils::ExecutionChains execution_chains_; // for testing
 
   // Pools and streams
   std::mutex pools_mutex_;
diff --git a/caffe2/core/net_gpu_test.cc b/caffe2/core/net_gpu_test.cc
index e093889a6261c..8bc82b53f5b54 100644
--- a/caffe2/core/net_gpu_test.cc
+++ b/caffe2/core/net_gpu_test.cc
@@ -84,7 +84,7 @@ void checkChainingAndRun(
     FLAGS_caffe2_disable_chaining = false;
 
     std::unique_ptr<NetBase> net(CreateNet(net_def, &ws));
-    auto* dag = dynamic_cast_if_rtti<DAGNetBase*>(net.get());
+    auto* dag = dynamic_cast_if_rtti<AsyncNetBase*>(net.get());
     CHECK_NOTNULL(dag);
     const auto& chains = dag->TEST_execution_chains();
     EXPECT_EQ(chains, expected);
diff --git a/caffe2/core/net_test.cc b/caffe2/core/net_test.cc
index ce2252c07189e..ed0b8c49bd3a9 100644
--- a/caffe2/core/net_test.cc
+++ b/caffe2/core/net_test.cc
@@ -155,7 +155,7 @@ void checkChainingAndRun(
     FLAGS_caffe2_disable_chaining = false;
 
     std::unique_ptr<NetBase> net(CreateNet(net_def, &ws));
-    auto* dag = dynamic_cast_if_rtti<DAGNetBase*>(net.get());
+    auto* dag = dynamic_cast_if_rtti<AsyncNetBase*>(net.get());
     CHECK_NOTNULL(dag);
     const auto& chains = dag->TEST_execution_chains();
     EXPECT_TRUE(chains == expected);
@@ -182,7 +182,7 @@ void checkNumChainsAndRun(const char* spec, const int expected_num_chains) {
     FLAGS_caffe2_disable_chaining = false;
 
     std::unique_ptr<NetBase> net(CreateNet(net_def, &ws));
-    auto* dag = dynamic_cast_if_rtti<DAGNetBase*>(net.get());
+    auto* dag = dynamic_cast_if_rtti<AsyncNetBase*>(net.get());
     CHECK_NOTNULL(dag);
     const auto& chains = dag->TEST_execution_chains();
     EXPECT_EQ(expected_num_chains, chains.size());
@@ -579,7 +579,14 @@ TEST(NetTest, FailingOperator) {
     std::unique_ptr<NetBase> net(CreateNet(net_def, &ws));
     for (int i = 0; i < 10; i++) {
       counter.exchange(0);
-      ASSERT_FALSE(net->Run());
+      bool run_result = false;
+      try {
+        run_result = net->Run();
+      } catch (const std::exception&) {
+        // async_scheduling would throw
+      }
+      ASSERT_FALSE(run_result);
+
       ASSERT_EQ(1, counter.load());
     }
   }
@@ -675,17 +682,6 @@ TEST(NetTest, ExecutorOverride) {
   CAFFE_ENFORCE(
       ::google::protobuf::TextFormat::ParseFromString(spec, &net_def));
 
-  {
-    Workspace ws;
-    auto old = FLAGS_caffe2_override_executor;
-    auto g = MakeGuard([&]() { FLAGS_caffe2_override_executor = old; });
-    FLAGS_caffe2_override_executor = "";
-
-    std::unique_ptr<NetBase> net(CreateNet(net_def, &ws));
-    auto dag_net = caffe2::dynamic_cast_if_rtti<DAGNet*>(net.get());
-    ASSERT_TRUE(dag_net != nullptr);
-  }
-
   {
     Workspace ws;
     auto old = FLAGS_caffe2_override_executor;
diff --git a/caffe2/core/observer_test.cc b/caffe2/core/observer_test.cc
index 73baf28b18ba2..f4f4e81a3cb45 100644
--- a/caffe2/core/observer_test.cc
+++ b/caffe2/core/observer_test.cc
@@ -143,7 +143,6 @@ TEST(ObserverTest, TestDAGNetBase) {
   ws.CreateBlob("in");
   NetDef net_def;
   unique_ptr<NetBase> net(CreateNetTestHelper(&ws, true));
-  EXPECT_EQ(caffe2::dynamic_cast_if_rtti<DAGNetBase*>(net.get()), net.get());
   unique_ptr<DummyObserver<NetBase>> net_ob =
       make_unique<DummyObserver<NetBase>>(net.get());
   net.get()->AttachObserver(std::move(net_ob));

From e4bb8002316445c600678f8598dedc98c3a07085 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 23:15:34 -0700
Subject: [PATCH 044/118] CTCGreedyDecoderOp only has CPU implementation, test
 should only run on CPU

---
 caffe2/python/operator_test/ctc_greedy_decoder_op_test.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py b/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py
index 4ae1db3050bc4..632a44d960fc5 100644
--- a/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py
+++ b/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py
@@ -18,7 +18,7 @@ class TestCTCGreedyDecoderOp(hu.HypothesisTestCase):
         max_time=st.sampled_from([2, 10, 30, 50]),
         num_classes=st.sampled_from([2, 10, 26, 40]),
         merge_repeated=st.sampled_from([True, False]),
-        **hu.gcs
+        **hu.gcs_cpu_only
     )
     def test_ctc_greedy_decoder(
         self, batch, max_time,

From 0598dd4153271f70366744a444d9f070a470a734 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Wed, 13 Jun 2018 07:08:10 -0700
Subject: [PATCH 045/118] Add a variable to avoid conversion resizing issue

---
 caffe2/operators/ctc_greedy_decoder_op.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/caffe2/operators/ctc_greedy_decoder_op.cc b/caffe2/operators/ctc_greedy_decoder_op.cc
index 5f9792d651b37..1a9c415aac74b 100644
--- a/caffe2/operators/ctc_greedy_decoder_op.cc
+++ b/caffe2/operators/ctc_greedy_decoder_op.cc
@@ -54,7 +54,8 @@ bool CTCGreedyDecoderOp<CPUContext>::RunOnDevice() {
     output_len_data[i] = t_dec;
   }
 
-  values->Resize(vector<TIndex>{values_cach.size()});
+  int32_t values_cach_size = values_cach.size();
+  values->Resize(vector<TIndex>{values_cach_size});
   int* values_data = values->mutable_data<int>();
   for (int i = 0; i < values_cach.size(); ++i) {
     values_data[i] = values_cach.at(i);

From 49f6f05b95bf65740f949da0f7dfc09d08d81cec Mon Sep 17 00:00:00 2001
From: Bram Wasti <bwasti@fb.com>
Date: Tue, 12 Jun 2018 09:50:48 -0700
Subject: [PATCH 046/118] [fix] fixup the bias multiplier data access issue

Hotfix for failues in conv_transpose
---
 caffe2/operators/conv_transpose_op_impl.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/caffe2/operators/conv_transpose_op_impl.h b/caffe2/operators/conv_transpose_op_impl.h
index dd35678baea19..808433939c785 100644
--- a/caffe2/operators/conv_transpose_op_impl.h
+++ b/caffe2/operators/conv_transpose_op_impl.h
@@ -38,7 +38,6 @@ bool ConvTransposeOp<T, Context>::RunOnDeviceWithOrderNCHW() {
   const int input_image_size = H * W;
   const int output_image_size = Y->dim32(2) * Y->dim32(3);
 
-#if !defined(__ARM_NEON__) && !defined(__ARM_NEON)
   if (InputSize() == 3) {
     auto& bias = Input(BIAS);
     CAFFE_ENFORCE(bias.ndim() == 1, "bias must be 1D tensor");
@@ -55,7 +54,6 @@ bool ConvTransposeOp<T, Context>::RunOnDeviceWithOrderNCHW() {
           &context_);
     }
   }
-#endif // !defined(__ARM_NEON__) && !defined(__ARM_NEON)
 
   const T* Xdata = X.template data<T>();
   const T* filter_data = filter.template data<T>();

From ea937354d4dd7701e38ff8defd600ce1c271ae63 Mon Sep 17 00:00:00 2001
From: Xiaolong Wang <xlwang@fb.com>
Date: Tue, 12 Jun 2018 09:51:30 -0700
Subject: [PATCH 047/118] [D2][Easy]: lint regularizer

lint with black
---
 caffe2/python/regularizer.py | 28 ++++++++++------------------
 1 file changed, 10 insertions(+), 18 deletions(-)

diff --git a/caffe2/python/regularizer.py b/caffe2/python/regularizer.py
index e5381ac6ab7d3..9f57a096dd8ce 100644
--- a/caffe2/python/regularizer.py
+++ b/caffe2/python/regularizer.py
@@ -1,10 +1,6 @@
 # @package optimizer
 # Module caffe2.python.optimizer
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
+from __future__ import absolute_import, division, print_function, unicode_literals
 
 from caffe2.python import core
 
@@ -13,11 +9,11 @@ class Regularizer(object):
     def __init__(self):
         self.apply_after_optimizer = False
 
-    '''
+    """
     Adds regularization to train_net for given parameter. Its factor ahead of
     regularization is given when initialization.
     The param should be a BlobReference.
-    '''
+    """
 
     def __call__(self, net, param_init_net, param, grad=None):
         assert isinstance(param, core.BlobReference)
@@ -30,13 +26,12 @@ def _run(self, net, param_init_net, param, grad):
 class L1Norm(Regularizer):
     def __init__(self, reg_lambda):
         super(L1Norm, self).__init__()
-        assert reg_lambda >= 0,\
-            'factor ahead of regularization should be 0 or positive'
+        assert reg_lambda >= 0, "factor ahead of regularization should be 0 or positive"
 
         self.reg_lambda = reg_lambda
 
     def _run(self, net, param_init_net, param, grad=None):
-        output_blob = net.NextScopedBlob(param + '_l1_regularization')
+        output_blob = net.NextScopedBlob(param + "_l1_regularization")
         net.LpNorm([param], [output_blob], p=1)
         net.Scale([output_blob], [output_blob], scale=self.reg_lambda)
         return output_blob
@@ -45,13 +40,12 @@ def _run(self, net, param_init_net, param, grad=None):
 class L2Norm(Regularizer):
     def __init__(self, reg_lambda):
         super(L2Norm, self).__init__()
-        assert reg_lambda >= 0,\
-            'factor ahead of regularization should be 0 or positive'
+        assert reg_lambda >= 0, "factor ahead of regularization should be 0 or positive"
 
         self.reg_lambda = reg_lambda
 
     def _run(self, net, param_init_net, param, grad=None):
-        output_blob = net.NextScopedBlob(param + '_l2_regularization')
+        output_blob = net.NextScopedBlob(param + "_l2_regularization")
         net.LpNorm([param], [output_blob], p=2)
         net.Scale([output_blob], [output_blob], scale=self.reg_lambda)
         return output_blob
@@ -64,7 +58,7 @@ def __init__(self, norm=1.0):
         self.apply_after_optimizer = True
 
     def _run(self, net, param_init_net, param, grad):
-        assert self.norm > 0, 'norm should be bigger than 0.'
+        assert self.norm > 0, "norm should be bigger than 0."
         if isinstance(grad, core.GradientSlice):
             net.SparseNormalize(
                 [param, grad.indices, grad.values],
@@ -73,9 +67,7 @@ def _run(self, net, param_init_net, param, grad):
                 norm=self.norm,
             )
         else:
-            raise NotImplementedError(
-                "MaxNorm is not supported for dense parameters"
-            )
+            raise NotImplementedError("MaxNorm is not supported for dense parameters")
 
 
 class ConstantNorm(Regularizer):
@@ -85,7 +77,7 @@ def __init__(self, norm=1.0):
         self.apply_after_optimizer = True
 
     def _run(self, net, param_init_net, param, grad):
-        assert self.norm > 0, 'norm should be bigger than 0.'
+        assert self.norm > 0, "norm should be bigger than 0."
         if isinstance(grad, core.GradientSlice):
             net.SparseNormalize(
                 [param, grad.indices, grad.values],

From d71773b91e39bf4bc59cebfd0f09f9d3db1f74e1 Mon Sep 17 00:00:00 2001
From: Xiaolong Wang <xlwang@fb.com>
Date: Tue, 12 Jun 2018 09:51:39 -0700
Subject: [PATCH 048/118] [GanH]: Split mu in adaptive weight for diagnose

---
 caffe2/python/layers/adaptive_weight.py | 60 ++++++++++++-------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/caffe2/python/layers/adaptive_weight.py b/caffe2/python/layers/adaptive_weight.py
index 9aec2735b44c1..0676a1f280d6f 100644
--- a/caffe2/python/layers/adaptive_weight.py
+++ b/caffe2/python/layers/adaptive_weight.py
@@ -1,86 +1,86 @@
 # @package adaptive_weight
 # Module caffe2.fb.python.layers.adaptive_weight
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
+from __future__ import absolute_import, division, print_function, unicode_literals
 
+import numpy as np
 from caffe2.python import core, schema
 from caffe2.python.layers.layers import ModelLayer
-import numpy as np
-'''
+
+
+"""
 Implementation of adaptive weighting: https://arxiv.org/pdf/1705.07115.pdf
-'''
+"""
 
 
 class AdaptiveWeight(ModelLayer):
+
     def __init__(
         self,
         model,
         input_record,
-        name='adaptive_weight',
+        name="adaptive_weight",
         optimizer=None,
         weights=None,
+        slice_mu=False,
         **kwargs
     ):
-        super(AdaptiveWeight,
-              self).__init__(model, name, input_record, **kwargs)
+        super(AdaptiveWeight, self).__init__(model, name, input_record, **kwargs)
         self.output_schema = schema.Scalar(
-            np.float32, self.get_next_blob_reference('adaptive_weight')
+            np.float32, self.get_next_blob_reference("adaptive_weight")
         )
         self.data = self.input_record.field_blobs()
         self.num = len(self.data)
         # mu_i = log(sigma_i^2)
         if weights is None:
             # mu_i is set such that all initial weights are 1. / num
-            initializer = ('ConstantFill', {'value': np.log(self.num / 2.)})
+            initializer = ("ConstantFill", {"value": np.log(self.num / 2.)})
         else:
             assert len(weights) == self.num
             weights = np.array(weights).astype(np.float32)
-            assert min(weights) > 0, 'initial weights must be non-negative'
+            assert min(weights) > 0, "initial weights must be non-negative"
             values = np.log(1. / 2. / weights)
             initializer = (
-                'GivenTensorFill', {
-                    'values': values,
-                    'dtype': core.DataType.FLOAT
-                }
+                "GivenTensorFill",
+                {"values": values, "dtype": core.DataType.FLOAT},
             )
 
         self.mu = self.create_param(
-            param_name='mu',
+            param_name="mu",
             shape=[self.num],
             initializer=initializer,
             optimizer=optimizer,
         )
+        self.slice_mu = slice_mu
 
     def concat_data(self, net):
-        reshaped = [
-            net.NextScopedBlob('reshaped_data_%d' % i) for i in range(self.num)
-        ]
+        reshaped = [net.NextScopedBlob("reshaped_data_%d" % i) for i in range(self.num)]
         # coerce shape for single real values
         for i in range(self.num):
             net.Reshape(
                 [self.data[i]],
-                [reshaped[i], net.NextScopedBlob('new_shape_%d' % i)],
-                shape=[1]
+                [reshaped[i], net.NextScopedBlob("new_shape_%d" % i)],
+                shape=[1],
             )
-        concated = net.NextScopedBlob('concated_data')
+        concated = net.NextScopedBlob("concated_data")
         net.Concat(
-            reshaped, [concated, net.NextScopedBlob('concated_new_shape')],
-            axis=0
+            reshaped, [concated, net.NextScopedBlob("concated_new_shape")], axis=0
         )
         return concated
 
     def compute_adaptive_sum(self, x, net):
-        mu_exp = net.NextScopedBlob('mu_exp')
+        mu_exp = net.NextScopedBlob("mu_exp")
         net.Exp(self.mu, mu_exp)
-        mu_exp_double = net.NextScopedBlob('mu_exp_double')
+        mu_exp_double = net.NextScopedBlob("mu_exp_double")
         net.Scale(mu_exp, mu_exp_double, scale=2.0)
-        weighted_x = net.NextScopedBlob('weighted_x')
+        weighted_x = net.NextScopedBlob("weighted_x")
         net.Div([x, mu_exp_double], weighted_x)
-        weighted_elements = net.NextScopedBlob('weighted_elements')
+        weighted_elements = net.NextScopedBlob("weighted_elements")
         net.Add([weighted_x, self.mu], weighted_elements)
         net.SumElements(weighted_elements, self.output_schema())
+        if self.slice_mu:
+            for i in range(self.num):
+                mu_i = net.NextScopedBlob("mu_%d" % i)
+                net.Slice(self.mu, mu_i, starts=[i], ends=[i + 1])
 
     def add_ops(self, net):
         data = self.concat_data(net)

From b070f1142b38314fcf7569633d99e95e1b804e26 Mon Sep 17 00:00:00 2001
From: Jiyan Yang <chocjy@fb.com>
Date: Tue, 12 Jun 2018 09:51:48 -0700
Subject: [PATCH 049/118] [Dper] Add the ability to split FC weights into
 multiple smaller ones

---
 caffe2/python/layers/fc.py | 93 ++++++++++++++++++++++++++++++++------
 1 file changed, 78 insertions(+), 15 deletions(-)

diff --git a/caffe2/python/layers/fc.py b/caffe2/python/layers/fc.py
index 68d0d49ed2b08..b949cc5b1bb81 100644
--- a/caffe2/python/layers/fc.py
+++ b/caffe2/python/layers/fc.py
@@ -16,7 +16,8 @@ class FC(SamplingTrainableMixin, ModelLayer):
 
     def __init__(self, model, input_record, output_dims, weight_init=None,
                  bias_init=None, weight_optim=None, bias_optim=None, name='fc',
-                 weight_reg=None, bias_reg=None, clip_param=None, **kwargs):
+                 weight_reg=None, bias_reg=None, clip_param=None, max_fc_size=None,
+                 **kwargs):
         super(FC, self).__init__(model, name, input_record, **kwargs)
         assert isinstance(input_record, schema.Scalar), (
             "Incorrect input type {}".format(input_record))
@@ -54,35 +55,97 @@ def __init__(self, model, input_record, output_dims, weight_init=None,
         bias_init = bias_init if bias_init else (
             'UniformFill', {'min': -scale, 'max': scale})
 
-        self.w = self.create_param(param_name='w',
-                                   shape=[output_dims, input_dims],
-                                   initializer=weight_init,
-                                   optimizer=weight_optim,
-                                   regularizer=weight_reg)
+        self.output_dim_vec = FC.calculate_fc_output_dims(
+            max_fc_size, input_dims, output_dims)
 
-        self.b = self.create_param(param_name='b',
-                                   shape=[output_dims, ],
-                                   initializer=bias_init,
-                                   optimizer=bias_optim,
-                                   regularizer=bias_reg)
+        if self.output_dim_vec is None or len(self.output_dim_vec) == 1:
+            self.w = self.create_param(param_name='w',
+                                       shape=[output_dims, input_dims],
+                                       initializer=weight_init,
+                                       optimizer=weight_optim,
+                                       regularizer=weight_reg)
+
+            self.b = self.create_param(param_name='b',
+                                       shape=[output_dims, ],
+                                       initializer=bias_init,
+                                       optimizer=bias_optim,
+                                       regularizer=bias_reg)
+        else:
+            self.w_vec = []
+            self.b_vec = []
+
+            for idx, output_dim in enumerate(self.output_dim_vec):
+                self.w_vec.append(self.create_param(param_name='w_sub_{}'.format(idx),
+                                             shape=[output_dim, input_dims],
+                                             initializer=weight_init,
+                                             optimizer=weight_optim,
+                                             regularizer=weight_reg))
+
+                self.b_vec.append(self.create_param(param_name='b_sub_{}'.format(idx),
+                                             shape=[output_dim, ],
+                                             initializer=weight_init,
+                                             optimizer=weight_optim,
+                                             regularizer=weight_reg))
 
         self.output_schema = schema.Scalar(
             (np.float32, (output_dims, )),
             self.get_next_blob_reference('output')
         )
 
+    @staticmethod
+    def calculate_fc_output_dims(max_fc_size, input_dim, output_dim):
+
+        if not max_fc_size or max_fc_size < 0:
+            return None
+
+        assert max_fc_size >= input_dim, "Currently we split along the output " \
+            "dimension. So we need max_fc_size >= input_dim. But, max_fc_size: " \
+            "{}, input_dim: {}".format(max_fc_size, input_dim)
+
+        output_dim_allowed = int(np.floor(max_fc_size / input_dim))
+        num_fc = int(np.floor((output_dim - 1) / output_dim_allowed) + 1)
+
+        output_dim_vec = [output_dim_allowed] * (num_fc - 1)
+
+        output_dim_vec.append(output_dim - sum(output_dim_vec))
+
+        return output_dim_vec
+
     def _add_ops(self, net, params):
         if self.clip_args is not None:
             clipped_params = [net.NextScopedBlob(
                 'clipped_%s' % str(p)) for p in params]
             for p, cp in zip(params, clipped_params):
                 net.Clip([p], [cp], **self.clip_args)
-            net.FC(self.input_record.field_blobs() + clipped_params,
-                   self.output_schema.field_blobs(), **self.kwargs)
-        else:
+
+            params = clipped_params
+
+        if self.output_dim_vec is None or len(self.output_dim_vec) == 1:
             net.FC(self.input_record.field_blobs() + params,
                    self.output_schema.field_blobs(), **self.kwargs)
+        else:
+            w_vec = params[:int(len(params) / 2)]
+            b_vec = params[int(len(params) / 2):]
+
+            assert len(w_vec) == len(b_vec)
+
+            output_blob_vec = []
+
+            for i in range(len(self.output_dim_vec)):
+                output_blob = net.NextScopedBlob(
+                    'output_sub_{}'.format(i))
+                output_blob_vec.append(
+                    net.FC(self.input_record.field_blobs() +
+                           [w_vec[i], b_vec[i]],
+                           [output_blob], **self.kwargs))
+
+            net.Concat(output_blob_vec,
+                       self.output_schema.field_blobs() +
+                       [self.output_schema.field_blobs()[0] + "_concat_dims"])
 
     @property
     def param_blobs(self):
-        return [self.w, self.b]
+        if self.output_dim_vec is None or len(self.output_dim_vec) == 1:
+            return [self.w, self.b]
+        else:
+            return self.w_vec + self.b_vec

From 29588e84f26ebc218feca77fdc9e70734f891611 Mon Sep 17 00:00:00 2001
From: Xianjie Chen <cxj@fb.com>
Date: Tue, 12 Jun 2018 09:52:06 -0700
Subject: [PATCH 050/118] fix SumReduceLikeOp for empty blob

as desc.
---
 .../elementwise_op_broadcast_test.py          | 162 ++++++++++++++++++
 1 file changed, 162 insertions(+)

diff --git a/caffe2/python/operator_test/elementwise_op_broadcast_test.py b/caffe2/python/operator_test/elementwise_op_broadcast_test.py
index ff6bddeb2bb6d..e767a0db161a9 100644
--- a/caffe2/python/operator_test/elementwise_op_broadcast_test.py
+++ b/caffe2/python/operator_test/elementwise_op_broadcast_test.py
@@ -324,3 +324,165 @@ def test_semantic_broadcast(self, gc, dc):
         out = workspace.FetchBlob("out")
         np.testing.assert_array_almost_equal(out, X + Y)
         self.assertDeviceChecks(dc, op, [X, Y], [0])
+
+    @given(**hu.gcs)
+    def test_sum_reduce_empty_blob(self, gc, dc):
+        net = core.Net('test')
+
+        with core.DeviceScope(gc):
+            net.GivenTensorFill([], ["X"], values=[], shape=[2, 0, 5])
+            net.GivenTensorFill([], ["Y"], values=[], shape=[2, 0])
+            net.SumReduceLike(["X", "Y"], "out", axis=0)
+            workspace.RunNetOnce(net)
+
+    @given(**hu.gcs)
+    def test_sum_reduce(self, gc, dc):
+        # Set broadcast and no axis, i.e. broadcasting last dimensions.
+        X = np.random.rand(2, 3, 4, 5).astype(np.float32)
+        Y = np.random.rand(4, 5).astype(np.float32)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1)
+        workspace.FeedBlob("X", X)
+        workspace.FeedBlob("Y", Y)
+        workspace.RunOperatorOnce(op)
+        out = workspace.FetchBlob("out")
+        res = np.sum(X, axis=0)
+        res = np.sum(res, axis=0)
+        np.testing.assert_array_almost_equal(out, res)
+        self.assertDeviceChecks(dc, op, [X, Y], [0])
+
+        # Set broadcast and no axis, i.e. broadcasting last dimensions.
+        X = np.random.rand(2, 3, 4, 5).astype(np.float32)
+        Y = np.random.rand(2, 3).astype(np.float32)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1, axis=0)
+        workspace.FeedBlob("X", X)
+        workspace.FeedBlob("Y", Y)
+        workspace.RunOperatorOnce(op)
+        out = workspace.FetchBlob("out")
+        res = np.sum(X, axis=3)
+        res = np.sum(res, axis=2)
+        np.testing.assert_array_almost_equal(out, res, decimal=3)
+        self.assertDeviceChecks(dc, op, [X, Y], [0])
+
+        # broadcasting intermediate dimensions
+        X = np.random.rand(2, 3, 4, 5).astype(np.float32)
+        Y = np.random.rand(3, 4).astype(np.float32)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1, axis=1)
+        workspace.FeedBlob("X", X)
+        workspace.FeedBlob("Y", Y)
+        workspace.RunOperatorOnce(op)
+        out = workspace.FetchBlob("out")
+        res = np.sum(X, axis=0)
+        res = np.sum(res, axis=2)
+        np.testing.assert_array_almost_equal(out, res)
+        self.assertDeviceChecks(dc, op, [X, Y], [0])
+
+        # broadcasting intermediate dimensions
+        X = np.random.rand(2, 3, 4, 500).astype(np.float64)
+        Y = np.random.rand(1).astype(np.float64)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1)
+        workspace.FeedBlob("X", X)
+        workspace.FeedBlob("Y", Y)
+        workspace.RunOperatorOnce(op)
+        out = workspace.FetchBlob("out")
+        res = np.array(np.sum(X))
+        np.testing.assert_array_almost_equal(out, res, decimal=0)
+
+        # broadcasting with single elem dimensions at both ends
+        X = np.random.rand(2, 3, 4, 5).astype(np.float32)
+        Y = np.random.rand(1, 3, 4, 1).astype(np.float32)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1)
+        workspace.FeedBlob("X", X)
+        workspace.FeedBlob("Y", Y)
+        workspace.RunOperatorOnce(op)
+        out = workspace.FetchBlob("out")
+        res = np.sum(X, axis=0)
+        res = np.sum(res, axis=2).reshape(Y.shape)
+        np.testing.assert_array_almost_equal(out, res)
+        self.assertDeviceChecks(dc, op, [X, Y], [0])
+
+        # fp64 is not supported with the CUDA op
+        dc_cpu_only = [d for d in dc if d.device_type != caffe2_pb2.CUDA]
+        self.assertDeviceChecks(dc_cpu_only, op, [X, Y], [0])
+
+    @unittest.skipIf(not workspace.has_gpu_support, "No gpu support")
+    @given(**hu.gcs_gpu_only)
+    def test_sum_reduce_fp16(self, gc, dc):
+        # Set broadcast and no axis, i.e. broadcasting last dimensions.
+        X = np.random.rand(2, 3, 4, 5).astype(np.float16)
+        Y = np.random.rand(4, 5).astype(np.float16)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1, device_option=gc)
+
+        def ref_op(X, Y):
+            res = np.sum(X, axis=0)
+            res = np.sum(res, axis=0)
+            return [res]
+
+        self.assertReferenceChecks(
+            device_option=gc,
+            op=op,
+            inputs=[X, Y],
+            reference=ref_op,
+            threshold=1e-3)
+
+        # Set broadcast and no axis, i.e. broadcasting last dimensions.
+        X = np.random.rand(2, 3, 4, 5).astype(np.float16)
+        Y = np.random.rand(2, 3).astype(np.float16)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1, axis=0)
+
+        def ref_op(X, Y):
+            res = np.sum(X, axis=3)
+            res = np.sum(res, axis=2)
+            return [res]
+
+        self.assertReferenceChecks(
+            device_option=gc,
+            op=op,
+            inputs=[X, Y],
+            reference=ref_op,
+            threshold=1e-3)
+
+        # broadcasting intermediate dimensions
+        X = np.random.rand(2, 3, 4, 5).astype(np.float16)
+        Y = np.random.rand(3, 4).astype(np.float16)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1, axis=1)
+
+        def ref_op(X, Y):
+            res = np.sum(X, axis=0)
+            res = np.sum(res, axis=2)
+            return [res]
+
+        self.assertReferenceChecks(
+            device_option=gc,
+            op=op,
+            inputs=[X, Y],
+            reference=ref_op,
+            threshold=1e-3)
+
+        # broadcasting with single elem dimensions at both ends
+        X = np.random.rand(2, 3, 4, 5).astype(np.float16)
+        Y = np.random.rand(1, 3, 4, 1).astype(np.float16)
+        op = core.CreateOperator(
+            "SumReduceLike", ["X", "Y"], "out", broadcast=1)
+
+        def ref_op(X, Y):
+            res = np.sum(X, axis=0)
+            res = np.sum(res, axis=2)
+            return [res.reshape(Y.shape)]
+
+        self.assertReferenceChecks(
+            device_option=gc,
+            op=op,
+            inputs=[X, Y],
+            reference=ref_op,
+            threshold=1e-3)
+
+if __name__ == "__main__":
+    unittest.main()

From 67cbbc2203048f218c496d815662645a9efc6318 Mon Sep 17 00:00:00 2001
From: Jun Liu <junliu@fb.com>
Date: Tue, 12 Jun 2018 09:52:41 -0700
Subject: [PATCH 051/118] add ctc_greedy_decoder for caffe2

ctc_greedy_decoder same as tf's
---
 caffe2/operators/ctc_greedy_decoder_op.cc     | 98 +++++++++++++++++++
 caffe2/operators/ctc_greedy_decoder_op.h      | 32 ++++++
 .../ctc_greedy_decoder_op_test.py             | 90 +++++++++++++++++
 3 files changed, 220 insertions(+)
 create mode 100644 caffe2/operators/ctc_greedy_decoder_op.cc
 create mode 100644 caffe2/operators/ctc_greedy_decoder_op.h
 create mode 100644 caffe2/python/operator_test/ctc_greedy_decoder_op_test.py

diff --git a/caffe2/operators/ctc_greedy_decoder_op.cc b/caffe2/operators/ctc_greedy_decoder_op.cc
new file mode 100644
index 0000000000000..5f9792d651b37
--- /dev/null
+++ b/caffe2/operators/ctc_greedy_decoder_op.cc
@@ -0,0 +1,98 @@
+#include "caffe2/operators/ctc_greedy_decoder_op.h"
+
+namespace caffe2 {
+
+namespace {
+
+template <class Context>
+const float* getTensorDataPtr(const Tensor<Context>& tensor, int t, int n) {
+  const auto& dims = tensor.dims();
+  CAFFE_ENFORCE_EQ(dims.size(), 3);
+  int offset = (t * dims[1] + n) * dims[2];
+  CAFFE_ENFORCE_LT(offset, tensor.size());
+  return tensor.template data<float>() + offset;
+}
+
+} // namespace
+
+template <>
+bool CTCGreedyDecoderOp<CPUContext>::RunOnDevice() {
+  // [max_time_step, batch_size, num_classes]
+  auto& inputs = Input(INPUTS);
+  // [batch_size]
+  auto* output_len = Output(OUTPUT_LEN);
+  // [total_decoded_output]
+  auto* values = Output(VALUES);
+
+  const auto& inputs_dims = inputs.dims();
+  int32_t max_time_step = inputs_dims[0];
+  int32_t batch_size = inputs_dims[1];
+  int32_t num_classes = inputs_dims[2];
+  // [batch_size]
+  const int* seq_len_data =
+      (InputSize() == 2) ? Input(SEQ_LEN).data<int>() : nullptr;
+
+  vector<int> values_cach;
+  output_len->Resize(vector<TIndex>{batch_size});
+  int* output_len_data = output_len->mutable_data<int>();
+
+  for (int32_t i = 0; i < batch_size; ++i) {
+    int previous_label = 0, t_dec = 0;
+    int32_t seq_len_i = (seq_len_data) ? seq_len_data[i] : max_time_step;
+    CAFFE_ENFORCE_LE(seq_len_i, max_time_step);
+    for (int32_t t = 0; t < seq_len_i; ++t) {
+      auto* prob_data = getTensorDataPtr(inputs, t, i);
+      int curr_label =
+          std::max_element(prob_data, prob_data + num_classes) - prob_data;
+      if (curr_label != 0 &&
+          (!merge_repeated_ || (previous_label != curr_label))) {
+        t_dec++;
+        values_cach.push_back(curr_label);
+      }
+      previous_label = curr_label;
+    }
+    output_len_data[i] = t_dec;
+  }
+
+  values->Resize(vector<TIndex>{values_cach.size()});
+  int* values_data = values->mutable_data<int>();
+  for (int i = 0; i < values_cach.size(); ++i) {
+    values_data[i] = values_cach.at(i);
+  }
+  values_cach.clear();
+
+  return true;
+}
+
+REGISTER_CPU_OPERATOR(CTCGreedyDecoder, CTCGreedyDecoderOp<CPUContext>);
+OPERATOR_SCHEMA(CTCGreedyDecoder)
+    .NumInputs(1, 2)
+    .NumOutputs(2)
+    .Arg(
+        "merge_repeated",
+        "When merge_repeated is true, merge repeated classes in output.")
+    .SetDoc("Greedy decoder for connectionist temporal classification.")
+    .Input(
+        0,
+        "INPUTS",
+        "3D float Tensor sized [max_time, batch_size, num_classes]")
+    .Input(
+        1,
+        "SEQ_LEN",
+        "(optional) 1D int vector containing sequence lengths, "
+        "having size [batch_size]"
+        "seq_len will be set to max_time if not provided")
+    .Output(
+        0,
+        "OUTPUT_LEN",
+        "Output_len matrix size (batch). "
+        "The row store: [decoded_length]")
+    .Output(
+        1,
+        "VALUES",
+        "Values vector, size (total_decoded_outputs). "
+        "The vector stores the decoded classes")
+    .InheritOnnxSchema("CTCGreedyDecoder");
+SHOULD_NOT_DO_GRADIENT(CTCGreedyDecoder);
+
+} // namespace caffe2
diff --git a/caffe2/operators/ctc_greedy_decoder_op.h b/caffe2/operators/ctc_greedy_decoder_op.h
new file mode 100644
index 0000000000000..a5a0bab8f9480
--- /dev/null
+++ b/caffe2/operators/ctc_greedy_decoder_op.h
@@ -0,0 +1,32 @@
+#ifndef CAFFE2_OPERATORS_CTC_GREEDY_DECODER_OP_H_
+#define CAFFE2_OPERATORS_CTC_GREEDY_DECODER_OP_H_
+
+#include "caffe2/core/context.h"
+#include "caffe2/core/operator.h"
+
+namespace caffe2 {
+
+template <class Context>
+class CTCGreedyDecoderOp : public Operator<Context> {
+ public:
+  USE_OPERATOR_CONTEXT_FUNCTIONS;
+  CTCGreedyDecoderOp(const OperatorDef& operator_def, Workspace* ws)
+      : Operator<Context>(operator_def, ws) {
+    if (OperatorBase::HasArgument("merge_repeated")) {
+      merge_repeated_ =
+          OperatorBase::GetSingleArgument<bool>("merge_repeated", true);
+    }
+  }
+
+  bool RunOnDevice() override;
+
+ protected:
+  bool merge_repeated_;
+  INPUT_TAGS(INPUTS, SEQ_LEN);
+  OUTPUT_TAGS(OUTPUT_LEN, VALUES);
+  // Input: X, 3D tensor; L, 1D tensor. Output: Y sparse tensor
+};
+
+} // namespace caffe2
+
+#endif // CAFFE2_OPERATORS_CTC_GREEDY_DECODER_OP_H_
diff --git a/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py b/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py
new file mode 100644
index 0000000000000..4ae1db3050bc4
--- /dev/null
+++ b/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py
@@ -0,0 +1,90 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+from caffe2.python import core
+from hypothesis import given
+import caffe2.python.hypothesis_test_util as hu
+import hypothesis.strategies as st
+import numpy as np
+
+import unittest
+
+
+class TestCTCGreedyDecoderOp(hu.HypothesisTestCase):
+
+    @given(
+        batch=st.sampled_from([2, 4, 128, 256]),
+        max_time=st.sampled_from([2, 10, 30, 50]),
+        num_classes=st.sampled_from([2, 10, 26, 40]),
+        merge_repeated=st.sampled_from([True, False]),
+        **hu.gcs
+    )
+    def test_ctc_greedy_decoder(
+        self, batch, max_time,
+        num_classes, merge_repeated, gc, dc
+    ):
+
+        def input_generater():
+            inputs = np.random.rand(max_time, batch, num_classes)\
+                .astype(np.float32)
+            seq_len = np.random.randint(1, max_time + 1, size=batch)\
+                .astype(np.int32)
+            return inputs, seq_len
+
+        def ref_ctc_decoder(inputs, seq_len):
+            merge = merge_repeated
+            output_len = np.array([]).astype(np.int32)
+            val = np.array([]).astype(np.int32)
+            for i in range(batch):
+                prev_id = 0
+                t_dec = 0
+                len_i = seq_len[i] if seq_len is not None else max_time
+                for t in range(len_i):
+                    max_id = np.argmax(inputs[t, i, :])
+                    if max_id == 0:
+                        prev_id = max_id
+                        continue
+                    if max_id == prev_id and merge:
+                        prev_id = max_id
+                        continue
+                    t_dec += 1
+                    val = np.append(val, max_id)
+                    prev_id = max_id
+                output_len = np.append(output_len, t_dec)
+
+            return [output_len, val]
+
+        def ref_ctc_decoder_max_time(inputs):
+            return ref_ctc_decoder(inputs, None)
+
+        inputs, seq_len = input_generater()
+        op = core.CreateOperator('CTCGreedyDecoder',
+            ['INPUTS', 'SEQ_LEN'],
+            ['OUTPUT_LEN', 'VALUES'],
+            merge_repeated=merge_repeated)
+
+        self.assertReferenceChecks(
+            device_option=gc,
+            op=op,
+            inputs=[inputs, seq_len],
+            reference=ref_ctc_decoder,
+        )
+
+        op_1 = core.CreateOperator('CTCGreedyDecoder',
+            ['INPUTS'],
+            ['OUTPUT_LEN', 'VALUES'],
+            merge_repeated=merge_repeated)
+
+        self.assertReferenceChecks(
+            device_option=gc,
+            op=op_1,
+            inputs=[inputs],
+            reference=ref_ctc_decoder_max_time,
+        )
+
+
+if __name__ == "__main__":
+    import random
+    random.seed(2603)
+    unittest.main()

From 555188395362394040a47658bccbfeb2d1656cd2 Mon Sep 17 00:00:00 2001
From: Ilia Cherniavskii <iliacher@fb.com>
Date: Tue, 12 Jun 2018 09:53:05 -0700
Subject: [PATCH 052/118] Update event callback handling

Allow multiple callbacks per event
---
 caffe2/core/event.cc    | 18 ++++++------------
 caffe2/core/event.h     |  6 +++---
 caffe2/core/event_cpu.h |  2 +-
 3 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/caffe2/core/event.cc b/caffe2/core/event.cc
index 0a612b68c1e95..e547167dadfe5 100644
--- a/caffe2/core/event.cc
+++ b/caffe2/core/event.cc
@@ -99,28 +99,22 @@ void EventSetFinishedCPU(const Event* event, const char* err_msg) {
     wrapper->status_ = EventStatus::EVENT_FAILED;
   }
 
-  if (wrapper->callback_) {
-    wrapper->callback_();
+  for (auto& callback : wrapper->callbacks_) {
+    callback();
   }
 
   wrapper->cv_completed_.notify_all();
 }
 
-bool EventSetCallbackCPU(Event* event, EventCallbackFunction callback) {
+void EventSetCallbackCPU(Event* event, EventCallbackFunction callback) {
   auto* wrapper = static_cast<CPUEventWrapper*>(event->event_.get());
   std::unique_lock<std::mutex> lock(wrapper->mutex_);
 
-  if (wrapper->callback_) {
-    return false;
-  }
-  wrapper->callback_ = callback;
+  wrapper->callbacks_.push_back(callback);
   if (wrapper->status_ == EventStatus::EVENT_SUCCESS ||
       wrapper->status_ == EventStatus::EVENT_FAILED) {
-    if (wrapper->callback_) {
-      wrapper->callback_();
-    }
+    callback();
   }
-  return true;
 }
 
 void EventResetCPU(Event* event) {
@@ -128,7 +122,7 @@ void EventResetCPU(Event* event) {
   std::unique_lock<std::mutex> lock(wrapper->mutex_);
   wrapper->status_ = EventStatus::EVENT_INITIALIZED;
   wrapper->err_msg_ = "";
-  wrapper->callback_ = nullptr;
+  wrapper->callbacks_.clear();
 }
 
 REGISTER_EVENT_CREATE_FUNCTION(CPU, EventCreateCPU);
diff --git a/caffe2/core/event.h b/caffe2/core/event.h
index 17822490dfc12..d6bbc126760bb 100644
--- a/caffe2/core/event.h
+++ b/caffe2/core/event.h
@@ -49,7 +49,7 @@ typedef void (*EventResetFunction)(Event*);
 
 // Sets callback that is called when event is finished
 typedef std::function<void()> EventCallbackFunction;
-typedef bool (*EventSetCallbackFunction)(Event*, EventCallbackFunction);
+typedef void (*EventSetCallbackFunction)(Event*, EventCallbackFunction);
 
 class Event {
  public:
@@ -124,10 +124,10 @@ class Event {
     return event_callback_setter_[type_] != nullptr;
   }
 
-  bool SetCallback(EventCallbackFunction callback) {
+  void SetCallback(EventCallbackFunction callback) {
     CAFFE_ENFORCE(
         event_callback_setter_[type_], "Event does not support callbacks");
-    return event_callback_setter_[type_](this, callback);
+    event_callback_setter_[type_](this, callback);
   }
 
   // If parent op has succeeded, then we can run any child op;
diff --git a/caffe2/core/event_cpu.h b/caffe2/core/event_cpu.h
index d723828aa517e..130841c10e72d 100644
--- a/caffe2/core/event_cpu.h
+++ b/caffe2/core/event_cpu.h
@@ -19,7 +19,7 @@ struct CPUEventWrapper {
   std::condition_variable cv_completed_;
   std::atomic<int> status_;
   std::string err_msg_;
-  EventCallbackFunction callback_;
+  std::vector<EventCallbackFunction> callbacks_;
 };
 
 void EventCreateCPU(const DeviceOption& option, Event* event);

From 07a3025a8e62e8d6b8890cf021d9a2213f1a57b5 Mon Sep 17 00:00:00 2001
From: Ellie Wen <dwen@fb.com>
Date: Tue, 12 Jun 2018 09:53:22 -0700
Subject: [PATCH 053/118] Add WeightedSum layer

The motivation is to do weighted sum in HoNet/crossnet, in the next diff, I'll replace model.Add with model.WeightedSum in
honet: https://fburl.com/f4rmolg2
crossnet: https://fburl.com/v7awn8se, https://fburl.com/63filbnm
---
 caffe2/python/layers/blob_weighted_sum.py | 73 +++++++++++++++++++++++
 caffe2/python/layers_test.py              | 63 +++++++++++++++++++
 2 files changed, 136 insertions(+)
 create mode 100644 caffe2/python/layers/blob_weighted_sum.py

diff --git a/caffe2/python/layers/blob_weighted_sum.py b/caffe2/python/layers/blob_weighted_sum.py
new file mode 100644
index 0000000000000..cf8ecfd99045d
--- /dev/null
+++ b/caffe2/python/layers/blob_weighted_sum.py
@@ -0,0 +1,73 @@
+## @package BlobWeightedSum
+# Module caffe2.python.layers.blob_weighted_sum
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+from caffe2.python import schema
+from caffe2.python.layers.layers import ModelLayer
+
+
+class BlobWeightedSum(ModelLayer):
+    """
+    This layer implements the weighted sum:
+    weighted element-wise sum of input blobs.
+    """
+    def __init__(
+        self,
+        model,
+        input_record,
+        init_weights=None,
+        weight_optim=None,
+        name='blob_weighted_sum',
+        **kwargs
+    ):
+        super(BlobWeightedSum, self).__init__(model, name, input_record, **kwargs)
+
+        self.blobs = self.input_record.field_blobs()
+
+        self.num_weights = len(self.blobs)
+        assert self.num_weights > 1, (
+            "BlobWeightedSum expects more than one input blobs"
+        )
+
+        assert len(input_record.field_types()[0].shape) > 0, (
+            "BlobWeightedSum expects limited dimensions of the input tensor"
+        )
+
+        assert all(
+            input_record.field_types()[0].shape == input_record.field_types()[i].shape
+            for i in range(1, self.num_weights)
+        ), "Shape of input blobs should be the same shape {}".format(
+            input_record.field_types()[0].shape
+        )
+
+        if init_weights:
+            assert self.num_weights == len(init_weights), (
+                "the size of init_weights should be the same as input blobs, "
+                "expects {}, got {}".format(self.num_weights, len(init_weights))
+            )
+        else:
+            init_weights = [1.0] * self.num_weights
+
+        self.weights = [
+            self.create_param(
+                param_name="w_{}".format(idx),
+                shape=[1],
+                initializer=('ConstantFill', {'value': float(init_weights[idx])}),
+                optimizer=weight_optim
+            ) for idx in range(self.num_weights)
+        ]
+
+        self.output_schema = schema.Scalar(
+            input_record.field_types()[0],
+            self.get_next_blob_reference('blob_weighted_sum_out')
+        )
+
+    def add_ops(self, net):
+        net.WeightedSum(
+            [x for pair in zip(self.blobs, self.weights) for x in pair],
+            self.output_schema(),
+            grad_on_w=True,
+        )
diff --git a/caffe2/python/layers_test.py b/caffe2/python/layers_test.py
index e7e4df3bfd714..278276609d594 100644
--- a/caffe2/python/layers_test.py
+++ b/caffe2/python/layers_test.py
@@ -1854,3 +1854,66 @@ def testLabelSmoothForCategoricalLabel(self, categories, bsz, gc, dc):
     )
     def testLabelSmoothForBinaryProbLabel(self, bsz, gc, dc):
         self._testLabelSmooth(2, True, bsz)
+
+    @given(
+        num_inputs=st.integers(min_value=2, max_value=10),
+        batch_size=st.integers(min_value=2, max_value=10),
+        input_dim=st.integers(min_value=5, max_value=10),
+        seed=st.integers(1, 10),
+    )
+    def testBlobWeightedSum(self, num_inputs, batch_size, input_dim, seed):
+
+        def get_blob_weighted_sum():
+            weights = []
+            for i in range(num_inputs):
+                w_blob_name = 'blob_weighted_sum/w_{0}'.format(i)
+                assert workspace.HasBlob(w_blob_name), (
+                    "cannot fine blob {}".format(w_blob_name)
+                )
+                w = workspace.FetchBlob(w_blob_name)
+                weights.append(w)
+
+            result = np.sum([
+                input_data[idx] * weights[idx] for idx in range(num_inputs)
+            ], axis=0)
+            return result
+
+        np.random.seed(seed)
+        expected_output_schema = schema.Scalar((np.float32, (input_dim,)))
+        input_schema = schema.Tuple(
+            *[expected_output_schema for _ in range(num_inputs)]
+        )
+        input_data = [
+            np.random.random((batch_size, input_dim)).astype(np.float32)
+            for _ in range(num_inputs)
+        ]
+        input_record = self.new_record(input_schema)
+        schema.FeedRecord(input_record, input_data)
+
+        # test output schema
+        ws_output = self.model.BlobWeightedSum(input_record)
+        self.assertEqual(len(self.model.layers), 1)
+        assert schema.equal_schemas(ws_output, expected_output_schema)
+
+        # test train net
+        train_init_net, train_net = self.get_training_nets()
+        workspace.RunNetOnce(train_init_net)
+        workspace.RunNetOnce(train_net)
+        output = workspace.FetchBlob(ws_output())
+        npt.assert_almost_equal(get_blob_weighted_sum(), output, decimal=5)
+
+        self.run_train_net_forward_only()
+        output = workspace.FetchBlob(ws_output())
+        npt.assert_almost_equal(get_blob_weighted_sum(), output, decimal=5)
+
+        # test eval net
+        eval_net = self.get_eval_net()
+        workspace.RunNetOnce(eval_net)
+        output = workspace.FetchBlob(ws_output())
+        npt.assert_almost_equal(get_blob_weighted_sum(), output, decimal=5)
+
+        # test pred net
+        pred_net = self.get_predict_net()
+        workspace.RunNetOnce(pred_net)
+        output = workspace.FetchBlob(ws_output())
+        npt.assert_almost_equal(get_blob_weighted_sum(), output, decimal=5)

From d7f2d023762d7c8a2bc54dac5b5597abf676a1cf Mon Sep 17 00:00:00 2001
From: Ilia Cherniavskii <iliacher@fb.com>
Date: Tue, 12 Jun 2018 09:53:32 -0700
Subject: [PATCH 054/118] Replicate DAG's behavior

Some callers expect RunAsync to block, replicate that behavior in case of
explicit 'dag' net type
---
 caffe2/core/net_async_base.cc       | 3 +++
 caffe2/core/net_async_base.h        | 1 +
 caffe2/core/net_async_scheduling.cc | 4 ++++
 3 files changed, 8 insertions(+)

diff --git a/caffe2/core/net_async_base.cc b/caffe2/core/net_async_base.cc
index 742a3457ec916..89d579aeb4c1d 100644
--- a/caffe2/core/net_async_base.cc
+++ b/caffe2/core/net_async_base.cc
@@ -455,6 +455,7 @@ void AsyncNetBase::computeExecutionModeFlags() {
     check_stream_status_ = false;
     use_single_pool_ = true;
     use_per_net_pools_ = true;
+    is_blocking_ = true;
   } else if (net_type == kAsyncDag) {
     streams_per_gpu_ = 1;
     finish_chain_ = false;
@@ -462,6 +463,7 @@ void AsyncNetBase::computeExecutionModeFlags() {
     check_stream_status_ = false;
     use_single_pool_ = true;
     use_per_net_pools_ = true;
+    is_blocking_ = true;
   } else {
     streams_per_gpu_ = FLAGS_caffe2_streams_per_gpu;
     finish_chain_ = FLAGS_caffe2_net_async_finish_chain;
@@ -469,6 +471,7 @@ void AsyncNetBase::computeExecutionModeFlags() {
     check_stream_status_ = FLAGS_caffe2_net_async_check_stream_status;
     use_single_pool_ = FLAGS_caffe2_net_async_use_single_pool;
     use_per_net_pools_ = FLAGS_caffe2_net_async_use_per_net_pools;
+    is_blocking_ = false;
   }
 }
 
diff --git a/caffe2/core/net_async_base.h b/caffe2/core/net_async_base.h
index cebffa2e657da..c7047d2e64162 100644
--- a/caffe2/core/net_async_base.h
+++ b/caffe2/core/net_async_base.h
@@ -114,6 +114,7 @@ class AsyncNetBase : public NetBase {
   bool check_stream_status_;
   bool use_single_pool_;
   bool use_per_net_pools_;
+  bool is_blocking_;
 
   DISABLE_COPY_AND_ASSIGN(AsyncNetBase);
 
diff --git a/caffe2/core/net_async_scheduling.cc b/caffe2/core/net_async_scheduling.cc
index 5cf96d0a551fc..87c2a4b0c237f 100644
--- a/caffe2/core/net_async_scheduling.cc
+++ b/caffe2/core/net_async_scheduling.cc
@@ -203,6 +203,10 @@ bool AsyncSchedulingNet::RunAsync() {
     finishRun();
   }
 
+  if (is_blocking_) {
+    Wait();
+  }
+
   return true;
 }
 

From 037d98e0b3eba0b80f4e762b736665d20c6d93c6 Mon Sep 17 00:00:00 2001
From: Yan Zhu <yzhu@fb.com>
Date: Tue, 12 Jun 2018 09:53:43 -0700
Subject: [PATCH 055/118] [dper] layernorm layer

as title
---
 caffe2/python/layers/layer_normalization.py | 76 +++++++++++++++++++++
 caffe2/python/layers_test.py                | 14 ++++
 2 files changed, 90 insertions(+)
 create mode 100644 caffe2/python/layers/layer_normalization.py

diff --git a/caffe2/python/layers/layer_normalization.py b/caffe2/python/layers/layer_normalization.py
new file mode 100644
index 0000000000000..db34adbd93c80
--- /dev/null
+++ b/caffe2/python/layers/layer_normalization.py
@@ -0,0 +1,76 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+from caffe2.python import schema
+from caffe2.python.layers.layers import ModelLayer
+
+import numpy as np
+
+
+class LayerNormalization(ModelLayer):
+    def __init__(
+        self,
+        model,
+        input_record,
+        name='layer_normalization',
+        scale_optim=None,
+        bias_optim=None,
+        epsilon=1e-4,
+        axis=1,
+        **kwargs
+    ):
+        super(LayerNormalization, self).__init__(
+            model, name, input_record, **kwargs)
+
+        assert isinstance(input_record, schema.Scalar), (
+            "Incorrect input type: {}".format(input_record))
+
+        self.input_shape = input_record.field_type().shape
+        self.epsilon = epsilon
+        self.axis = axis
+
+        assert len(self.input_shape) >= 1, (
+            "This layer supports only >= 2D tesnors")
+        input_dims = self.input_shape[0]
+
+        self.output_schema = schema.Scalar(
+            (np.float32, self.input_shape),
+            self.get_next_blob_reference('output')
+        )
+
+        self.scale = self.create_param(param_name='scale',
+                                       shape=[input_dims],
+                                       initializer=('ConstantFill', {'value': 1.0}),
+                                       optimizer=scale_optim)
+        self.bias = self.create_param(param_name='bias',
+                                       shape=[input_dims],
+                                       initializer=('ConstantFill', {'value': 0.0}),
+                                       optimizer=bias_optim)
+
+    def add_ops(self, net):
+        input_blob = self.input_record.field_blobs()
+        ln_output = self.output_schema.field_blobs()
+
+        output_blobs = [net.NextScopedBlob('ln_output'), net.NextScopedBlob('ln_mean'),
+                        net.NextScopedBlob('ln_stdev')]
+
+        normalized, mean, stdev = net.LayerNorm(input_blob,
+            output_blobs,
+            axis=self.axis,
+            epsilon=self.epsilon)
+
+        scaled = net.Mul(
+            [normalized, self.scale],
+            [net.NextScopedBlob('ln_scaled')],
+            broadcast=1,
+            axis=self.axis,
+        )
+
+        net.Add(
+            [scaled, self.bias],
+            ln_output,
+            broadcast=1,
+            axis=self.axis,
+        )
diff --git a/caffe2/python/layers_test.py b/caffe2/python/layers_test.py
index 278276609d594..4383c01b13915 100644
--- a/caffe2/python/layers_test.py
+++ b/caffe2/python/layers_test.py
@@ -769,6 +769,20 @@ def testBatchNormalization(self, X):
         schema.FeedRecord(input_record, [X])
         workspace.RunNetOnce(predict_net)
 
+    @given(
+        X=hu.arrays(dims=[2, 5, 6]),
+    )
+    def testLayerNormalization(self, X):
+        input_record = self.new_record(schema.Scalar((np.float32, (5, 6,))))
+        schema.FeedRecord(input_record, [X])
+        ln_output = self.model.LayerNormalization(input_record)
+        self.assertEqual(schema.Scalar((np.float32, (5, 6,))), ln_output)
+        self.model.output_schema = schema.Struct()
+
+        train_init_net, train_net = self.get_training_nets()
+        workspace.RunNetOnce(train_init_net)
+        workspace.RunNetOnce(train_net)
+
     @given(
         X=hu.arrays(dims=[5, 2]),
         num_to_collect=st.integers(min_value=1, max_value=10),

From 9da991ee03cc8d19a3bb05c67bd063653693ab9c Mon Sep 17 00:00:00 2001
From: Ilia Cherniavskii <iliacher@fb.com>
Date: Tue, 12 Jun 2018 09:53:51 -0700
Subject: [PATCH 056/118] Override dag, async_dag, async_polling

Overriding dag, async_dag and async_polling with async_scheduling
---
 caffe2/core/net.cc | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/caffe2/core/net.cc b/caffe2/core/net.cc
index 9d6f536c06346..19f1c4798c717 100644
--- a/caffe2/core/net.cc
+++ b/caffe2/core/net.cc
@@ -104,17 +104,30 @@ std::vector<NetObserverCreator>* GetNetObserverCreators() {
   return &creators;
 }
 
+const std::unordered_map<std::string, std::string>& defaultOverrides() {
+  static const std::unordered_map<std::string, std::string> overrides = {
+      {"dag", "async_scheduling"},
+      {"async_dag", "async_scheduling"},
+      {"async_polling", "async_scheduling"},
+      {"async_simple", "simple"},
+  };
+  return overrides;
+}
+
 void checkExecutorOverride(std::string& net_type) {
   auto executors = caffe2::split(',', FLAGS_caffe2_override_executor);
   CAFFE_ENFORCE(
       executors.size() % 2 == 0, "Invalid override executors flag value");
   std::unordered_map<std::string, std::string> overrides;
+  for (const auto& kv : defaultOverrides()) {
+    overrides[kv.first] = kv.second;
+  }
   for (size_t idx = 0; idx < executors.size() - 1; idx += 2) {
     overrides[executors[idx]] = executors[idx + 1];
   }
   if (overrides.count(net_type)) {
-    LOG(INFO) << "Overrode net type '" << net_type << "' with '"
-              << overrides[net_type] << "'";
+    VLOG(1) << "Overrode net type '" << net_type << "' with '"
+            << overrides[net_type] << "'";
     net_type = overrides[net_type];
   }
 }
@@ -147,9 +160,7 @@ unique_ptr<NetBase> CreateNet(
     // sequentially.
     net_type = kSimpleNet;
   }
-  if (!FLAGS_caffe2_override_executor.empty()) {
-    checkExecutorOverride(net_type);
-  }
+  checkExecutorOverride(net_type);
   unique_ptr<NetBase> net = NetRegistry()->Create(net_type, net_def, ws);
 
   VLOG(1) << "Adding a global observer to a net";

From 4a194d57adcfa0b074b0f35f91515f4e2effc4a1 Mon Sep 17 00:00:00 2001
From: Giuseppe Ottaviano <ott@fb.com>
Date: Tue, 12 Jun 2018 09:54:03 -0700
Subject: [PATCH 057/118] Name the thread pools

Caffe thread pools currently inherit the thread names from the thread that starts them, which can be misleading. Give them an explicit name instead.
---
 caffe2/core/net_dag.cc                |  3 +++
 caffe2/utils/thread_name.cc           | 24 ++++++++++++++++++++++++
 caffe2/utils/thread_name.h            |  9 +++++++++
 caffe2/utils/thread_pool.h            |  2 ++
 caffe2/utils/threadpool/ThreadPool.h  |  4 ++--
 caffe2/utils/threadpool/WorkersPool.h |  8 +++++---
 6 files changed, 45 insertions(+), 5 deletions(-)
 create mode 100644 caffe2/utils/thread_name.cc
 create mode 100644 caffe2/utils/thread_name.h

diff --git a/caffe2/core/net_dag.cc b/caffe2/core/net_dag.cc
index 8ecc17f902c95..e256362d409e9 100644
--- a/caffe2/core/net_dag.cc
+++ b/caffe2/core/net_dag.cc
@@ -11,6 +11,7 @@
 #include "caffe2/core/timer.h"
 #include "caffe2/proto/caffe2.pb.h"
 #include "caffe2/utils/proto_utils.h"
+#include "caffe2/utils/thread_name.h"
 
 CAFFE2_DEFINE_bool(
     caffe2_disable_chaining,
@@ -200,6 +201,8 @@ void DAGNetBase::HandleException(
 }
 
 void DAGNetBase::WorkerFunction() {
+  setThreadName("CaffeDAGNet");
+
   // WorkerFunctions() is an infinite loop until there are no more jobs to run.
   while (true) {
     int idx = 0;
diff --git a/caffe2/utils/thread_name.cc b/caffe2/utils/thread_name.cc
new file mode 100644
index 0000000000000..5fdcc22567756
--- /dev/null
+++ b/caffe2/utils/thread_name.cc
@@ -0,0 +1,24 @@
+#include "caffe2/utils/thread_name.h"
+
+#include <algorithm>
+
+#if defined(__GLIBC__) && !defined(__APPLE__) && !defined(__ANDROID__)
+#define CAFFE2_HAS_PTHREAD_SETNAME_NP
+#endif
+
+#ifdef CAFFE2_HAS_PTHREAD_SETNAME_NP
+#include <pthread.h>
+#endif
+
+namespace caffe2 {
+
+void setThreadName(std::string name) {
+#ifdef CAFFE2_HAS_PTHREAD_SETNAME_NP
+  constexpr size_t kMaxThreadName = 15;
+  name.resize(std::min(name.size(), kMaxThreadName));
+
+  pthread_setname_np(pthread_self(), name.c_str());
+#endif
+}
+
+} // namespace caffe2
diff --git a/caffe2/utils/thread_name.h b/caffe2/utils/thread_name.h
new file mode 100644
index 0000000000000..aece335c23dbc
--- /dev/null
+++ b/caffe2/utils/thread_name.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <string>
+
+namespace caffe2 {
+
+void setThreadName(std::string name);
+
+} // namespace caffe2
diff --git a/caffe2/utils/thread_pool.h b/caffe2/utils/thread_pool.h
index db25d7c30dfcf..3c10dd769e8eb 100644
--- a/caffe2/utils/thread_pool.h
+++ b/caffe2/utils/thread_pool.h
@@ -9,6 +9,7 @@
 #include <utility>
 
 #include "caffe2/core/numa.h"
+#include "caffe2/utils/thread_name.h"
 
 namespace caffe2 {
 
@@ -115,6 +116,7 @@ class TaskThreadPool {
  private:
   /// @brief Entry point for pool threads.
   void main_loop(std::size_t index) {
+    setThreadName("CaffeTaskThread");
     NUMABind(numa_node_id_);
 
     while (running_) {
diff --git a/caffe2/utils/threadpool/ThreadPool.h b/caffe2/utils/threadpool/ThreadPool.h
index 8c111d0ac044b..aa6c44ac7984c 100644
--- a/caffe2/utils/threadpool/ThreadPool.h
+++ b/caffe2/utils/threadpool/ThreadPool.h
@@ -19,12 +19,12 @@ class WorkersPool;
 
 constexpr size_t kCacheLineSize = 64;
 
-// A work-stealing threadpool with the given number of threads.
+// A threadpool with the given number of threads.
 // NOTE: the kCacheLineSize alignment is present only for cache
 // performance, and is not strictly enforced (for example, when
 // the object is created on the heap). Thus, in order to avoid
 // misaligned intrinsics, no SSE instructions shall be involved in
-// the ThreadPool implemetation.
+// the ThreadPool implementation.
 class alignas(kCacheLineSize) ThreadPool {
  public:
   static std::unique_ptr<ThreadPool> defaultThreadPool();
diff --git a/caffe2/utils/threadpool/WorkersPool.h b/caffe2/utils/threadpool/WorkersPool.h
index 9d2ffd57864b6..0c621d53854de 100644
--- a/caffe2/utils/threadpool/WorkersPool.h
+++ b/caffe2/utils/threadpool/WorkersPool.h
@@ -1,10 +1,11 @@
 #pragma once
 
-#include "caffe2/core/common.h"
-#include "caffe2/core/logging.h"
 #include <atomic>
-#include <thread>
 #include <condition_variable>
+#include <thread>
+#include "caffe2/core/common.h"
+#include "caffe2/core/logging.h"
+#include "caffe2/utils/thread_name.h"
 
 #if defined(_MSC_VER)
 #include <intrin.h>
@@ -262,6 +263,7 @@ class alignas(kGEMMLOWPCacheLineSize) Worker {
 
   // Thread entry point.
   void ThreadFunc() {
+    setThreadName("CaffeWorkersPool");
     ChangeState(State::Ready);
 
     // Thread main loop

From 1e8ca7d85e3a6193fc752ada007183b10cad26f8 Mon Sep 17 00:00:00 2001
From: Artem Volkhin <volkhin@fb.com>
Date: Tue, 12 Jun 2018 09:54:16 -0700
Subject: [PATCH 058/118] [Caffe2] FilleOp should support int64_t dimensions

Change argument type to int64_t for shape argument of FillerOp (used in ConstantFill, XavierFill, etc)
---
 caffe2/operators/filler_op.h                   |  8 ++++----
 caffe2/python/operator_test/filler_ops_test.py | 15 +++++++++++++++
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/caffe2/operators/filler_op.h b/caffe2/operators/filler_op.h
index 8fac761bdbb36..c144b70378273 100644
--- a/caffe2/operators/filler_op.h
+++ b/caffe2/operators/filler_op.h
@@ -22,7 +22,7 @@ class FillerOp : public Operator<Context> {
  public:
   FillerOp(const OperatorDef& operator_def, Workspace* ws)
       : Operator<Context>(operator_def, ws),
-        shape_(ToVectorTIndex(OperatorBase::GetRepeatedArgument<int>("shape"))),
+        shape_(OperatorBase::GetRepeatedArgument<int64_t>("shape")),
         extra_shape_(ToVectorTIndex(
             OperatorBase::GetRepeatedArgument<int>("extra_shape"))),
         input_as_shape_(
@@ -524,12 +524,12 @@ inline std::vector<TensorShape> FillerTensorInference(
       out[0].set_unknown_shape(true);
       return out;
     }
-    for (int d : in[0].dims()) {
+    for (auto d : in[0].dims()) {
       out[0].add_dims(d);
     }
   } else {
-    auto shape = helper.GetRepeatedArgument<int>("shape");
-    for (int d : shape) {
+    auto shape = helper.GetRepeatedArgument<int64_t>("shape");
+    for (auto d : shape) {
       out[0].add_dims(d);
     }
   }
diff --git a/caffe2/python/operator_test/filler_ops_test.py b/caffe2/python/operator_test/filler_ops_test.py
index 186778ee9416e..df13cba4a3b96 100644
--- a/caffe2/python/operator_test/filler_ops_test.py
+++ b/caffe2/python/operator_test/filler_ops_test.py
@@ -49,6 +49,21 @@ def test_shape_error(self, gc, dc):
         self.assertTrue(workspace.RunOperatorOnce(op))
         self.assertEqual(workspace.FetchBlob('out'), [2.0])
 
+    @given(**hu.gcs)
+    def test_int64_shape(self, gc, dc):
+        large_dim = 2 ** 31 + 1
+        net = core.Net("test_shape_net")
+        net.UniformFill(
+            [],
+            'out',
+            shape=[0, large_dim],
+            min=0.0,
+            max=1.0,
+        )
+        self.assertTrue(workspace.CreateNet(net))
+        self.assertTrue(workspace.RunNet(net.Name()))
+        self.assertEqual(workspace.blobs['out'].shape, (0, large_dim))
+
     @given(
         shape=hu.dims().flatmap(
             lambda dims: hu.arrays(

From db1fc3246f3adc1d4e424c596dce19dc2dc796cf Mon Sep 17 00:00:00 2001
From: Dmytro Dzhulgakov <dzhulgakov@fb.com>
Date: Tue, 12 Jun 2018 09:54:41 -0700
Subject: [PATCH 059/118] Remove caffe2/caffe2/contrib/torch/

It's not used anywhere and depends on old lua torch that conflicts with Aten. Given PT1 it's not relevant any more (though it was nice and clever code!)

#accept2ship
---
 caffe2/contrib/torch/th_ops.cc         | 118 -----
 caffe2/contrib/torch/th_ops_gpu.cu     | 160 -------
 caffe2/contrib/torch/th_ops_test.py    |  50 ---
 caffe2/contrib/torch/torch_op.cpp      |  46 --
 caffe2/contrib/torch/torch_op.h        | 575 -------------------------
 caffe2/contrib/torch/torch_op_gpu.cpp  | 110 -----
 caffe2/contrib/torch/torch_ops_test.py | 135 ------
 7 files changed, 1194 deletions(-)
 delete mode 100644 caffe2/contrib/torch/th_ops.cc
 delete mode 100644 caffe2/contrib/torch/th_ops_gpu.cu
 delete mode 100644 caffe2/contrib/torch/th_ops_test.py
 delete mode 100644 caffe2/contrib/torch/torch_op.cpp
 delete mode 100644 caffe2/contrib/torch/torch_op.h
 delete mode 100644 caffe2/contrib/torch/torch_op_gpu.cpp
 delete mode 100644 caffe2/contrib/torch/torch_ops_test.py

diff --git a/caffe2/contrib/torch/th_ops.cc b/caffe2/contrib/torch/th_ops.cc
deleted file mode 100644
index b4e18a4d4e894..0000000000000
--- a/caffe2/contrib/torch/th_ops.cc
+++ /dev/null
@@ -1,118 +0,0 @@
-#include "caffe2/core/context.h"
-#include "caffe2/core/operator.h"
-
-extern "C" {
-#include <THNN.h>
-}
-
-namespace caffe2 {
-
-namespace {
-
-using UniqueTHFloatTensor =
-    std::unique_ptr<THFloatTensor, decltype(&THFloatTensor_free)>;
-
-UniqueTHFloatTensor aliasFromTensorCPU(TensorCPU* tensor) {
-  if (!tensor->ndim()) {
-    return UniqueTHFloatTensor(THFloatTensor_new(), THFloatTensor_free);
-  }
-
-  THLongStorage* thshape = THLongStorage_newWithSize(tensor->ndim());
-  for (int i = 0; i < tensor->ndim(); ++i) {
-    THLongStorage_set(thshape, i, tensor->dim(i));
-  }
-  THFloatStorage* storage = THFloatStorage_newWithData(
-      tensor->template mutable_data<float>(), tensor->size());
-  THFloatStorage_clearFlag(storage, TH_STORAGE_FREEMEM);
-  auto* th = THFloatTensor_newWithStorage(storage, 0, thshape, nullptr);
-  THFloatStorage_free(storage);
-  THLongStorage_free(thshape);
-  CAFFE_ENFORCE_EQ(
-      THFloatTensor_storage(th)->data, tensor->template mutable_data<float>());
-  return UniqueTHFloatTensor(th, THFloatTensor_free);
-}
-
-void copyToTensorCPU(UniqueTHFloatTensor th, TensorCPU* tensor) {
-  // TODO - if th and tensor point to the same data and have the same
-  // size, elide the copy!
-  th = UniqueTHFloatTensor(
-      THFloatTensor_newContiguous(th.get()), THFloatTensor_free);
-  const auto dims = std::vector<TIndex>(
-      th->size, th->size + THFloatTensor_nDimension(th.get()));
-  // Short-circuit if we never reallocated in TH
-  auto* storage = THFloatTensor_storage(th.get());
-  // Short-circuit if we never reallocated in TH
-  if (dims == tensor->dims() &&
-      storage->data == tensor->template data<float>()) {
-    THFloatStorage_clearFlag(storage, TH_STORAGE_FREEMEM);
-    return;
-  }
-  tensor->Resize(dims);
-  CPUContext ctx;
-  ctx.Copy<float, CPUContext, CPUContext>(
-      tensor->size(), storage->data, tensor->mutable_data<float>());
-}
-
-// _Everything_ below here can be autogenerated with the TBD
-// THNN/THCUNN schema. This is just a proof of concept.
-
-class THNNELUCPUOp final : public Operator<CPUContext> {
- public:
-  USE_OPERATOR_FUNCTIONS(CPUContext);
-  using Operator<CPUContext>::Operator;
-  bool RunOnDevice() override {
-    // TODO - we can autogenerate this from a schema.
-    auto X = aliasFromTensorCPU(const_cast<TensorCPU*>(&Input(0)));
-    auto Y = aliasFromTensorCPU(Output(0));
-    THNN_FloatELU_updateOutput(
-        nullptr,
-        X.get(),
-        Y.get(),
-        GetSingleArgument<float>("alpha", 1.0),
-        &Input(0) == Output(0));
-    copyToTensorCPU(std::move(Y), Output(0));
-    return true;
-  }
-};
-
-class THNNELUCPUGradientOp final : public Operator<CPUContext> {
- public:
-  USE_OPERATOR_FUNCTIONS(CPUContext);
-  using Operator<CPUContext>::Operator;
-
-  bool RunOnDevice() override {
-    // TODO - we can autogenerate this from a schema.
-    auto X = aliasFromTensorCPU(const_cast<TensorCPU*>(&Input(0)));
-    auto Y = aliasFromTensorCPU(const_cast<TensorCPU*>(&Input(1)));
-    auto dY = aliasFromTensorCPU(const_cast<TensorCPU*>(&Input(2)));
-    auto dX = aliasFromTensorCPU(Output(0));
-    THNN_FloatELU_updateGradInput(
-        nullptr,
-        X.get(),
-        dY.get(),
-        dX.get(),
-        Y.get(),
-        GetSingleArgument<float>("alpha", 1.0),
-        &Input(2) == Output(0) /* inplace */);
-    copyToTensorCPU(std::move(dX), Output(0));
-    return true;
-  }
-};
-
-REGISTER_CPU_OPERATOR_WITH_ENGINE(ELU, THNN, THNNELUCPUOp);
-REGISTER_CPU_OPERATOR_WITH_ENGINE(ELUGradient, THNN, THNNELUCPUGradientOp);
-
-class GetELUGradient : public GradientMakerBase {
-  using GradientMakerBase::GradientMakerBase;
-  vector<OperatorDef> GetGradientDefs() override {
-    return SingleGradientDef(
-        "ELUGradient",
-        "",
-        vector<string>{I(0), O(0), GO(0)},
-        vector<string>{GI(0)},
-        Def().arg());
-  }
-};
-REGISTER_GRADIENT(ELU, GetELUGradient);
-}
-}
diff --git a/caffe2/contrib/torch/th_ops_gpu.cu b/caffe2/contrib/torch/th_ops_gpu.cu
deleted file mode 100644
index a998384316771..0000000000000
--- a/caffe2/contrib/torch/th_ops_gpu.cu
+++ /dev/null
@@ -1,160 +0,0 @@
-#include "caffe2/core/context.h"
-#include "caffe2/core/context_gpu.h"
-#include "caffe2/core/operator.h"
-
-#include <THCAllocator.h>
-#include <THCStorage.h>
-#include <THCTensor.h>
-
-#include <THCUNN.h>
-
-namespace caffe2 {
-
-namespace {
-
-THCState* getTHCState() {
-  // TODO don't leak the THCState. We only have as many threads as
-  // e.g. the number of AsyncDAGNet worker threads, which is small
-  // (O(numGPUs)).
-  static thread_local THCState* state = nullptr;
-  if (!state) {
-    state = new THCState();
-    THCudaInit(state);
-    CHECK_NOTNULL(state);
-  }
-  return state;
-}
-
-struct THCudaTensorDeleter {
-  explicit THCudaTensorDeleter(THCState* state)
-      : state_(CHECK_NOTNULL(state)) {}
-  void operator()(THCudaTensor* th) {
-    THCudaTensor_free(state_, th);
-  }
-
-  THCState* state_{nullptr};
-};
-
-using UniqueTHCudaTensor = std::unique_ptr<THCudaTensor, THCudaTensorDeleter>;
-
-THCState* thnnState(CUDAContext* context) {
-  THCState* state = getTHCState();
-  THCStream* stream = THCState_getStream(state);
-  // TODO - swap these back after we're done before we handle
-  // deletion.
-  // TODO - handle proper destroy of existing handle
-  // (if not already caffe2 set handle)
-  stream->stream = context->cuda_stream();
-
-  // TODO - destroy the current handle
-  int device;
-  THCudaCheck(cudaGetDevice(&device));
-  int blasHandleIndex = THCState_getCurrentBlasHandleIndex(state);
-  THCState_getDeviceBlasHandle(state, device, blasHandleIndex); // to reserve
-  THCCudaResourcesPerDevice* res = &(state->resourcesPerDevice[device]);
-  res->blasHandles[blasHandleIndex - 1] = context->cublas_handle();
-  return state;
-}
-
-UniqueTHCudaTensor aliasFromTensorCUDA(
-    CUDAContext* context,
-    TensorCUDA* tensor) {
-  auto* state = thnnState(context);
-  if (!tensor->ndim()) {
-    return UniqueTHCudaTensor(
-        THCudaTensor_new(state), THCudaTensorDeleter(state));
-  }
-  THLongStorage* thshape = THLongStorage_newWithSize(tensor->ndim());
-  for (int i = 0; i < tensor->ndim(); ++i) {
-    THLongStorage_set(thshape, i, tensor->dim(i));
-  }
-  THCudaStorage* storage = THCudaStorage_newWithData(
-      state, tensor->mutable_data<float>(), tensor->size());
-  THCudaStorage_clearFlag(state, storage, TH_STORAGE_FREEMEM);
-  auto* th =
-      THCudaTensor_newWithStorage(state, storage, 0, thshape, nullptr);
-  THCudaStorage_free(state, storage);
-  THLongStorage_free(thshape);
-  CAFFE_ENFORCE_EQ(
-      THCudaTensor_storage(state, th)->data,
-      tensor->mutable_data<float>());
-  return UniqueTHCudaTensor(th, THCudaTensorDeleter(state));
-}
-
-void copyToTensorCUDA(
-    CUDAContext* context,
-    UniqueTHCudaTensor th,
-    TensorCUDA* tensor) {
-  auto* state = thnnState(context);
-  // As contiguous
-  th = UniqueTHCudaTensor(
-      THCudaTensor_newContiguous(state, th.get()),
-      THCudaTensorDeleter(state));
-  const auto dims = std::vector<TIndex>(
-      th->size, th->size + THCudaTensor_nDimension(state, th.get()));
-  auto* storage = THCudaTensor_storage(state, th.get());
-  // Short-circuit if we never reallocated in TH
-  if (dims == tensor->dims() && storage->data == tensor->data<float>()) {
-    THCudaStorage_clearFlag(state, storage, TH_STORAGE_FREEMEM);
-    return;
-  }
-
-  tensor->Resize(dims);
-  context->Copy<float, CUDAContext, CUDAContext>(
-      tensor->size(), storage->data, tensor->mutable_data<float>());
-}
-
-// _Everything_ below here can be autogenerated with the TBD
-// THNN/THCUNN schema. This is just a proof of concept.
-
-class THNNELUCUDAOp final : public Operator<CUDAContext> {
- public:
-  USE_OPERATOR_FUNCTIONS(CUDAContext);
-  using Operator<CUDAContext>::Operator;
-
-  bool RunOnDevice() override {
-    // TODO - we can autogenerate this from a schema.
-    auto* state = thnnState(&context_);
-    auto X = aliasFromTensorCUDA(&context_, const_cast<TensorCUDA*>(&Input(0)));
-    auto Y = aliasFromTensorCUDA(&context_, Output(0));
-    THNN_CudaELU_updateOutput(
-        state,
-        X.get(),
-        Y.get(),
-        GetSingleArgument<float>("alpha", 1.0),
-        &Input(0) == Output(0));
-    copyToTensorCUDA(&context_, std::move(Y), Output(0));
-    return true;
-  }
-};
-
-class THNNELUCUDAGradientOp final : public Operator<CUDAContext> {
- public:
-  USE_OPERATOR_FUNCTIONS(CUDAContext);
-  using Operator<CUDAContext>::Operator;
-
-  bool RunOnDevice() override {
-    // TODO - we can autogenerate this from a schema.
-    auto* state = thnnState(&context_);
-    auto X = aliasFromTensorCUDA(&context_, const_cast<TensorCUDA*>(&Input(0)));
-    auto Y = aliasFromTensorCUDA(&context_, const_cast<TensorCUDA*>(&Input(1)));
-    auto dY =
-        aliasFromTensorCUDA(&context_, const_cast<TensorCUDA*>(&Input(2)));
-    auto dX = aliasFromTensorCUDA(&context_, Output(0));
-    THNN_CudaELU_updateGradInput(
-        state,
-        X.get(),
-        dY.get(),
-        dX.get(),
-        Y.get(),
-        GetSingleArgument<float>("alpha", 1.0),
-        &Input(2) == Output(0) /* inplace */);
-    copyToTensorCUDA(&context_, std::move(dX), Output(0));
-    return true;
-  }
-};
-
-REGISTER_CUDA_OPERATOR_WITH_ENGINE(ELU, THNN, THNNELUCUDAOp);
-REGISTER_CUDA_OPERATOR_WITH_ENGINE(ELUGradient, THNN, THNNELUCUDAGradientOp);
-}
-}
diff --git a/caffe2/contrib/torch/th_ops_test.py b/caffe2/contrib/torch/th_ops_test.py
deleted file mode 100644
index 09d7d1635d58d..0000000000000
--- a/caffe2/contrib/torch/th_ops_test.py
+++ /dev/null
@@ -1,50 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-from caffe2.python import core, dyndep
-import caffe2.python.hypothesis_test_util as hu
-
-from hypothesis import given
-import hypothesis.strategies as st
-import numpy as np
-
-dyndep.InitOpsLibrary('@/caffe2/caffe2/contrib/torch:th_ops')
-
-
-try:
-    dyndep.InitOpsLibrary('@/caffe2/caffe2/contrib/torch:th_ops_gpu')
-    HAS_GPU = True
-except Exception as e:
-    print("Exception loading Torch GPU library: ", e)
-    # GPU import can fail, as Torch is not using cuda-lazy
-    HAS_GPU = False
-    pass
-
-
-class THOpsTest(hu.HypothesisTestCase):
-    @given(X=hu.tensor(),
-           alpha=st.floats(min_value=0.1, max_value=2.0),
-           in_place=st.booleans(),
-           **(hu.gcs if HAS_GPU else hu.gcs_cpu_only))
-    def test_elu(self, X, alpha, in_place, gc, dc):
-        op = core.CreateOperator(
-            "ELU",
-            ["X"],
-            ["X" if in_place else "Y"],
-            engine="THNN",
-            alpha=alpha)
-        self.assertDeviceChecks(dc, op, [X], [0])
-
-        def elu(X):
-            Y = np.copy(X)
-            Y[Y <= 0] = (np.exp(Y[Y <= 0]) - 1) * alpha
-            return (Y,)
-
-        self.assertReferenceChecks(gc, op, [X], elu)
-        # Avoid the nonlinearity at 0 for gradient checker.
-        X[X == 0] += 0.2
-        X[np.abs(X) < 0.2] += np.sign(X[np.abs(X) < 0.2])
-        assert len(X[np.abs(X) < 0.2]) == 0
-        self.assertGradientChecks(gc, op, [X], 0, [0])
diff --git a/caffe2/contrib/torch/torch_op.cpp b/caffe2/contrib/torch/torch_op.cpp
deleted file mode 100644
index 3e9f9b0bdc1b9..0000000000000
--- a/caffe2/contrib/torch/torch_op.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "torch_op.h"
-
-namespace caffe2 {
-
-namespace torch {
-
-const char* TyTraits<CPUContext>::moduleTy = "float";
-const char* TyTraits<CPUContext>::tensorTy = "torch.FloatTensor";
-const char* TyTraits<CPUContext>::prelude = R"(
-        require 'torch'
-        require 'nn'
-)";
-}
-
-struct GetTorchGradient : public GradientMakerBase {
-  using GradientMakerBase::GradientMakerBase;
-  std::vector<OperatorDef> GetGradientDefs() override {
-    std::vector<std::string> gradientInputs;
-    for (int i = 0; i < def_.input_size(); ++i) {
-      gradientInputs.push_back(I(i));
-    }
-    for (int i = 0; i < def_.output_size(); ++i) {
-      gradientInputs.push_back(O(i));
-    }
-    for (int i = 0; i < def_.output_size(); ++i) {
-      gradientInputs.push_back(GO(i));
-    }
-    std::vector<std::string> gradientOutputs;
-    for (int i = 0; i < def_.input_size(); ++i) {
-      gradientOutputs.push_back(GI(i));
-    }
-
-    return SingleGradientDef(
-        "TorchGradient", "", gradientInputs, gradientOutputs);
-  }
-};
-
-
-REGISTER_CPU_OPERATOR(Torch, TorchOp<CPUContext>);
-REGISTER_CPU_OPERATOR(TorchInit, TorchInitOp<CPUContext>);
-REGISTER_CPU_OPERATOR(TorchGradient, TorchGradientOp<CPUContext>);
-REGISTER_GRADIENT(Torch, GetTorchGradient);
-OPERATOR_SCHEMA(Torch).AllowInplace([](int, int) { return true; });
-OPERATOR_SCHEMA(TorchInit);
-OPERATOR_SCHEMA(TorchGradient).AllowInplace([](int, int) { return true; });
-}
diff --git a/caffe2/contrib/torch/torch_op.h b/caffe2/contrib/torch/torch_op.h
deleted file mode 100644
index c5860364400b5..0000000000000
--- a/caffe2/contrib/torch/torch_op.h
+++ /dev/null
@@ -1,575 +0,0 @@
-#pragma once
-#include <unordered_map>
-
-#include "caffe2/core/context.h"
-#include "caffe2/core/operator.h"
-#include "caffe2/core/tensor.h"
-
-extern "C" {
-#include <TH/THStorage.h>
-#include <TH/THTensor.h>
-#include <lua.h>
-#include <luaT.h>
-#include <lualib.h>
-}
-
-namespace caffe2 {
-
-namespace torch {
-
-template <typename Context>
-struct TyTraits {};
-
-template <>
-struct TyTraits<CPUContext> {
-  static const char* moduleTy;
-  static const char* prelude;
-  static const char* tensorTy;
-  using Tensor = THFloatTensor;
-};
-
-template <typename Context>
-class Torch final {
- public:
-  using Traits = TyTraits<Context>;
-  Torch() {
-    L_ = luaL_newstate();
-    luaL_openlibs(L_);
-    luaL_loadstring(L_, Traits::prelude);
-    int err = lua_pcall(L_, 0, 0, 0);
-    CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L_, -1));
-  };
-
-  ~Torch() {
-    lua_close(L_);
-  }
-
-  lua_State* L() {
-    return L_;
-  }
-
-  static const char* tensorTy(const Blob& blob) {
-    CAFFE_ENFORCE(blob.template IsType<Tensor<Context>>());
-    const auto& tc = blob.template Get<Tensor<Context>>();
-    CAFFE_ENFORCE(
-        tc.template IsType<float>() + tc.meta().name(), ", ", tc.size());
-    return Traits::tensorTy;
-  }
-
-  void setContext(Context* /*context*/) {}
-
-  void setTensor(typename Traits::Tensor* t, Blob* blob) {
-    CAFFE_ENFORCE_EQ(tensorTy(*blob), Traits::tensorTy);
-    auto* tc = blob->template GetMutable<Tensor<Context>>();
-    CAFFE_ENFORCE_EQ(THFloatTensor_nElement(t), tc->size());
-    THFloatStorage* storage = THFloatStorage_newWithData(
-        tc->template mutable_data<float>(), tc->size());
-    THFloatStorage_clearFlag(storage, TH_STORAGE_FREEMEM);
-    THFloatStorage* original = t->storage;
-    t->storage = storage;
-    THFloatStorage_free(original);
-  }
-
-  std::vector<TIndex> tensorShape(typename Traits::Tensor* t) {
-    auto* size = t->size;
-    return std::vector<TIndex>(size, size + THFloatTensor_nDimension(t));
-  }
-
-  typename Traits::Tensor* newTensorAs(const Tensor<Context>& tc) {
-    THLongStorage* thshape = THLongStorage_newWithSize(tc.ndim());
-    for (uint32_t i = 0; i < tc.ndim(); ++i) {
-      THLongStorage_set(thshape, i, tc.dim(i));
-    }
-    THFloatTensor* d = THFloatTensor_newWithSize(thshape, nullptr);
-    THLongStorage_free(thshape);
-    return d;
-  }
-
-  typename Traits::Tensor* blobToTensor(Blob* blob) {
-    CAFFE_ENFORCE_EQ(tensorTy(*blob), Traits::tensorTy);
-    auto* tc = blob->template GetMutable<Tensor<Context>>();
-
-    size_t size = tc->size();
-    THLongStorage* thshape = THLongStorage_newWithSize(tc->ndim());
-    for (int i = 0; i < tc->ndim(); ++i) {
-      THLongStorage_set(thshape, i, tc->dim(i));
-    }
-    THFloatStorage* storage =
-        THFloatStorage_newWithData(tc->template mutable_data<float>(), size);
-    THFloatStorage_clearFlag(storage, TH_STORAGE_FREEMEM);
-    auto* th = THFloatTensor_newWithStorage(storage, 0, thshape, nullptr);
-    THFloatStorage_free(storage);
-    THLongStorage_free(thshape);
-    CAFFE_ENFORCE_EQ(
-        THFloatTensor_storage(th)->data, tc->template mutable_data<float>());
-    return th;
-  }
-
-  std::vector<typename Traits::Tensor*> pushTable(
-      const std::vector<Blob*>& blobs) {
-    if (blobs.empty()) {
-      lua_pushnil(L());
-      return {};
-    }
-
-    if (blobs.size() == 1) {
-      auto* th = blobToTensor(blobs[0]);
-      luaT_pushudata(L(), th, tensorTy(*blobs[0]));
-      return {th};
-    }
-
-    std::vector<typename Traits::Tensor*> res;
-    lua_createtable(L(), blobs.size(), 0);
-    int index = 1;
-    for (auto* blob : blobs) {
-      auto* th = blobToTensor(blob);
-      res.push_back(th);
-      luaT_pushudata(L(), th, tensorTy(*blob));
-      lua_rawseti(L(), -2, index++);
-    }
-    return res;
-  }
-
-  void verifyOutput(Blob* dst, typename Traits::Tensor* torchDst) {
-    if (!luaT_isudata(L(), -1, Traits::tensorTy)) {
-      LOG(FATAL) << "Unsupported Torch tensor type " << luaT_typename(L(), -1);
-    }
-
-    // Invariant: dst has the same size as src, and has the same data
-    // values as src.
-    auto* src = static_cast<typename Traits::Tensor*>(
-        luaT_toudata(L(), -1, Traits::tensorTy));
-    auto* thDst = static_cast<typename Traits::Tensor*>(torchDst);
-    auto* tcDst = dst->template GetMutable<Tensor<Context>>();
-    CAFFE_ENFORCE(src->storage->data);
-    CAFFE_ENFORCE(src->storage->size);
-    CAFFE_ENFORCE_EQ(src->storage->data, thDst->storage->data);
-    CAFFE_ENFORCE_EQ(src->storage->data, tcDst->template data<float>());
-    CAFFE_ENFORCE_EQ(src->storage->size, thDst->storage->size);
-    CAFFE_ENFORCE_EQ(src->storage->size, tcDst->size());
-  }
-
-  void verifyOutputs(
-      const std::vector<Blob*>& blobs,
-      const std::vector<typename Traits::Tensor*>& tensors) {
-    CAFFE_ENFORCE_EQ(tensors.size(), blobs.size());
-
-    if (blobs.empty()) {
-      return;
-    }
-
-    if (blobs.size() == 1) {
-      verifyOutput(blobs[0], tensors[0]);
-      return;
-    }
-
-    CAFFE_ENFORCE(lua_istable(L(), -1));
-    lua_pushnil(L());
-    for (auto i = 0; i < blobs.size(); ++i) {
-      CAFFE_ENFORCE(lua_next(L(), -2));
-      verifyOutput(blobs[i], tensors[i]);
-      lua_pop(L(), 1);
-    }
-    lua_pop(L(), 1);
-  }
-
-private:
-  lua_State* L_;
-};
-}
-
-template <typename Context>
-class TorchOpBase : public Operator<Context> {
- public:
-  USE_OPERATOR_CONTEXT_FUNCTIONS;
-  using OperatorBase::Outputs;
-  using OperatorBase::Inputs;
-  TorchOpBase(const OperatorDef& operator_def, Workspace* ws)
-      : Operator<Context>(operator_def, ws) {
-    lua_State* L = state_.L();
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-    const auto initString = "return " +
-        OperatorBase::GetSingleArgument<std::string>("init", "") + ":" +
-        torch::Torch<Context>::Traits::moduleTy + "()";
-    CAFFE_ENFORCE_EQ(luaL_loadstring(L, initString.c_str()), 0);
-    int err = lua_pcall(L, 0, 1, 0);
-    CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L, -1));
-    // Get number of parameters
-    uint32_t numParams = 0;
-    lua_getfield(L, -1, "parameters");
-    lua_pushvalue(L, -2);
-    CAFFE_ENFORCE_EQ(lua_pcall(L, 1, LUA_MULTRET, 0), 0);
-    if (lua_gettop(L) == 1) {
-      numParams = 0;
-    } else {
-      CAFFE_ENFORCE_EQ(lua_gettop(L), 3);
-      numParams = lua_objlen(L, -2);
-      lua_pop(L, 2);
-    }
-    CAFFE_ENFORCE_EQ(
-        numParams, OperatorBase::GetSingleArgument<int>("num_params", 0));
-    // TODO: free parameters?
-    self_ = luaL_ref(L, LUA_REGISTRYINDEX);
-  }
-
-  void reshapeBlobs(
-      const std::vector<Blob*>& inputBlobs,
-      const std::vector<Blob*>& paramBlobs,
-      const std::vector<Blob*>& outputBlobs) {
-    auto cacheEqual = [=]() {
-      if (cachedInputSizes_.size() != inputBlobs.size()) {
-        return false;
-      }
-
-      for (auto i = 0; i < inputBlobs.size(); ++i) {
-        const auto& current =
-            inputBlobs[i]->template Get<Tensor<Context>>().dims();
-        const auto& cached = cachedInputSizes_[i];
-        if (current != cached) {
-          return false;
-        }
-      }
-      return true;
-    };
-
-    if (cacheEqual()) {
-      return;
-    }
-    LOG(INFO) << "Cached blobs not equal, running :updateOutput to reshape";
-    lua_State* L = state_.L();
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-    lua_rawgeti(L, LUA_REGISTRYINDEX, self_);
-    lua_getfield(L, -1, "updateOutput");
-    lua_pushvalue(L, -2); // self
-    if (inputBlobs.size() == 1) {
-      const auto& tc = inputBlobs[0]->template Get<Tensor<Context>>();
-      auto* inputData = state_.newTensorAs(tc);
-      luaT_pushudata(L, inputData, torch::Torch<Context>::Traits::tensorTy);
-    } else if (inputBlobs.size() > 1) {
-      lua_createtable(L, inputBlobs.size(), 0);
-      for (auto i = 0; i < inputBlobs.size(); ++i) {
-        const auto* blob = inputBlobs[i];
-        const auto& tc = blob->template Get<Tensor<Context>>();
-        auto* inputData = state_.newTensorAs(tc);
-        luaT_pushudata(L, inputData, torch::Torch<Context>::Traits::tensorTy);
-        lua_rawseti(L, -2, i + 1);
-      }
-    }
-    int err = lua_pcall(L, 2, 0, 0);
-    CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L, -1));
-    if (paramBlobs.size() != 0) {
-      lua_getfield(L, -1, "parameters");
-      lua_pushvalue(L, -2);
-      int err2 = lua_pcall(L, 1, LUA_MULTRET, 0);
-      CAFFE_ENFORCE_EQ(err2, 0);
-      CAFFE_ENFORCE_EQ(lua_gettop(L), 3);
-      lua_pushnil(L);
-      int i = 0;
-      while (lua_next(L, -3) && i < paramBlobs.size()) {
-        CAFFE_ENFORCE(
-            luaT_isudata(L, -1, torch::Torch<Context>::Traits::tensorTy));
-        auto* param =
-            static_cast<typename torch::Torch<Context>::Traits::Tensor*>(
-                luaT_toudata(L, -1, torch::Torch<Context>::Traits::tensorTy));
-        auto paramShape = state_.tensorShape(param);
-        auto* blob = paramBlobs[i];
-        auto* tc = blob->template GetMutable<Tensor<Context>>();
-        if (tc->size() == 0) {
-          tc->Resize(paramShape);
-          tc->template mutable_data<float>();
-        } else {
-          CAFFE_ENFORCE(tc->dims() == paramShape);
-        }
-        lua_pop(L, 1);
-        i++;
-      }
-      CAFFE_ENFORCE_EQ(i, paramBlobs.size());
-      lua_pop(L, 2);
-    }
-    lua_getfield(L, -1, "output");
-    if (outputBlobs.size() == 0) {
-    } else if (outputBlobs.size() == 1) {
-      CAFFE_ENFORCE(
-          luaT_isudata(L, -1, torch::Torch<Context>::Traits::tensorTy));
-      auto* output =
-          static_cast<typename torch::Torch<Context>::Traits::Tensor*>(
-              luaT_toudata(L, -1, torch::Torch<Context>::Traits::tensorTy));
-      auto outputShape = state_.tensorShape(output);
-      auto* blob = outputBlobs[0];
-      auto* tc = blob->template GetMutable<Tensor<Context>>();
-      tc->Resize(outputShape);
-      tc->template mutable_data<float>();
-    } else {
-      lua_pushnil(L);
-      auto i = 0;
-      while (lua_next(L, -2) && i < outputBlobs.size()) {
-        CAFFE_ENFORCE(
-            luaT_isudata(L, -1, torch::Torch<Context>::Traits::tensorTy));
-        auto* output =
-            static_cast<typename torch::Torch<Context>::Traits::Tensor*>(
-                luaT_toudata(L, -1, torch::Torch<Context>::Traits::tensorTy));
-        auto outputShape = state_.tensorShape(output);
-        auto* blob = outputBlobs[i];
-        auto* tc = blob->template GetMutable<Tensor<Context>>();
-        if (tc->size() == 0) {
-          tc->Resize(outputShape);
-          tc->template mutable_data<float>();
-        } else {
-          CAFFE_ENFORCE(tc->dims() == outputShape);
-        }
-        ++i;
-      }
-      CAFFE_ENFORCE_EQ(i, outputBlobs.size());
-    }
-    lua_pop(L, 2);
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-
-    cachedInputSizes_.clear();
-    for (const auto* blob : inputBlobs) {
-      const auto& dims = blob->template Get<Tensor<Context>>().dims();
-      cachedInputSizes_.push_back(dims);
-    }
-  }
-
- protected:
-  torch::Torch<Context> state_;
-  int self_{0};
-  std::vector<std::vector<TIndex>> cachedInputSizes_;
-};
-
-template <typename Context>
-class TorchOp : public TorchOpBase<Context> {
- public:
-  USE_OPERATOR_CONTEXT_FUNCTIONS;
-  using OperatorBase::Outputs;
-  using OperatorBase::Inputs;
-  using TorchOpBase<Context>::state_;
-  using TorchOpBase<Context>::self_;
-
-  using TorchOpBase<Context>::TorchOpBase;
-
-  bool RunOnDevice() final {
-    const auto numInputs =
-        OperatorBase::GetSingleArgument<int>("num_inputs", 1);
-    const auto numParams =
-        OperatorBase::GetSingleArgument<int>("num_params", 0);
-    const auto numOutputs =
-        OperatorBase::GetSingleArgument<int>("num_outputs", 1);
-    CAFFE_ENFORCE_EQ(InputSize(), numInputs + numParams);
-    CAFFE_ENFORCE_EQ(OutputSize(), numOutputs);
-
-    std::vector<Blob*> inputBlobs;
-    for (auto i = 0; i < numInputs; ++i) {
-      inputBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    std::vector<Blob*> paramBlobs;
-    for (auto i = numInputs; i < numInputs + numParams; ++i) {
-      paramBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    // Outputs must already be pre-sized
-    this->reshapeBlobs(inputBlobs, paramBlobs, Outputs());
-
-    lua_State* L = state_.L();
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-    state_.setContext(&context_);
-
-    // Deserialize self table
-    lua_rawgeti(L, LUA_REGISTRYINDEX, self_);
-
-    auto torchOutputs = state_.pushTable(Outputs());
-    // set the output field
-    lua_setfield(L, -2, "output");
-    // set the parameters
-    if (numParams != 0) {
-      // get the parameters into the stack
-      lua_getfield(L, -1, "parameters");
-      lua_pushvalue(L, -2);
-      int err = lua_pcall(L, 1, 1, 0);
-      CAFFE_ENFORCE_EQ(err, 0);
-      // iterate the parameters table to put tblobs inside
-      lua_pushnil(L);
-      auto i = 0;
-      while (lua_next(L, -2) && i < numParams) {
-        CAFFE_ENFORCE(
-            luaT_isudata(L, -1, state_.tensorTy(*paramBlobs[i])),
-            luaT_typename(L, -1));
-        auto* udata = luaT_toudata(L, -1, state_.tensorTy(*paramBlobs[i]));
-        state_.setTensor(
-            static_cast<typename torch::Torch<Context>::Traits::Tensor*>(udata),
-            const_cast<Blob*>(paramBlobs[i]));
-        i++;
-        lua_pop(L, 1);
-      }
-      CAFFE_ENFORCE_EQ(i, numParams);
-      lua_pop(L, 1); // pop the parameter table
-    }
-    // call updateOutput
-    // | self
-    lua_getfield(L, -1, "updateOutput");
-    // | self | updateOutput
-    lua_pushvalue(L, -2);
-    // | self | updateOutput | self
-    auto torchInputs = state_.pushTable(inputBlobs);
-    // | self | updateOutput | self | inputs
-    int err = lua_pcall(L, 2, 1, 0); // doesn't need the output
-    CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L, -1));
-    state_.verifyOutputs(Outputs(), torchOutputs);
-    lua_pop(L, 2);
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-    return true;
-  }
-};
-
-template <typename Context>
-class TorchInitOp : public TorchOpBase<Context> {
- public:
-  USE_OPERATOR_CONTEXT_FUNCTIONS;
-  using OperatorBase::Outputs;
-  using OperatorBase::Inputs;
-  using TorchOpBase<Context>::TorchOpBase;
-
-  bool RunOnDevice() final {
-    const auto numInputs =
-        OperatorBase::GetSingleArgument<int>("num_inputs", 1);
-    const auto numParams =
-        OperatorBase::GetSingleArgument<int>("num_params", 0);
-    const auto numOutputs =
-        OperatorBase::GetSingleArgument<int>("num_outputs", 1);
-    std::vector<Blob*> inputBlobs;
-    for (auto i = 0; i < numInputs; ++i) {
-      inputBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    std::vector<Blob*> paramBlobs;
-    for (auto i = numInputs; i < numInputs + numParams; ++i) {
-      paramBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    this->reshapeBlobs(inputBlobs, paramBlobs, Outputs());
-    return true;
-  }
-};
-
-template <typename Context>
-class TorchGradientOp : public TorchOpBase<Context> {
- public:
-  USE_OPERATOR_CONTEXT_FUNCTIONS;
-  using OperatorBase::Outputs;
-  using OperatorBase::Inputs;
-  using TorchOpBase<Context>::state_;
-  using TorchOpBase<Context>::self_;
-  using TorchOpBase<Context>::TorchOpBase;
-
-  bool RunOnDevice() final {
-    const auto numInputs =
-        OperatorBase::GetSingleArgument<int>("num_inputs", 1);
-    const auto numParams =
-        OperatorBase::GetSingleArgument<int>("num_params", 0);
-    const auto numOutputs =
-        OperatorBase::GetSingleArgument<int>("num_outputs", 1);
-    lua_State* L = state_.L();
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-    // inputs, params, outputs, grad outputs
-    CAFFE_ENFORCE_EQ(InputSize(), numInputs + numParams + 2 * numOutputs);
-    // grad inputs, grad params
-    CAFFE_ENFORCE_EQ(OutputSize(), numInputs + numParams);
-    state_.setContext(&context_);
-
-    std::vector<Blob*> outputBlobs;
-    for (auto i = numInputs + numParams; i < numInputs + numParams + numOutputs;
-         ++i) {
-      outputBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    std::vector<Blob*> inputBlobs;
-    for (auto i = 0; i < numInputs; ++i) {
-      inputBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    std::vector<Blob*> gradOutputBlobs;
-    for (auto i = numInputs + numParams + numOutputs;
-         i < numInputs + numParams + numOutputs + numOutputs;
-         ++i) {
-      gradOutputBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    std::vector<Blob*> gradInputBlobs;
-    for (auto i = 0; i < numInputs; ++i) {
-      gradInputBlobs.push_back(Outputs()[i]);
-    }
-    std::vector<Blob*> paramBlobs;
-    for (auto i = numInputs; i < numInputs + numParams; ++i) {
-      paramBlobs.push_back(const_cast<Blob*>(Inputs()[i]));
-    }
-    std::vector<Blob*> gradParamBlobs;
-    for (auto i = numInputs; i < numInputs + numParams; ++i) {
-      gradParamBlobs.push_back(Outputs()[i]);
-    }
-
-    // Ensure shapes are correct.
-    for (auto i = 0; i < OutputSize(); ++i) {
-      Output(i)->ResizeLike(Input(i));
-      Output(i)->template mutable_data<float>();
-    }
-
-    lua_rawgeti(L, LUA_REGISTRYINDEX, self_);
-    state_.pushTable(outputBlobs);
-    lua_setfield(L, -2, "output");
-
-    const auto& torchGradInputs = state_.pushTable(gradInputBlobs);
-    lua_setfield(L, -2, "gradInput");
-    if (numParams != 0) {
-      // get the parameters into the stack
-      lua_getfield(L, -1, "parameters");
-      lua_pushvalue(L, -2);
-      int err = lua_pcall(L, 1, LUA_MULTRET, 0);
-      CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L, -1));
-      // iterate the parameters table to put tblobs inside
-      lua_pushnil(L);
-      auto i = 0;
-      while (lua_next(L, -3) && i < numParams) {
-        CAFFE_ENFORCE(luaT_isudata(L, -1, state_.tensorTy(*paramBlobs[i])));
-        auto* udata = luaT_toudata(L, -1, state_.tensorTy(*paramBlobs[i]));
-        state_.setTensor(
-            static_cast<typename torch::Torch<Context>::Traits::Tensor*>(udata),
-            const_cast<Blob*>(paramBlobs[i]));
-        i++;
-        lua_pop(L, 1);
-      }
-      CAFFE_ENFORCE_EQ(i, numParams);
-      // iterate the grad of params
-      lua_pushnil(L);
-      i = 0;
-      while (lua_next(L, -2) && i < numParams) {
-        CAFFE_ENFORCE(luaT_isudata(L, -1, state_.tensorTy(*gradParamBlobs[i])));
-        auto* udata = luaT_toudata(L, -1, state_.tensorTy(*gradParamBlobs[i]));
-        state_.setTensor(
-            static_cast<typename torch::Torch<Context>::Traits::Tensor*>(udata),
-            const_cast<Blob*>(gradParamBlobs[i]));
-        i++;
-        lua_pop(L, 1);
-      }
-      CAFFE_ENFORCE_EQ(i, numParams);
-      lua_pop(L, 2); // pop the parameters
-    }
-    lua_getfield(L, -1, "zeroGradParameters");
-    lua_pushvalue(L, -2);
-    CAFFE_ENFORCE_EQ(lua_pcall(L, 1, 0, 0), 0);
-    state_.pushTable(inputBlobs);
-    state_.pushTable(gradOutputBlobs);
-    // call
-    lua_getfield(L, -3, "accGradParameters");
-    lua_pushvalue(L, -4);
-    lua_pushvalue(L, -4);
-    lua_pushvalue(L, -4);
-    lua_pushnumber(L, 1);
-    int err = lua_pcall(L, 4, 0, 0); // doesn't need the output
-    CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L, -1));
-    lua_getfield(L, -3, "updateGradInput");
-    lua_pushvalue(L, -4);
-    lua_pushvalue(L, -4);
-    lua_pushvalue(L, -4);
-    err = lua_pcall(L, 3, 1, 0); // doesn't need the output
-    CAFFE_ENFORCE_EQ(err, 0, lua_tostring(L, -1));
-    state_.verifyOutputs(gradInputBlobs, torchGradInputs);
-    lua_pop(L, 4);
-    CAFFE_ENFORCE_EQ(lua_gettop(L), 0);
-    return true;
-  }
-};
-}
diff --git a/caffe2/contrib/torch/torch_op_gpu.cpp b/caffe2/contrib/torch/torch_op_gpu.cpp
deleted file mode 100644
index 5cfea19cba6f2..0000000000000
--- a/caffe2/contrib/torch/torch_op_gpu.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-#include "caffe2/core/context_gpu.h"
-#include "torch_op.h"
-
-extern "C" {
-#include <THCStorage.h>
-#include <THCTensor.h>
-#include <THCStream.h>
-}
-
-namespace caffe2 {
-
-namespace torch {
-
-template <>
-struct TyTraits<CUDAContext> {
-  static const char* moduleTy;
-  static const char* prelude;
-  static const char* tensorTy;
-  using Tensor = THCudaTensor;
-};
-
-const char* TyTraits<CUDAContext>::tensorTy = "torch.CudaTensor";
-const char* TyTraits<CUDAContext>::moduleTy = "cuda";
-const char* TyTraits<CUDAContext>::prelude = R"(
-        require 'torch'
-        require 'nn'
-        require 'cunn'
-)";
-
-THCState* cudaState(Torch<CUDAContext>* t) {
-  auto* L = t->L();
-  lua_getglobal(L, "cutorch");
-  CAFFE_ENFORCE(!lua_isnil(L, -1));
-  lua_getfield(L, -1, "_state");
-  CAFFE_ENFORCE(!lua_isnil(L, -1));
-  THCState* state = reinterpret_cast<THCState*>(lua_touserdata(L, -1));
-  lua_pop(L, 2);
-  return state;
-}
-
-template <>
-void Torch<CUDAContext>::setContext(CUDAContext* context) {
-  THCState *state = cudaState(this);
-  THCStream* stream = THCState_getStream(state);
-  THCudaCheck(cudaStreamDestroy(stream->stream));
-  stream->stream = context->cuda_stream();
-}
-
-template <>
-void Torch<CUDAContext>::setTensor(typename Traits::Tensor* t, Blob* blob) {
-  CAFFE_ENFORCE_EQ(tensorTy(*blob), Traits::tensorTy);
-  auto* cs = cudaState(this);
-  auto* tc = blob->template GetMutable<Tensor<CUDAContext>>();
-  CAFFE_ENFORCE_EQ(THCudaTensor_nElement(cs, t), tc->size());
-  THCudaStorage* storage = THCudaStorage_newWithData(
-      cs, tc->template mutable_data<float>(), tc->size());
-  THCudaStorage_clearFlag(cs, storage, TH_STORAGE_FREEMEM);
-  THCudaStorage* original = t->storage;
-  t->storage = storage;
-  THCudaStorage_free(cs, original);
-}
-
-template <>
-typename Torch<CUDAContext>::Traits::Tensor* Torch<CUDAContext>::blobToTensor(
-    Blob* blob) {
-  CAFFE_ENFORCE_EQ(tensorTy(*blob), Traits::tensorTy);
-  auto* cs = cudaState(this);
-  auto* tc = blob->template GetMutable<Tensor<CUDAContext>>();
-
-  size_t size = tc->size();
-  THLongStorage* thshape = THLongStorage_newWithSize(tc->ndim());
-  for (int i = 0; i < tc->ndim(); ++i) {
-    THLongStorage_set(thshape, i, tc->dim(i));
-  }
-  THCudaStorage* storage =
-      THCudaStorage_newWithData(cs, tc->template mutable_data<float>(), size);
-  THCudaStorage_clearFlag(cs, storage, TH_STORAGE_FREEMEM);
-  auto* th = THCudaTensor_newWithStorage(cs, storage, 0, thshape, nullptr);
-  THCudaStorage_free(cs, storage);
-  THLongStorage_free(thshape);
-  CAFFE_ENFORCE_EQ(
-      THCudaTensor_storage(cs, th)->data, tc->template mutable_data<float>());
-  return th;
-}
-
-template <>
-std::vector<TIndex> Torch<CUDAContext>::tensorShape(
-    typename Traits::Tensor* t) {
-  auto* cs = cudaState(this);
-  auto* size = t->size;
-  return std::vector<TIndex>(size, size + THCudaTensor_nDimension(cs, t));
-}
-
-template <>
-typename Torch<CUDAContext>::Traits::Tensor* Torch<CUDAContext>::newTensorAs(
-    const Tensor<CUDAContext>& tc) {
-  auto* cs = cudaState(this);
-  THLongStorage* thshape = THLongStorage_newWithSize(tc.ndim());
-  for (uint32_t i = 0; i < tc.ndim(); ++i) {
-    THLongStorage_set(thshape, i, tc.dim(i));
-  }
-  THCudaTensor* d = THCudaTensor_newWithSize(cs, thshape, nullptr);
-  THLongStorage_free(thshape);
-  return d;
-}
-}
-
-REGISTER_CUDA_OPERATOR(Torch, TorchOp<CUDAContext>);
-REGISTER_CUDA_OPERATOR(TorchGradient, TorchGradientOp<CUDAContext>);
-}
diff --git a/caffe2/contrib/torch/torch_ops_test.py b/caffe2/contrib/torch/torch_ops_test.py
deleted file mode 100644
index dd9c080946469..0000000000000
--- a/caffe2/contrib/torch/torch_ops_test.py
+++ /dev/null
@@ -1,135 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-from caffe2.python import core, dyndep
-import caffe2.python.hypothesis_test_util as hu
-
-from hypothesis import given
-import hypothesis.strategies as st
-import numpy as np
-import os
-import unittest
-
-try:
-    from libfb.py import parutil
-except ImportError as e:
-    # If libfb not found, skip all tests in this file
-    raise unittest.SkipTest(str(e))
-
-core.GlobalInit(["python", "--caffe2_log_level=0"])
-
-dyndep.InitOpsLibrary('@/caffe2/caffe2/contrib/torch:torch_ops')
-
-RUNTIME = parutil.get_runtime_path()
-if 'LUA_PATH' not in os.environ:
-    os.environ['LUA_PATH'] = ";".join([
-        os.path.join(RUNTIME, '_lua', '?.lua'),
-        os.path.join(RUNTIME, '_lua', '?', 'init.lua'),
-    ])
-    os.environ['LUA_CPATH'] = os.path.join(RUNTIME, '_lua', '?.so')
-
-
-class TorchOpTest(hu.HypothesisTestCase):
-    @given(n=st.integers(min_value=1, max_value=10),
-           i=st.integers(min_value=1, max_value=10),
-           h=st.integers(min_value=2, max_value=10))
-    def test_feed(self, n, i, h):
-        op = core.CreateOperator(
-            "Torch", ["x", "W", "b"], ["y"],
-            init=b"nn.Linear({i}, {h})".format(h=h, i=i),
-            num_inputs=1,
-            num_params=2,
-            num_outputs=1
-        )
-        x = np.random.randn(n, i).astype(np.float32)
-        W = np.random.randn(h, i).astype(np.float32)
-        b = np.random.randn(h).astype(np.float32)
-        self.ws.create_blob("x").feed(x)
-        self.ws.create_blob("W").feed(W)
-        self.ws.create_blob("b").feed(b)
-        self.ws.run(op)
-        y = self.ws.blobs["y"].fetch()
-        print("y", y)
-        y = y.reshape((n, h))
-        np.testing.assert_allclose(y, np.dot(x, W.T) + b, atol=1e-4, rtol=1e-4)
-
-    @given(n=st.integers(min_value=1, max_value=10),
-           i=st.integers(min_value=1, max_value=10),
-           h=st.integers(min_value=2, max_value=10),
-           **hu.gcs)
-    def test_gradient(self, n, i, h, gc, dc):
-        op = core.CreateOperator(
-            "Torch", ["x", "W", "b"], ["y"],
-            init=b"nn.Linear({i}, {h})".format(h=h, i=i),
-            num_inputs=1,
-            num_params=2,
-            num_outputs=1
-        )
-        x = np.random.randn(n, i).astype(np.float32)
-        W = np.random.randn(h, i).astype(np.float32)
-        b = np.random.randn(h).astype(np.float32)
-        inputs = [x, W, b]
-        self.assertDeviceChecks(dc, op, inputs, [0])
-        for i, _ in enumerate(inputs):
-            self.assertGradientChecks(gc, op, inputs, i, [0])
-
-    @given(n=st.integers(min_value=1, max_value=10),
-           i=st.integers(min_value=1, max_value=10),
-           h=st.integers(min_value=2, max_value=10),
-           iters=st.integers(min_value=1, max_value=100))
-    def test_iterated(self, n, i, h, iters):
-        x = np.random.randn(n, i).astype(np.float32)
-        W = np.random.randn(h, i).astype(np.float32)
-        b = np.random.randn(h).astype(np.float32)
-        self.ws.create_blob("x").feed(x)
-        self.ws.create_blob("W").feed(W)
-        self.ws.create_blob("b").feed(b)
-        net = core.Net("op")
-        net.Torch(
-            ["x", "W", "b"], ["y"],
-            init=b"nn.Linear({i}, {h})".format(h=h, i=i),
-            num_inputs=1,
-            num_params=2,
-            num_outputs=1
-        )
-        print(net.Proto())
-        net_ = self.ws.create_net(net)
-        for i in range(iters):
-            if i % 1000 == 0:
-                print(i)
-            net_.run()
-
-        y = self.ws.blobs["y"].fetch()
-        y = y.reshape((n, h))
-        np.testing.assert_allclose(y, np.dot(x, W.T) + b, atol=1e-4, rtol=1e-4)
-
-    def test_leakage_torch(self):
-        n = 1
-        i = 100
-        h = 1000
-        iters = 2000
-        x = np.random.randn(n, i).astype(np.float32)
-        W = np.random.randn(h, i).astype(np.float32)
-        b = np.random.randn(h).astype(np.float32)
-        self.ws.create_blob("x").feed(x)
-        self.ws.create_blob("W").feed(W)
-        self.ws.create_blob("b").feed(b)
-        net = core.Net("op")
-        net.Torch(
-            ["x", "W", "b"], ["y"],
-            init=b"nn.Linear({i}, {h})".format(h=h, i=i),
-            num_inputs=1,
-            num_params=2,
-            num_outputs=1
-        )
-        net_ = self.ws.create_net(net)
-        for i in range(iters):
-            if i % 1000 == 0:
-                print(i)
-            net_.run()
-
-        y = self.ws.blobs["y"].fetch()
-        y = y.reshape((n, h))
-        np.testing.assert_allclose(y, np.dot(x, W.T) + b, atol=1e-4, rtol=1e-4)

From 601ebe888cd96f124ba5c21adf8d5353be849176 Mon Sep 17 00:00:00 2001
From: Frank Jiang <ffjiang@fb.com>
Date: Tue, 12 Jun 2018 09:55:00 -0700
Subject: [PATCH 060/118] Fix linearWarmup multiplier check

The multiplier needs to be non-negative, not strictly positive.
---
 caffe2/sgd/learning_rate_op.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/caffe2/sgd/learning_rate_op.h b/caffe2/sgd/learning_rate_op.h
index 41b314239e987..0a47b6c5fd6d5 100644
--- a/caffe2/sgd/learning_rate_op.h
+++ b/caffe2/sgd/learning_rate_op.h
@@ -118,7 +118,7 @@ class LearningRateOp final : public Operator<Context> {
           arg_prefix + "start_multiplier", 0.);
       int num_iter = OperatorBase::template GetSingleArgument<int>(
           arg_prefix + "num_iter", 0);
-      DCHECK_GT(start_multiplier, 0);
+      DCHECK_GE(start_multiplier, 0);
       return new LinearWarmupLearningRate<T>(start_multiplier, num_iter);
     } else if (policy == "constantWarmup") {
       T multiplier = OperatorBase::template GetSingleArgument<float>(

From 9e5eaa14fad141cf5f010b218474af0dfac1dca3 Mon Sep 17 00:00:00 2001
From: Yangqing Jia <jiayq@fb.com>
Date: Tue, 12 Jun 2018 09:55:31 -0700
Subject: [PATCH 061/118] Revert D3314316

This is after 2 years and we do not seem to have a use case for this one, so
for the sake of clean API design we should potentially remove this. This would
allow us to potentially pass in arguments to optionally construct an object,
although it is indeed a little bit unclear how we can reuse existing objects if
constructor arguments are passed in. In any case, we may want to remove this
dangling feature.
---
 caffe2/python/onnx/tests/onnx_backend_test.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/caffe2/python/onnx/tests/onnx_backend_test.py b/caffe2/python/onnx/tests/onnx_backend_test.py
index b3c7493c96d33..4c9c3ea848fba 100644
--- a/caffe2/python/onnx/tests/onnx_backend_test.py
+++ b/caffe2/python/onnx/tests/onnx_backend_test.py
@@ -47,7 +47,8 @@
                      '|test_rnn_seq_length'
                      '|test_operator_add.*_cuda'
                      '|test_operator_lstm_cuda'
-                     '|test_operator_rnn.*_cuda)')
+                     '|test_operator_rnn.*_cuda'
+                     '|test_lrn_default_cuda)')
 
 # Temporarily skip some ONNX backend tests with broadcasting.
 backend_test.exclude('(test_xor_bcast'

From 5c6b236124a55c2bbf9c4f3e598290ac03ac3e69 Mon Sep 17 00:00:00 2001
From: Peizhao Zhang <stzpz@fb.com>
Date: Tue, 12 Jun 2018 09:56:05 -0700
Subject: [PATCH 062/118] Speedup generate proposals by partial_sort.

Speedup generate proposals by partial_sort.

FACEBOOK:
- Saw speed improvement for training with this op.
- Yanghan benchmarked the op on a small dataset and see consistent 100% improvement on speed (6ms -> 3ms) on 420 input resolution. See next diff for details.
---
 caffe2/operators/generate_proposals_op.cc | 52 +++++++++++++++--------
 1 file changed, 35 insertions(+), 17 deletions(-)

diff --git a/caffe2/operators/generate_proposals_op.cc b/caffe2/operators/generate_proposals_op.cc
index bb1f2f6bf2bdd..6caf0b19e48ff 100644
--- a/caffe2/operators/generate_proposals_op.cc
+++ b/caffe2/operators/generate_proposals_op.cc
@@ -103,7 +103,6 @@ void GenerateProposalsOp<CPUContext>::ProposalsForOneImage(
     const utils::ConstTensorView<float>& scores_tensor,
     ERArrXXf* out_boxes,
     EArrXf* out_probs) const {
-  const auto& pre_nms_topN = rpn_pre_nms_topN_;
   const auto& post_nms_topN = rpn_post_nms_topN_;
   const auto& nms_thresh = rpn_nms_thresh_;
   const auto& min_size = rpn_min_size_;
@@ -139,11 +138,39 @@ void GenerateProposalsOp<CPUContext>::ProposalsForOneImage(
   Eigen::Map<ERMatXf>(scores.data(), H * W, A) =
       Eigen::Map<const ERMatXf>(scores_tensor.data(), A, H * W).transpose();
 
+  std::vector<int> order(scores.size());
+  std::iota(order.begin(), order.end(), 0);
+  if (rpn_pre_nms_topN_ <= 0 || rpn_pre_nms_topN_ >= scores.size()) {
+    // 4. sort all (proposal, score) pairs by score from highest to lowest
+    // 5. take top pre_nms_topN (e.g. 6000)
+    std::sort(order.begin(), order.end(), [&scores](int lhs, int rhs) {
+      return scores[lhs] > scores[rhs];
+    });
+  } else {
+    // Avoid sorting possibly large arrays; First partition to get top K
+    // unsorted and then sort just those (~20x faster for 200k scores)
+    std::partial_sort(
+        order.begin(),
+        order.begin() + rpn_pre_nms_topN_,
+        order.end(),
+        [&scores](int lhs, int rhs) { return scores[lhs] > scores[rhs]; });
+    order.resize(rpn_pre_nms_topN_);
+  }
+
+  ERArrXXf bbox_deltas_sorted;
+  ERArrXXf all_anchors_sorted;
+  EArrXf scores_sorted;
+  utils::GetSubArrayRows(
+      bbox_deltas, utils::AsEArrXt(order), &bbox_deltas_sorted);
+  utils::GetSubArrayRows(
+      all_anchors.array(), utils::AsEArrXt(order), &all_anchors_sorted);
+  utils::GetSubArray(scores, utils::AsEArrXt(order), &scores_sorted);
+
   // Transform anchors into proposals via bbox transformations
   static const std::vector<float> bbox_weights{1.0, 1.0, 1.0, 1.0};
   auto proposals = utils::bbox_transform(
-      all_anchors.array(),
-      bbox_deltas,
+      all_anchors_sorted,
+      bbox_deltas_sorted,
       bbox_weights,
       utils::BBOX_XFORM_CLIP_DEFAULT,
       correct_transform_coords_);
@@ -154,30 +181,21 @@ void GenerateProposalsOp<CPUContext>::ProposalsForOneImage(
 
   // 3. remove predicted boxes with either height or width < min_size
   auto keep = utils::filter_boxes(proposals, min_size, im_info);
-  DCHECK_LE(keep.size(), scores.size());
-
-  // 4. sort all (proposal, score) pairs by score from highest to lowest
-  // 5. take top pre_nms_topN (e.g. 6000)
-  std::sort(keep.begin(), keep.end(), [&scores](int lhs, int rhs) {
-    return scores[lhs] > scores[rhs];
-  });
-
-  if (pre_nms_topN > 0 && pre_nms_topN < keep.size()) {
-    keep.resize(pre_nms_topN);
-  }
+  DCHECK_LE(keep.size(), scores_sorted.size());
 
   // 6. apply loose nms (e.g. threshold = 0.7)
   // 7. take after_nms_topN (e.g. 300)
   // 8. return the top proposals (-> RoIs top)
   if (post_nms_topN > 0 && post_nms_topN < keep.size()) {
-    keep = utils::nms_cpu(proposals, scores, keep, nms_thresh, post_nms_topN);
+    keep = utils::nms_cpu(
+        proposals, scores_sorted, keep, nms_thresh, post_nms_topN);
   } else {
-    keep = utils::nms_cpu(proposals, scores, keep, nms_thresh);
+    keep = utils::nms_cpu(proposals, scores_sorted, keep, nms_thresh);
   }
 
   // Generate outputs
   utils::GetSubArrayRows(proposals, utils::AsEArrXt(keep), out_boxes);
-  utils::GetSubArray(scores, utils::AsEArrXt(keep), out_probs);
+  utils::GetSubArray(scores_sorted, utils::AsEArrXt(keep), out_probs);
 }
 
 template <>

From 2a30b50d1fe73b2de3f004a1caf970adeadaf7b6 Mon Sep 17 00:00:00 2001
From: Peizhao Zhang <stzpz@fb.com>
Date: Tue, 12 Jun 2018 09:56:10 -0700
Subject: [PATCH 063/118] More parallel processing friendly for CPP version of
 GenerateProposals.

More parallel processing friendly for CPP version of GenerateProposals.
---
 caffe2/operators/generate_proposals_op.cc | 35 ++++++++++++++---------
 1 file changed, 21 insertions(+), 14 deletions(-)

diff --git a/caffe2/operators/generate_proposals_op.cc b/caffe2/operators/generate_proposals_op.cc
index 6caf0b19e48ff..49cb0315eb3f9 100644
--- a/caffe2/operators/generate_proposals_op.cc
+++ b/caffe2/operators/generate_proposals_op.cc
@@ -242,14 +242,15 @@ bool GenerateProposalsOp<CPUContext>::RunOnDevice() {
   out_rois->Resize(0, roi_col_count);
   out_rois_probs->Resize(0);
 
-  // Use openmp for acceleration?
+  std::vector<ERArrXXf> im_boxes(num_images);
+  std::vector<EArrXf> im_probs(num_images);
   for (int i = 0; i < num_images; i++) {
     auto cur_im_info = im_info.row(i);
     auto cur_bbox_deltas = GetSubTensorView<float>(bbox_deltas, i);
     auto cur_scores = GetSubTensorView<float>(scores, i);
 
-    ERArrXXf im_i_boxes;
-    EArrXf im_i_probs;
+    ERArrXXf& im_i_boxes = im_boxes[i];
+    EArrXf& im_i_probs = im_probs[i];
     ProposalsForOneImage(
         cur_im_info,
         all_anchors,
@@ -257,25 +258,31 @@ bool GenerateProposalsOp<CPUContext>::RunOnDevice() {
         cur_scores,
         &im_i_boxes,
         &im_i_probs);
+  }
 
+  int roi_counts = 0;
+  for (int i = 0; i < num_images; i++) {
+    roi_counts += im_boxes[i].rows();
+  }
+  out_rois->Extend(roi_counts, 50, &context_);
+  out_rois_probs->Extend(roi_counts, 50, &context_);
+  float* out_rois_ptr = out_rois->mutable_data<float>();
+  float* out_rois_probs_ptr = out_rois_probs->mutable_data<float>();
+  for (int i = 0; i < num_images; i++) {
+    const ERArrXXf& im_i_boxes = im_boxes[i];
+    const EArrXf& im_i_probs = im_probs[i];
     int csz = im_i_boxes.rows();
-    int cur_start_idx = out_rois->dim(0);
-
-    out_rois->Extend(csz, 50, &context_);
-    out_rois_probs->Extend(csz, 50, &context_);
 
     // write rois
-    Eigen::Map<ERArrXXf> cur_rois(
-        out_rois->mutable_data<float>() + cur_start_idx * roi_col_count,
-        csz,
-        5);
+    Eigen::Map<ERArrXXf> cur_rois(out_rois_ptr, csz, 5);
     cur_rois.col(0).setConstant(i);
     cur_rois.block(0, 1, csz, 4) = im_i_boxes;
 
     // write rois_probs
-    Eigen::Map<EArrXf>(
-        out_rois_probs->mutable_data<float>() + cur_start_idx, csz) =
-        im_i_probs;
+    Eigen::Map<EArrXf>(out_rois_probs_ptr, csz) = im_i_probs;
+
+    out_rois_ptr += csz * roi_col_count;
+    out_rois_probs_ptr += csz;
   }
 
   return true;

From fbac668973a0928866620d74f45fea1d3794e6dc Mon Sep 17 00:00:00 2001
From: Qinqing Zheng <zqq@fb.com>
Date: Tue, 12 Jun 2018 09:56:31 -0700
Subject: [PATCH 064/118] [DT] [43/n] Lift stop conditions inside reader code
 back to flow control

1. Split multi_reader function into local_reader and remote_reader
2. Lifted stop conditions inside Limiter back to flow control
3. Split epoch flow building logic into 3 cases:
  - single machine (1 reader, 1 trainer on trainer0 node, no PS)
  - (1 reader + 1 trainer) on trainer0 node, has PS
  - multiple readers, readers do not share nodes with trainers, might have PS or not
---
 caffe2/ideep/operators/utility_ops.cc | 35 +++++++++++++--------------
 1 file changed, 17 insertions(+), 18 deletions(-)

diff --git a/caffe2/ideep/operators/utility_ops.cc b/caffe2/ideep/operators/utility_ops.cc
index ca6a1437825a8..9a2ec875d426b 100644
--- a/caffe2/ideep/operators/utility_ops.cc
+++ b/caffe2/ideep/operators/utility_ops.cc
@@ -6,29 +6,29 @@ namespace caffe2 {
 
 class CopyCPUToIDEEPOp final : public IDEEPOperator {
  public:
-   USE_SIMPLE_IDEEP_CTOR_DTOR(CopyCPUToIDEEPOp);
-   USE_IDEEP_DEF_ALIASES();
+  USE_SIMPLE_IDEEP_CTOR_DTOR(CopyCPUToIDEEPOp);
+  USE_IDEEP_DEF_ALIASES();
 
-   bool RunOnDevice() override {
-     const auto& X = OperatorBase::Input<TensorCPU>(0);
-     auto* Y = OperatorBase::OutputBlob(0);
-     itensor::dims src_dims(X.dims().begin(), X.dims().end());
-     if (!(Y->template IsType<itensor>() &&
-           Y->Get<itensor>().get_data_type() == itensor::data_type::f32) ||
-         Y->Get<itensor>().get_dims() != src_dims) {
-       Y->Reset(new itensor());
-       Y->GetMutable<itensor>()->resize(src_dims, itensor::data_type::f32);
-     }
-     Y->GetMutable<itensor>()->reorder_from(
-         src_dims, itensor::data_type::f32, X.raw_data());
-     return true;
+  bool RunOnDevice() override {
+    const auto& X = OperatorBase::Input<TensorCPU>(0);
+    auto* Y = OperatorBase::OutputBlob(0);
+    itensor::dims src_dims(X.dims().begin(), X.dims().end());
+    if (!(Y->template IsType<itensor>() &&
+          Y->Get<itensor>().get_data_type() == itensor::data_type::f32) ||
+        Y->Get<itensor>().get_dims() != src_dims) {
+      Y->Reset(new itensor());
+      Y->GetMutable<itensor>()->resize(src_dims, itensor::data_type::f32);
+    }
+    Y->GetMutable<itensor>()->reorder_from(
+        src_dims, itensor::data_type::f32, X.raw_data());
+    return true;
   }
 };
 
 class CopyIDEEPToCPUOp final : public IDEEPOperator {
  public:
-   USE_SIMPLE_IDEEP_CTOR_DTOR(CopyIDEEPToCPUOp);
-   USE_IDEEP_DEF_ALIASES();
+  USE_SIMPLE_IDEEP_CTOR_DTOR(CopyIDEEPToCPUOp);
+  USE_IDEEP_DEF_ALIASES();
   bool RunOnDevice() override {
     const auto& X = OperatorBase::Input<itensor>(0);
     auto* Y = OperatorBase::Output<TensorCPU>(0);
@@ -53,4 +53,3 @@ OPERATOR_SCHEMA(CopyIDEEPToCPU)
     .Output(0, "cpu_blob", "The output TensorCPU to copy to");
 
 } // namespace caffe2
-

From dbfd22f26a239f481b239377bd67d2be85407058 Mon Sep 17 00:00:00 2001
From: Anders Papitto <andersj@fb.com>
Date: Tue, 12 Jun 2018 09:58:03 -0700
Subject: [PATCH 065/118] Resolve conflicts for torch/_thnn/utils.py

---
 tools/nnwrap/generate_wrappers.py    | 1 +
 tools/setup_helpers/generate_code.py | 5 +++++
 2 files changed, 6 insertions(+)

diff --git a/tools/nnwrap/generate_wrappers.py b/tools/nnwrap/generate_wrappers.py
index 1edbca928c17d..19e7aad9dc331 100644
--- a/tools/nnwrap/generate_wrappers.py
+++ b/tools/nnwrap/generate_wrappers.py
@@ -134,3 +134,4 @@ def wrap_cunn(thcunn_h_path, install_dir, template_path):
     cwrap(os.path.join(install_dir, 'THCUNN.cwrap'),
           plugins=[NNExtension('torch._C._THCUNN'), NullableArguments(), AutoGPU(has_self=False)],
           template_path=template_path)
+
diff --git a/tools/setup_helpers/generate_code.py b/tools/setup_helpers/generate_code.py
index c9779fb86972c..c14ae02a305e4 100644
--- a/tools/setup_helpers/generate_code.py
+++ b/tools/setup_helpers/generate_code.py
@@ -89,8 +89,13 @@ def generate_code(ninja_global=None,
     for d in (autograd_gen_dir, jit_gen_dir):
         if not os.path.exists(d):
             os.makedirs(d)
+<<<<<<< HEAD
     gen_autograd(declarations_path or DECLARATIONS_PATH, autograd_gen_dir, 'tools/autograd')
     gen_jit_dispatch(declarations_path or DECLARATIONS_PATH, jit_gen_dir, 'tools/jit/templates')
+=======
+    gen_autograd(declarations_path or DECLARATIONS_PATH, autograd_gen_dir)
+    gen_jit_dispatch(declarations_path or DECLARATIONS_PATH, jit_gen_dir)
+>>>>>>> f5ab3fa... Resolve conflicts for torch/_thnn/utils.py
 
 
 def main():

From a9e05b7fbced732b5a2cb1e97f9cde1866480ec3 Mon Sep 17 00:00:00 2001
From: Aleksandr Ulanov <avulanov@fb.com>
Date: Tue, 12 Jun 2018 09:59:45 -0700
Subject: [PATCH 066/118] [Caffe2] Handle image decoding errors

Image decoding errors can make the whole training fail. This diff is to handle them
1.Catch imdecode exceptions and check if decoded image has zero columns or rows. This is counted as decoding errors.
2.Replace the image with empty in case of error
3.Count the number of errors and throw runtime exception if the rate reaches given number

The empty image data is kept. It might introduce noise in the training data.
---
 caffe2/image/image_input_op.h | 86 ++++++++++++++++++++++++++---------
 1 file changed, 64 insertions(+), 22 deletions(-)

diff --git a/caffe2/image/image_input_op.h b/caffe2/image/image_input_op.h
index 0a4f09fc8b97e..bd9796e588f18 100644
--- a/caffe2/image/image_input_op.h
+++ b/caffe2/image/image_input_op.h
@@ -139,9 +139,13 @@ class ImageInputOp final
   vector<int> random_scale_;
   bool random_scaling_;
 
-
   // Working variables
   std::vector<std::mt19937> randgen_per_thread_;
+
+  // number of exceptions produced by opencv while reading image data
+  std::atomic<long> num_decode_errors_in_batch_{0};
+  // opencv exceptions tolerance
+  float max_decode_error_ratio_;
 };
 
 template <class Context>
@@ -197,8 +201,12 @@ ImageInputOp<Context>::ImageInputOp(
       // output type only supported with CUDA and use_gpu_transform for now
       output_type_(
           cast::GetCastDataType(ArgumentHelper(operator_def), "output_type")),
-      random_scale_(
-          OperatorBase::template GetRepeatedArgument<int>("random_scale", {-1,-1})) {
+      random_scale_(OperatorBase::template GetRepeatedArgument<int>(
+          "random_scale",
+          {-1, -1})),
+      max_decode_error_ratio_(OperatorBase::template GetSingleArgument<float>(
+          "max_decode_error_ratio",
+          0.0)) {
   if ((random_scale_[0] == -1) || (random_scale_[1] == -1)) {
     random_scaling_ = false;
   } else {
@@ -448,13 +456,23 @@ bool ImageInputOp<Context>::GetImageAndLabelAndInfoFromDBValue(
     prefetched_label_.mutable_data<int>()[item_id] = datum.label();
     if (datum.encoded()) {
       // encoded image in datum.
-      src = cv::imdecode(
-          cv::Mat(
-              1,
-              datum.data().size(),
-              CV_8UC1,
-              const_cast<char*>(datum.data().data())),
-          color_ ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);
+      // count the number of exceptions from opencv imdecode
+      try {
+        src = cv::imdecode(
+            cv::Mat(
+                1,
+                datum.data().size(),
+                CV_8UC1,
+                const_cast<char*>(datum.data().data())),
+            color_ ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);
+        if (src.rows == 0 or src.cols == 0) {
+          num_decode_errors_in_batch_++;
+          src = cv::Mat::zeros(cv::Size(224, 224), CV_8UC3);
+        }
+      } catch (cv::Exception& e) {
+        num_decode_errors_in_batch_++;
+        src = cv::Mat::zeros(cv::Size(224, 224), CV_8UC3);
+      }
     } else {
       // Raw image in datum.
       CAFFE_ENFORCE(datum.channels() == 3 || datum.channels() == 1);
@@ -487,6 +505,7 @@ bool ImageInputOp<Context>::GetImageAndLabelAndInfoFromDBValue(
     CAFFE_ENFORCE(protos.ParseFromString(value));
     const TensorProto& image_proto = protos.protos(0);
     const TensorProto& label_proto = protos.protos(1);
+    // add handle protos
     vector<TensorProto> additional_output_protos;
     int start = additional_inputs_offset_;
     int end = start + additional_inputs_count_;
@@ -512,13 +531,23 @@ bool ImageInputOp<Context>::GetImageAndLabelAndInfoFromDBValue(
       const string& encoded_image_str = image_proto.string_data(0);
       int encoded_size = encoded_image_str.size();
       // We use a cv::Mat to wrap the encoded str so we do not need a copy.
-      src = cv::imdecode(
-          cv::Mat(
-              1,
-              &encoded_size,
-              CV_8UC1,
-              const_cast<char*>(encoded_image_str.data())),
-          color_ ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);
+      // count the number of exceptions from opencv imdecode
+      try {
+        src = cv::imdecode(
+            cv::Mat(
+                1,
+                &encoded_size,
+                CV_8UC1,
+                const_cast<char*>(encoded_image_str.data())),
+            color_ ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);
+        if (src.rows == 0 or src.cols == 0) {
+          num_decode_errors_in_batch_++;
+          src = cv::Mat::zeros(cv::Size(224, 224), CV_8UC3);
+        }
+      } catch (cv::Exception& e) {
+        num_decode_errors_in_batch_++;
+        src = cv::Mat::zeros(cv::Size(224, 224), CV_8UC3);
+      }
     } else if (image_proto.data_type() == TensorProto::BYTE) {
       // raw image content.
       int src_c = (image_proto.dims_size() == 3) ? image_proto.dims(2) : 1;
@@ -536,6 +565,7 @@ bool ImageInputOp<Context>::GetImageAndLabelAndInfoFromDBValue(
       LOG(FATAL) << "Unknown image data type.";
     }
 
+    // TODO: if image decoding was unsuccessful, set label to 0
     if (label_proto.data_type() == TensorProto::FLOAT) {
       if (label_type_ == SINGLE_LABEL || label_type_ == SINGLE_LABEL_WEIGHTED) {
         DCHECK_EQ(label_proto.float_data_size(), 1);
@@ -728,6 +758,7 @@ bool ImageInputOp<Context>::GetImageAndLabelAndInfoFromDBValue(
         *img = scaled_img;
       }
   }
+
   // TODO(Yangqing): return false if any error happens.
   return true;
 }
@@ -1030,9 +1061,8 @@ void ImageInputOp<Context>::DecodeAndTransform(
   cv::Mat img;
   // Decode the image
   PerImageArg info;
-  CHECK(GetImageAndLabelAndInfoFromDBValue(value, &img, info, item_id,
-    randgen));
-
+  CHECK(
+      GetImageAndLabelAndInfoFromDBValue(value, &img, info, item_id, randgen));
   // Factor out the image transformation
   TransformImage<Context>(img, channels, image_data,
     color_jitter_, img_saturation_, img_brightness_, img_contrast_,
@@ -1054,8 +1084,8 @@ void ImageInputOp<Context>::DecodeAndTransposeOnly(
   cv::Mat img;
   // Decode the image
   PerImageArg info;
-  CHECK(GetImageAndLabelAndInfoFromDBValue(value, &img, info, item_id,
-    randgen));
+  CHECK(
+      GetImageAndLabelAndInfoFromDBValue(value, &img, info, item_id, randgen));
 
   // Factor out the image transformation
   CropTransposeImage<Context>(img, channels, image_data, crop_, mirror_,
@@ -1154,6 +1184,15 @@ bool ImageInputOp<Context>::Prefetch() {
   }
   thread_pool_->waitWorkComplete();
 
+  // we allow to get at most max_decode_error_ratio from
+  // opencv imdecode until raising a runtime exception
+  if ((float)num_decode_errors_in_batch_ / batch_size_ >
+      max_decode_error_ratio_) {
+    throw std::runtime_error(
+        "max_decode_error_ratio exceeded " +
+        caffe2::to_string(max_decode_error_ratio_));
+  }
+
   // If the context is not CPUContext, we will need to do a copy in the
   // prefetch function as well.
   if (!std::is_same<Context, CPUContext>::value) {
@@ -1165,6 +1204,9 @@ bool ImageInputOp<Context>::Prefetch() {
           prefetched_additional_outputs_[i], &context_);
     }
   }
+
+  num_decode_errors_in_batch_ = 0;
+
   return true;
 }
 

From 6804e1faef0af68e9aa0257bcc5828b66177a75b Mon Sep 17 00:00:00 2001
From: Viswanath Sivakumar <viswanath@fb.com>
Date: Tue, 12 Jun 2018 09:59:51 -0700
Subject: [PATCH 067/118] Update MKL exporter to IDEEP ops

TSIA
---
 caffe2/python/mkl/rewrite_graph.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/caffe2/python/mkl/rewrite_graph.py b/caffe2/python/mkl/rewrite_graph.py
index 60460f3d94627..c81383a3ea97a 100644
--- a/caffe2/python/mkl/rewrite_graph.py
+++ b/caffe2/python/mkl/rewrite_graph.py
@@ -69,7 +69,6 @@ def mkl_tmp(name):
         net.ParseFromString(
                 C.transform_optimizeForIDEEP(net.SerializeToString()))
 
-
 def rewrite_model_helper_simple(model, ideep=True):
     model = copy.deepcopy(model)
     # All parameter initialization should run on MKL

From 04b3dc0d675e349d5cf736152514498ef61c4222 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 10:00:08 -0700
Subject: [PATCH 068/118] [Caffe2] GlobalInit is thread safe, fixing the
 comment

With the mutex and lock, GlobalInit is thread safe.
Update the comments.
---
 caffe2/core/init.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/caffe2/core/init.h b/caffe2/core/init.h
index 4ea7883fd90a1..db3e411c53ea8 100644
--- a/caffe2/core/init.h
+++ b/caffe2/core/init.h
@@ -125,7 +125,7 @@ class GlobalInitIsCalledGuard {
  * successive calls will parse flags and re-set caffe2 logging levels from
  * flags as needed, but NOT re-run early init and init functions.
  *
- * GlobalInit is *NOT* thread-safe and should not be called concurrently.
+ * GlobalInit is also thread-safe and can be called concurrently.
  */
 bool GlobalInit(int* pargc, char*** argv);
 

From cbdfa9e33f52fbac581df23637f4ef4a1e889633 Mon Sep 17 00:00:00 2001
From: Anders Papitto <andersj@fb.com>
Date: Tue, 12 Jun 2018 10:00:11 -0700
Subject: [PATCH 069/118] Back out "Add support for generating ATen files
 during fbcode build"

Original commit changeset: 28970ddba353

@override-unit-failures
(Note: this ignores all push blocking failures!)
---
 aten/src/ATen/Declarations.yaml        | 32527 +++++++++++++++++++++++
 aten/src/ATen/gen.py                   |    16 +-
 tools/autograd/gen_python_functions.py |     6 +-
 tools/autograd/utils.py                |     8 +-
 tools/nnwrap/generate_wrappers.py      |    11 +-
 tools/setup_helpers/generate_code.py   |    16 +-
 6 files changed, 32544 insertions(+), 40 deletions(-)
 create mode 100644 aten/src/ATen/Declarations.yaml

diff --git a/aten/src/ATen/Declarations.yaml b/aten/src/ATen/Declarations.yaml
new file mode 100644
index 0000000000000..e865a8ab30c66
--- /dev/null
+++ b/aten/src/ATen/Declarations.yaml
@@ -0,0 +1,32527 @@
+- name: storage_offset
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: resize_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: numel
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: set_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Storage
+    name: storage
+    type: Storage &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: set_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Storage
+    name: sourceStorage
+    type: Storage &
+  - dynamic_type: int64_t
+    name: storage_offset
+    type: int64_t
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: IntList
+    name: stride
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: set_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: set_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: _fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: value
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: is_contiguous
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: is_set_to
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: masked_fill_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  - dynamic_type: real
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: masked_fill_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: value
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: masked_scatter_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: masked_select_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: masked_select
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nonzero_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nonzero
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: contiguous
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clone
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: view
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: resize_as_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: the_template
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_select_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_select
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _indexCopy_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: take_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: take
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: put_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: accumulate
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_add_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: real
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: value
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: unfold
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dimension
+    type: int64_t
+  - dynamic_type: int64_t
+    name: size
+    type: int64_t
+  - dynamic_type: int64_t
+    name: step
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: _range_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: accreal
+    name: start
+    type: Scalar
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _range
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: accreal
+    name: start
+    type: Scalar
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _arange_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: accreal
+    name: start
+    type: Scalar
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _arange
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: accreal
+    name: start
+    type: Scalar
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _arange_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _arange
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: scatter_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: src
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: scatter_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: real
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: scatter_add_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: src
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gather_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gather
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: data_ptr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: void*
+    name: result
+    type: void*
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: true
+- name: equal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __and___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __and__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __and___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __and__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __iand__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __iand__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __or___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __or__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __or___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __or__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ior__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ior__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __xor___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __xor__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __xor___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __xor__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ixor__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ixor__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __lshift___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __lshift__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __lshift___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __lshift__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ilshift__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ilshift__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __rshift___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __rshift__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __rshift___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __rshift__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __irshift__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __irshift__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: min
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: min_indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: min
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: min_indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: min
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: min_indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: max
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: max_indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: max
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: max_indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: max
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: max_indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kthvalue_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: k
+    type: int64_t
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kthvalue
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: k
+    type: int64_t
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mode_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mode
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: median_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: median
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: median
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sort_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: descending
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sort
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: descending
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: topk_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: k
+    type: int64_t
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: largest
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: sorted
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: topk
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: k
+    type: int64_t
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: largest
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: sorted
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: all_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: all
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: all
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: any_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: any
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: any
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: get_device
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _abs_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _abs
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sigmoid_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sigmoid_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sigmoid
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log10_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log10
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log1p_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log1p
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log2_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log2
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lgamma_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lgamma
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lgamma_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: digamma_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: digamma
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: digamma_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: polygamma_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: n
+    type: int64_t
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: polygamma
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: int64_t
+    name: n
+    type: int64_t
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: polygamma_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: n
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _exp_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _exp
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _expm1_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _expm1
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cos_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cos
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _acos_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _acos
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cosh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cosh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sin_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _asin_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _asin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sinh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sinh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tan_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tan
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _atan_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _atan
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_tanh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_tanh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _erf_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _erf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: erfinv_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: erfinv_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: erfinv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sqrt_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sqrt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _rsqrt_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _rsqrt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _ceil_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _ceil
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _floor_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _floor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _round_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _round
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _trunc_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _trunc
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: frac_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: frac_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: frac
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mean_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mean
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mean
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: var_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: var
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: var
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: std_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: std
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: std
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: norm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: p
+    python_default_init: 2
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: p
+    python_default_init: 2
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 2
+    default_init: 2
+    dynamic_type: real
+    name: p
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: renorm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: p
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: real
+    name: maxnorm
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: renorm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: p
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: real
+    name: maxnorm
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: renorm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: p
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: real
+    name: maxnorm
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: dist
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 2
+    default_init: 2
+    dynamic_type: real
+    name: p
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reciprocal_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reciprocal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reciprocal_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: neg_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: neg
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: neg_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan2_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan2
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan2_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: exponent
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: exponent
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: exponent
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: exponent
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: real
+    name: base
+    type: Scalar
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: real
+    name: base
+    type: Scalar
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: exponent
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: exponent
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lerp_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: end
+    type: const Tensor &
+  - dynamic_type: real
+    name: weight
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lerp
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: end
+    type: const Tensor &
+  - dynamic_type: real
+    name: weight
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lerp_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: end
+    type: const Tensor &
+  - dynamic_type: real
+    name: weight
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _linspace_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: real
+    name: start
+    type: Scalar
+  - dynamic_type: real
+    name: end
+    type: Scalar
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _linspace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: real
+    name: start
+    type: Scalar
+  - dynamic_type: real
+    name: end
+    type: Scalar
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _logspace_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: real
+    name: start
+    type: Scalar
+  - dynamic_type: real
+    name: end
+    type: Scalar
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _logspace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: real
+    name: start
+    type: Scalar
+  - dynamic_type: real
+    name: end
+    type: Scalar
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: histc_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: bins
+    type: int64_t
+  - default: 0
+    default_init: 0
+    dynamic_type: real
+    name: min
+    type: Scalar
+  - default: 0
+    default_init: 0
+    dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: histc
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: bins
+    type: int64_t
+  - default: 0
+    default_init: 0
+    dynamic_type: real
+    name: min
+    type: Scalar
+  - default: 0
+    default_init: 0
+    dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: zero_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sumall
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_sum_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _prodall
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_prod_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cumsum_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cumsum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cumprod_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cumprod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sign_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sign
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sign_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: trace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: other
+    type: SparseTensor
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: other
+    type: SparseTensor
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: SparseTensor
+    name: other
+    type: SparseTensor
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_min_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_min
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_min_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_max_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_max
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_max_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dot
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tril_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tril
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tril_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: triu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: triu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: triu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cross_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cross
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: diag_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: diag
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: mat1
+    type: SparseTensor
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: mat1
+    type: SparseTensor
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: SparseTensor
+    name: mat1
+    type: SparseTensor
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addmv_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addmv
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addmv_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addr_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addr
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addr_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _ger_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _ger
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _mv_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _mv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _mm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _mm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: bmm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: bmm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addbmm_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addbmm
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addbmm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: baddbmm_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: baddbmm
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: baddbmm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcmul_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcmul
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcmul_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcdiv_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcdiv
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcdiv_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _gesv_single_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: solution
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: lu
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: solution
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: lu
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _gesv_single
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: solution
+    type: Tensor
+  - dynamic_type: Tensor
+    name: lu
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gels_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gels
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: trtrs_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: transpose
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: unitriangular
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: trtrs
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: transpose
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: unitriangular
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: symeig_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: eigenvectors
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: symeig
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: eigenvectors
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eig_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: eigenvectors
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eig
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: eigenvectors
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: svd_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res3
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: some
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res3
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: svd
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: some
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res3
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: inverse_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: inverse
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potrf_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potrf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potrs_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potrs
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potri_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potri
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pstrf_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  - default: -1
+    default_init: -1
+    dynamic_type: real
+    name: tol
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pstrf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  - default: -1
+    default_init: -1
+    dynamic_type: real
+    name: tol
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: IntegerTensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: qr_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: qr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: geqrf_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: geqrf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: orgqr_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: orgqr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ormqr_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input3
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: left
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: transpose
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ormqr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input3
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: left
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: transpose
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrifact_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: pivots
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    kwarg_only: true
+    name: pivot
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: pivots
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrifact
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    kwarg_only: true
+    name: pivot
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  - dynamic_type: IntegerTensor
+    name: pivots
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrifact_with_info_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: pivots
+    output: true
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: info
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    kwarg_only: true
+    name: pivot
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: pivots
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: info
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrifact_with_info
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    kwarg_only: true
+    name: pivot
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  - dynamic_type: IntegerTensor
+    name: pivots
+    type: Tensor
+  - dynamic_type: IntegerTensor
+    name: info
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrisolve_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: LU_data
+    type: const Tensor &
+  - dynamic_type: IntegerTensor
+    name: LU_pivots
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrisolve
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: LU_data
+    type: const Tensor &
+  - dynamic_type: IntegerTensor
+    name: LU_pivots
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: random_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: from
+    type: int64_t
+  - dynamic_type: int64_t
+    name: to
+    type: int64_t
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: random_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: to
+    type: int64_t
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: random_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multinomial_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: num_samples
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: replacement
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multinomial
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: num_samples
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: replacement
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: uniform_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: double
+    name: from
+    type: double
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: to
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mean
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: std
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: mean
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: std
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: double
+    name: mean
+    type: double
+  - dynamic_type: Tensor
+    name: std
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: double
+    name: mean
+    type: double
+  - dynamic_type: Tensor
+    name: std
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: std
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: std
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: double
+    name: mean
+    type: double
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: std
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cauchy_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: double
+    name: median
+    type: double
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: sigma
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_normal_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: mean
+    type: double
+  - default: 2
+    default_init: 2
+    dynamic_type: double
+    name: std
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: exponential_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: lambd
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: geometric_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: double
+    name: p
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_bernoulli_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_bernoulli
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dirichlet_grad_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: x
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: alpha
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: total
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dirichlet_grad
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: x
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: alpha
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: total
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Storage
+    name: storage
+    type: Storage &
+  - dynamic_type: int64_t
+    name: storageOffset
+    type: int64_t
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: IntList
+    name: stride
+    type: IntList
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    type: IntList
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tensor
+  method_prefix_derived: ''
+  arguments: []
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sparse_coo_tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: values
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sparse_coo_tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: values
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: alias
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sparse_coo_tensor_unsafe
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: values
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _copy_ignoring_overlaps_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: src
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: as_strided_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    type: IntList
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: storage_offset
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: as_strided
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    type: IntList
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: storage_offset
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: as_strided_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    type: IntList
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: storage_offset
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sparse_raw_resize_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: int64_t
+    name: nDimI
+    type: int64_t
+  - dynamic_type: int64_t
+    name: nDimV
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cat_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    output: true
+    type: Tensor &
+  - dynamic_type: TensorList
+    name: tensors
+    type: TensorList
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cat
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: TensorList
+    name: tensors
+    type: TensorList
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sparse_mask
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: mask
+    type: SparseTensor
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: SparseTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: to_dense
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dimI
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dimV
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _nnz
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: coalesce
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: is_coalesced
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _indices
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _values
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hspmm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hspmm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: kl_div
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: p
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: p
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: p
+    type: Scalar
+  - dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: p
+    type: Scalar
+  - dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: p
+    type: Scalar
+  - dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: p
+    type: Scalar
+  - dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - is_target
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - is_target
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: is_target
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: is_target
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: is_target
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: is_target
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: is_target
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: -100
+    default_init: -100
+    dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - total_weight
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: -100
+    default_init: -100
+    dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - total_weight
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: total_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: total_weight
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: total_weight
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: total_weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: total_weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: -100
+    default_init: -100
+    dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - total_weight
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: -100
+    default_init: -100
+    dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - total_weight
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: total_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: total_weight
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: total_weight
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: total_weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: total_weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: elu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: elu_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: elu_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: glu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: glu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: glu_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: glu_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: glu_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: glu_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.5
+    default_init: 0.5
+    dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.5
+    default_init: 0.5
+    dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.01
+    default_init: 0.01
+    dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.01
+    default_init: 0.01
+    dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0.01
+    default_init: 0.01
+    dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - buffer
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - buffer
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: buffer
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: buffer
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: buffer
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: buffer
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: buffer
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prelu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prelu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prelu_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prelu_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prelu_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prelu_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: '{{true, true}}'
+    default_init: '{{true, true}}'
+    dynamic_type: std::array<bool,2>
+    name: output_mask
+    type: std::array<bool,2>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - default: 0.125
+    default_init: 0.125
+    dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    default_init: 0.3333333333333333
+    dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: training
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - default: 0.125
+    default_init: 0.125
+    dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    default_init: 0.3333333333333333
+    dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: training
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - default: 0.125
+    default_init: 0.125
+    dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    default_init: 0.3333333333333333
+    dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: training
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softplus_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - default: 20
+    default_init: 20
+    dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softplus
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - default: 20
+    default_init: 20
+    dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softplus_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softplus_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softplus_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softplus_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.5
+    default_init: 0.5
+    dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softshrink
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.5
+    default_init: 0.5
+    dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: threshold
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: threshold_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: threshold_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: random_samples
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: random_samples
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: random_samples
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: random_samples
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 4
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 4
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 5
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 5
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _tanh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: momentum
+    type: double
+  - dynamic_type: double
+    name: eps
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - save_mean
+  - save_std
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: momentum
+    type: double
+  - dynamic_type: double
+    name: eps
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - save_mean
+  - save_std
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: save_mean
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: save_std
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: momentum
+    type: double
+  - dynamic_type: double
+    name: eps
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: save_mean
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: save_std
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: momentum
+    type: double
+  - dynamic_type: double
+    name: eps
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: save_mean
+    type: Tensor
+  - dynamic_type: Tensor
+    name: save_std
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: eps
+    type: double
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_std
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: eps
+    type: double
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_std
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - default: '{{true, true}}'
+    default_init: '{{true, true}}'
+    dynamic_type: std::array<bool,2>
+    name: output_mask
+    type: std::array<bool,2>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cast_uint8_t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_int8_t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_double
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_float
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_int
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_int64_t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_int16_t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_Half
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cudnn_rnn_flatten_weight
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: weight_arr
+    type: TensorList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: weight_stride0
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: input_size
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: hidden_size
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_layers
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: batch_first
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: bidirectional
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cudnn_rnn
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: weight
+    type: TensorList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: weight_stride0
+    type: int64_t
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight_buf
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: hx
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: cx
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: hidden_size
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_layers
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: batch_first
+    type: bool
+  - dynamic_type: double
+    is_nullable: false
+    name: dropout
+    type: double
+  - dynamic_type: bool
+    is_nullable: false
+    name: train
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: bidirectional
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: batch_sizes
+    type: IntList
+  - dynamic_type: BoolTensor
+    is_nullable: true
+    name: dropout_state
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result3
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result4
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cudnn_rnn_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: weight
+    type: TensorList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: weight_stride0
+    type: int64_t
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight_buf
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: hx
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: cx
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_hy
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_cy
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: hidden_size
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_layers
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: batch_first
+    type: bool
+  - dynamic_type: double
+    is_nullable: false
+    name: dropout
+    type: double
+  - dynamic_type: bool
+    is_nullable: false
+    name: train
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: bidirectional
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: batch_sizes
+    type: IntList
+  - dynamic_type: BoolTensor
+    is_nullable: true
+    name: dropout_state
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: reserve
+    type: const Tensor &
+  - dynamic_type: std::array<bool,4>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,4>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  - dynamic_type: TensorList
+    name: result3
+    type: std::vector<Tensor>
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cudnn_init_dropout_state
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: self_ty
+    type: const Type &
+  - dynamic_type: double
+    is_nullable: false
+    name: dropout
+    type: double
+  - dynamic_type: bool
+    is_nullable: false
+    name: train
+    type: bool
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dropout_seed
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: abs
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: abs_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: abs_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: acos
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: acos_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: acos_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_size
+    size: 1
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_size
+    size: 1
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: allclose
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  - default: 1.0e-05
+    dynamic_type: double
+    is_nullable: false
+    name: rtol
+    type: double
+  - default: 1.0e-08
+    dynamic_type: double
+    is_nullable: false
+    name: atol
+    type: double
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: equal_nan
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addmv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addmv_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addmv_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addr_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addr_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: arange
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: arange_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: arange
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: arange_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: argmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: argmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _argmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: argmin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: argmin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _argmin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: asin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: asin_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: asin_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: atan_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: batch_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    is_nullable: false
+    name: training
+    type: bool
+  - dynamic_type: double
+    is_nullable: false
+    name: momentum
+    type: double
+  - dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enabled
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: p
+    type: const Tensor &
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: double
+    is_nullable: false
+    name: p
+    type: double
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: p
+    type: const Tensor &
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: double
+    is_nullable: false
+    name: p
+    type: double
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bilinear
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cat
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cat_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ceil
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ceil_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ceil_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: chunk
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: chunks
+    type: int64_t
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: TensorList
+    name: result
+    type: std::vector<Tensor>
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_is_acceptable
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: convolution
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: transposed
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _convolution
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: transposed
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enabled
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _convolution_nogroup
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: transposed
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _convolution_double_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: ggI
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: ggW
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: ggb
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: gO
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: transposed
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enabled
+    type: bool
+  - dynamic_type: std::array<bool,3>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 1
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 1
+    type: IntList
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 1
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 2
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 2
+    type: IntList
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 2
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 3
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 3
+    type: IntList
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 3
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_tbc
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pad
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_tbc_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pad
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_transpose1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 1
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 1
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    size: 1
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 1
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_transpose2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 2
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 2
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    size: 2
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_transpose3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 3
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 3
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    size: 3
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cos
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cos_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cos_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cosh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cosh_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cosh_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cosine_embedding_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: target
+    type: const Tensor &
+  - default: 0.0
+    dynamic_type: double
+    is_nullable: false
+    name: margin
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: size_average
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_affine_grid_generator
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: theta
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: N
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: C
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: H
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: W
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: grid
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_affine_grid_generator_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: N
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: C
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: H
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: W
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: grad_theta
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_batch_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    is_nullable: false
+    name: training
+    type: bool
+  - dynamic_type: double
+    is_nullable: false
+    name: exponential_average_factor
+    type: double
+  - dynamic_type: double
+    is_nullable: false
+    name: epsilon
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_batch_norm_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_var
+    type: const Tensor &
+  - dynamic_type: double
+    is_nullable: false
+    name: epsilon
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_backward_input
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: self_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  - dynamic_type: std::array<bool,3>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_backward_bias
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_backward_weight
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: weight_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  - dynamic_type: std::array<bool,3>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose_backward_bias
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose_backward_input
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose_backward_weight
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: weight_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_grid_sampler
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grid
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_grid_sampler_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grid
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: grad_self
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_grid
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cumsum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumsum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumsum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumsum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumprod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumprod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumprod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumprod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: det
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: diagflat
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: offset
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: diagonal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: offset
+    type: int64_t
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim1
+    type: int64_t
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim2
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: dot
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: tensor
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: dot_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: tensor
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: einsum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: std::string
+    is_nullable: false
+    name: equation
+    type: std::string
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - default: -1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: padding_idx
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: sparse
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: padding_idx
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: sparse
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_dense_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: padding_idx
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: embedding_renorm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: double
+    is_nullable: false
+    name: max_norm
+    type: double
+  - dynamic_type: double
+    is_nullable: false
+    name: norm_type
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: embedding_sparse_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: padding_idx
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_bag
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offsets
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: sparse
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result3
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: embedding_bag_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offsets
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offset2bag
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: bag_size
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: maximum_indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: sparse
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_bag_sparse_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offsets
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offset2bag
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: bag_size
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_bag_dense_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offsets
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offset2bag
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: bag_size
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: maximum_indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: empty
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: empty_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: empty_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: empty_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: erf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: erf_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: erf_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: exp
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: exp_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: exp_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: expm1
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: expm1_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: expm1_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: expand
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    kwarg_only: true
+    name: implicit
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: expand_as
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: eye
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: n
+    type: int64_t
+  - default: -1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: m
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: eye_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: n
+    type: int64_t
+  - default: -1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: m
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: value
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: floor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: floor_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: floor_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: full
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: fill_value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: full_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: fill_value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: full_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: fill_value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: full_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: fill_value
+    type: Scalar
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hinge_embedding_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: target
+    type: const Tensor &
+  - default: 1.0
+    dynamic_type: double
+    is_nullable: false
+    name: margin
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: size_average
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ger
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ger_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: gesv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: gesv_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: solution
+    output: true
+    type: Tensor &
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: lu
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _gesv_helper
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: group_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_groups
+    type: int64_t
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - default: 1.0e-05
+    dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enabled
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: fft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ifft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rfft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: onesided
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: irfft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: onesided
+    type: bool
+  - default: '{}'
+    dynamic_type: IntList
+    is_nullable: false
+    name: signal_sizes
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _fft_with_size
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: complex_input
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: complex_output
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: inverse
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: checked_signal_sizes
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: onesided
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_sizes
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: indices
+    type: TensorList
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: index_copy_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: index_put_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: indices
+    type: TensorList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: values
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: isclose
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  - default: 1.0e-05
+    dynamic_type: double
+    is_nullable: false
+    name: rtol
+    type: double
+  - default: 1.0e-08
+    dynamic_type: double
+    is_nullable: false
+    name: atol
+    type: double
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: equal_nan
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_cuda
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_distributed
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_floating_point
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_nonzero
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_same_size
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_signed
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_sparse
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: layer_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: normalized_shape
+    type: IntList
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - default: 1.0e-05
+    dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enable
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: linspace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 100
+    dynamic_type: int64_t
+    is_nullable: false
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: linspace_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 100
+    dynamic_type: int64_t
+    is_nullable: false
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log10
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log10_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log10_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log1p
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log1p_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log1p_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log2
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log2_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log2_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: logdet
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: logspace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 100
+    dynamic_type: int64_t
+    is_nullable: false
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: logspace_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 100
+    dynamic_type: int64_t
+    is_nullable: false
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log_softmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_softmax_backward_data
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: output
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: logsumexp
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: logsumexp_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: margin_ranking_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: target
+    type: const Tensor &
+  - default: 0.0
+    dynamic_type: double
+    is_nullable: false
+    name: margin
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: size_average
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: matmul
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: matmul_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_values
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: kernel_size
+    size: 1
+    type: IntList
+  - default: '{}'
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 1
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 1
+    type: IntList
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: min_values
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mkldnn_convolution
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mkldnn_convolution_backward_input
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: self_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: bias_defined
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mkldnn_convolution_backward_weights
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: weight_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: bias_defined
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mkldnn_convolution_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: std::array<bool,3>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mm_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mv_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: narrow
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: start
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: length
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ones
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ones_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ones_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ones_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: pairwise_distance
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: x1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: x2
+    type: const Tensor &
+  - default: 2
+    dynamic_type: double
+    is_nullable: false
+    name: p
+    type: double
+  - default: 1.0e-06
+    dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: permute
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dims
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: pin_memory
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rand
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rand_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rand_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rand_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: low
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: low
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: low
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: low
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randn
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randn_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randn_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randn_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randperm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: n
+    type: int64_t
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randperm_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: n
+    type: int64_t
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: range
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: range_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: repeat
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: repeats
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reshape
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: shape
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: RoiPooling2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: rois
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pooledHeight
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pooledWidth
+    type: int64_t
+  - dynamic_type: double
+    is_nullable: false
+    name: spatialScale
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: RoiPooling2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: rois
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pooledHeight
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pooledWidth
+    type: int64_t
+  - dynamic_type: double
+    is_nullable: false
+    name: spatialScale
+    type: double
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: gradOutput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: argmaxes
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: round
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: round_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: round_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: 0.125
+    dynamic_type: Scalar
+    is_nullable: false
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    dynamic_type: Scalar
+    is_nullable: false
+    name: upper
+    type: Scalar
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: training
+    type: bool
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - default: 0.125
+    dynamic_type: Scalar
+    is_nullable: false
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    dynamic_type: Scalar
+    is_nullable: false
+    name: upper
+    type: Scalar
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: training
+    type: bool
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: relu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: relu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rsqrt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rsqrt_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rsqrt_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: select
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: index
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: selu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: selu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sin_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sin_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sinh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sinh_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sinh_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: size
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: slice
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: start
+    type: int64_t
+  - default: 9223372036854775807
+    dynamic_type: int64_t
+    is_nullable: false
+    name: end
+    type: int64_t
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: step
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: slogdet
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: smm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softmax_backward_data
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: output
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: split
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: split_size
+    type: int64_t
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: TensorList
+    name: result
+    type: std::vector<Tensor>
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: split_with_sizes
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: split_sizes
+    type: IntList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: TensorList
+    name: result
+    type: std::vector<Tensor>
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: squeeze
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: squeeze
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: squeeze_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: squeeze_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sspaddmm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sspaddmm_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: stack
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: stack_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: stft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: frame_length
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: hop
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: fft_size
+    python_default_init: frame_length
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: onesided
+    type: bool
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: window
+    type: const Tensor &
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: pad_end
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: stride
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sum_cuda_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sqrt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sqrt_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sqrt_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _prod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: t_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: tan
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: tan_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tan_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tanh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: tanh_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tanh_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: transpose
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim0
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim1
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: transpose_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim0
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim1
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _trilinear
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: i1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: i2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: i3
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: expand1
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: expand2
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: expand3
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: sumdim
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: unroll_dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: triplet_margin_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: anchor
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: positive
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: negative
+    type: const Tensor &
+  - default: 1.0
+    dynamic_type: double
+    is_nullable: false
+    name: margin
+    type: double
+  - default: 2
+    dynamic_type: double
+    is_nullable: false
+    name: p
+    type: double
+  - default: 1.0e-06
+    dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: swap
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: size_average
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: trunc
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: trunc_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: trunc_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: type_as
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _unique
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: sorted
+    type: bool
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: return_inverse
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _unsafe_view
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: unsqueeze
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: unsqueeze_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: view_as
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: where
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    is_nullable: false
+    name: condition
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _s_where
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    is_nullable: false
+    name: condition
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: zeros
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: zeros_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: zeros_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: zeros_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _standard_gamma_grad
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _standard_gamma
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: poisson
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
diff --git a/aten/src/ATen/gen.py b/aten/src/ATen/gen.py
index b46552068947a..4a43503d039b2 100644
--- a/aten/src/ATen/gen.py
+++ b/aten/src/ATen/gen.py
@@ -4,10 +4,6 @@
 import yaml
 from collections import OrderedDict
 
-import sys
-from os import path
-sys.path.append(path.dirname(path.abspath(__file__)))
-
 import cwrap_parser
 import nn_parse
 import native_parse
@@ -27,7 +23,6 @@
 
 parser = argparse.ArgumentParser(description='Generate ATen source files')
 parser.add_argument('files', help='cwrap files', nargs='+')
-
 parser.add_argument(
     '-s',
     '--source-path',
@@ -38,11 +33,12 @@
     '--output-dependencies',
     help='output a list of dependencies into the given file and exit')
 parser.add_argument(
-    '-d', '--install_dir', help='output directory', default='ATen')
+    '-d', '--output-dir', help='output directory', default='ATen')
 options = parser.parse_args()
 
-if options.install_dir is not None and not os.path.exists(options.install_dir):
-    os.makedirs(options.install_dir)
+
+if options.output_dir is not None and not os.path.exists(options.output_dir):
+    os.makedirs(options.output_dir)
 
 
 class FileManager(object):
@@ -52,7 +48,7 @@ def __init__(self):
         self.undeclared_files = []
 
     def will_write(self, filename):
-        filename = '{}/{}'.format(options.install_dir, filename)
+        filename = '{}/{}'.format(options.output_dir, filename)
         if self.outputs_written:
             raise Exception("'will_write' can only be called before " +
                             "the call to write_outputs, refactor so outputs are registered " +
@@ -78,7 +74,7 @@ def write_outputs(self, filename):
         self.outputs_written = True
 
     def write(self, filename, s, env=None):
-        filename = '{}/{}'.format(options.install_dir, filename)
+        filename = '{}/{}'.format(options.output_dir, filename)
         if isinstance(s, CodeTemplate):
             assert env is not None
             env['generated_comment'] = "@" + "generated by aten/src/ATen/gen.py"
diff --git a/tools/autograd/gen_python_functions.py b/tools/autograd/gen_python_functions.py
index ba58cde552e54..c5fcca7b3b0c0 100644
--- a/tools/autograd/gen_python_functions.py
+++ b/tools/autograd/gen_python_functions.py
@@ -9,11 +9,7 @@
 from .gen_variable_type import should_trace
 from .utils import write
 
-try:
-    from src.ATen.code_template import CodeTemplate
-except ImportError:
-    from tools.shared.module_loader import import_module
-    CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
+CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
 
 # These functions require manual Python bindings or are not exposed to Python
 SKIP_PYTHON_BINDINGS = [
diff --git a/tools/autograd/utils.py b/tools/autograd/utils.py
index 6758e71ffc97e..608b7ea2d8c38 100644
--- a/tools/autograd/utils.py
+++ b/tools/autograd/utils.py
@@ -1,5 +1,6 @@
 import re
 import os
+from tools.shared.module_loader import import_module
 from .nested_dict import nested_dict
 
 
@@ -8,11 +9,8 @@
     'split_name_params', 'write',
 ]
 
-try:
-    from src.ATen.code_template import CodeTemplate
-except ImportError:
-    from tools.shared.module_loader import import_module
-    CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
+
+CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
 
 try:
     # use faster C loader if available
diff --git a/tools/nnwrap/generate_wrappers.py b/tools/nnwrap/generate_wrappers.py
index 19e7aad9dc331..c190f7fc9ee5a 100644
--- a/tools/nnwrap/generate_wrappers.py
+++ b/tools/nnwrap/generate_wrappers.py
@@ -109,12 +109,7 @@ def wrap_nn(thnn_h_path, install_dir, template_path):
     for fn in nn_functions:
         for t in ['Float', 'Double']:
             wrapper += wrap_function(fn.name, t, fn.arguments)
-    install_dir = install_dir or 'torch/csrc/nn'
-    try:
-        os.makedirs(install_dir)
-    except OSError:
-        pass
-    with open(os.path.join(install_dir, 'THNN.cwrap'), 'w') as f:
+    with open('torch/csrc/nn/THNN.cwrap', 'w') as f:
         f.write(wrapper)
     cwrap(os.path.join(install_dir, 'THNN.cwrap'),
           plugins=[NNExtension('torch._C._THNN'), NullableArguments()],
@@ -128,10 +123,10 @@ def wrap_cunn(thcunn_h_path, install_dir, template_path):
     for fn in cunn_functions:
         for t in ['CudaHalf', 'Cuda', 'CudaDouble']:
             wrapper += wrap_function(fn.name, t, fn.arguments)
-    install_dir = install_dir or 'torch/csrc/nn'
-    with open(os.path.join(install_dir, 'THCUNN.cwrap'), 'w') as f:
+    with open('torch/csrc/nn/THCUNN.cwrap', 'w') as f:
         f.write(wrapper)
     cwrap(os.path.join(install_dir, 'THCUNN.cwrap'),
           plugins=[NNExtension('torch._C._THCUNN'), NullableArguments(), AutoGPU(has_self=False)],
           template_path=template_path)
 
+
diff --git a/tools/setup_helpers/generate_code.py b/tools/setup_helpers/generate_code.py
index c14ae02a305e4..7c4b9e1869ed6 100644
--- a/tools/setup_helpers/generate_code.py
+++ b/tools/setup_helpers/generate_code.py
@@ -65,8 +65,7 @@ def generate_code_ninja(w):
 
 def generate_code(ninja_global=None,
                   declarations_path=None,
-                  nn_path=None,
-                  install_dir=None):
+                  nn_path=None):
     # if ninja is enabled, we just register this file as something
     # ninja will need to call if needed
     if ninja_global is not None:
@@ -84,18 +83,13 @@ def generate_code(ninja_global=None,
     generate_nn_wrappers(nn_path, install_dir, 'tools/cwrap/plugins/templates')
 
     # Build ATen based Variable classes
-    autograd_gen_dir = install_dir or 'torch/csrc/autograd/generated'
-    jit_gen_dir = install_dir or 'torch/csrc/jit/generated'
+    autograd_gen_dir = 'torch/csrc/autograd/generated'
+    jit_gen_dir = 'torch/csrc/jit/generated'
     for d in (autograd_gen_dir, jit_gen_dir):
         if not os.path.exists(d):
             os.makedirs(d)
-<<<<<<< HEAD
     gen_autograd(declarations_path or DECLARATIONS_PATH, autograd_gen_dir, 'tools/autograd')
     gen_jit_dispatch(declarations_path or DECLARATIONS_PATH, jit_gen_dir, 'tools/jit/templates')
-=======
-    gen_autograd(declarations_path or DECLARATIONS_PATH, autograd_gen_dir)
-    gen_jit_dispatch(declarations_path or DECLARATIONS_PATH, jit_gen_dir)
->>>>>>> f5ab3fa... Resolve conflicts for torch/_thnn/utils.py
 
 
 def main():
@@ -103,12 +97,10 @@ def main():
     parser.add_argument('--declarations-path')
     parser.add_argument('--nn-path')
     parser.add_argument('--ninja-global')
-    parser.add_argument('--install_dir')
     options = parser.parse_args()
     generate_code(options.ninja_global,
                   options.declarations_path,
-                  options.nn_path,
-                  options.install_dir)
+                  options.nn_path)
 
 
 if __name__ == "__main__":

From 6d44647c1e1bc340806b24263d9f9a5960268553 Mon Sep 17 00:00:00 2001
From: Xiaolong Wang <xlwang@fb.com>
Date: Tue, 12 Jun 2018 10:00:18 -0700
Subject: [PATCH 070/118] [DT]: fix predictor save

similar to D6610058, here we add the fix for distributed online training
---
 caffe2/python/predictor/predictor_py_utils.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/caffe2/python/predictor/predictor_py_utils.py b/caffe2/python/predictor/predictor_py_utils.py
index ce7cfaebafd73..22d044472b838 100644
--- a/caffe2/python/predictor/predictor_py_utils.py
+++ b/caffe2/python/predictor/predictor_py_utils.py
@@ -97,6 +97,16 @@ def GetBlobs(meta_net_def, key):
     return blobs
 
 
+def GetBlobsByTypePrefix(meta_net_def, blob_type_prefix):
+    blob_map = {}
+    for b in meta_net_def.blobs:
+        if b.key.startswith(blob_type_prefix):
+            for blob in b.value:
+                if blob not in blob_map:
+                    blob_map[blob] = len(blob_map)
+    return sorted(blob_map, key=lambda blob: blob_map[blob])
+
+
 def GetNet(meta_net_def, key):
     return _ProtoMapGet(meta_net_def.nets, key)
 

From 4092c613d5d3b67dc09c3ced52c684fb5092e739 Mon Sep 17 00:00:00 2001
From: Yangqing Jia <jiayq@fb.com>
Date: Tue, 12 Jun 2018 10:00:26 -0700
Subject: [PATCH 071/118] Remove net_singlethread_async_gpu.cc

Closes https://github.com/caffe2/caffe2/pull/2528

This removes net_singlethread_async_gpu.cc as part of our effort to clean
CUDAContext and the net executors.
---
 caffe2/core/net_singlethread_async_gpu.cc | 218 ----------------------
 1 file changed, 218 deletions(-)
 delete mode 100644 caffe2/core/net_singlethread_async_gpu.cc

diff --git a/caffe2/core/net_singlethread_async_gpu.cc b/caffe2/core/net_singlethread_async_gpu.cc
deleted file mode 100644
index 0eba1bdc26bed..0000000000000
--- a/caffe2/core/net_singlethread_async_gpu.cc
+++ /dev/null
@@ -1,218 +0,0 @@
-#include <condition_variable>
-#include <mutex>
-#include <stack>
-
-#if !defined(_MSC_VER) && !defined(__APPLE__)
-#include <sched.h>
-#endif
-
-#include "caffe2/core/context_gpu.h"
-#include "caffe2/core/net_simple.h"
-#include "caffe2/core/operator.h"
-#include "caffe2/proto/caffe2.pb.h"
-
-namespace caffe2 {
-
-namespace gpu_single_thread {
-
-struct Task {
-  std::vector<std::unique_ptr<OperatorBase>>* ops_;
-  std::condition_variable* cv_;
-  std::mutex* mtx_;
-  int stream_id_;
-  bool done_ = false;
-};
-
-class GPUExecutor {
- public:
-  explicit GPUExecutor(int gpu_id) : gpu_id_(gpu_id) {}
-
-  ~GPUExecutor() {
-    queue_.NoMoreJobs();
-    thread_.join();
-  }
-
-  void RunJob(Task* task) {
-    queue_.Push(task);
-  }
-
-  void start() {
-    thread_ = std::thread(&GPUExecutor::WorkerFunction, this);
-  }
-
-  static std::shared_ptr<GPUExecutor> Get(int gpu);
-  static void Release(int gpu);
-
- private:
-  void set_affinity();
-  void WorkerFunction();
-
-  std::thread thread_;
-  int gpu_id_;
-  SimpleQueue<Task*> queue_;
-  static std::shared_ptr<GPUExecutor> executors_[CAFFE2_COMPILE_TIME_MAX_GPUS];
-  static std::mutex gpu_mtx_[CAFFE2_COMPILE_TIME_MAX_GPUS];
-};
-
-std::shared_ptr<GPUExecutor>
-    GPUExecutor::executors_[CAFFE2_COMPILE_TIME_MAX_GPUS];
-std::mutex GPUExecutor::gpu_mtx_[CAFFE2_COMPILE_TIME_MAX_GPUS];
-
-std::shared_ptr<GPUExecutor> GPUExecutor::Get(int gpu) {
-  std::lock_guard<std::mutex> grd(gpu_mtx_[gpu]);
-  if (!executors_[gpu].get()) {
-    executors_[gpu].reset(new GPUExecutor(gpu));
-    executors_[gpu].get()->start();
-  }
-  return executors_[gpu];
-}
-
-void GPUExecutor::Release(int gpu) {
-  std::lock_guard<std::mutex> grd(gpu_mtx_[gpu]);
-  if (executors_[gpu].use_count() == 1) {
-    executors_[gpu].reset();
-  }
-}
-
-void GPUExecutor::set_affinity() {
-// TODO: find a Windows-compatible affinity setting approach.
-// Currently, set_affinity has no effect in Windows. The code is still
-// correct with possible slowdowns.
-#if !defined(_MSC_VER) && !defined(__APPLE__)
-  /* Set CPU affinity */
-  int num_cores = std::thread::hardware_concurrency();
-  if (num_cores > 0) {
-    cpu_set_t mask;
-    CPU_ZERO(&mask);
-
-    CPU_SET(gpu_id_ % num_cores, &mask);
-    if (sched_setaffinity(0, sizeof(cpu_set_t), &mask)) {
-      LOG(WARNING) << "Could not set CPU affinity";
-    }
-  }
-#endif
-}
-
-// Worker that takes list of operators from the queue
-// and executes them.
-void GPUExecutor::WorkerFunction() {
-  int stream_id_seq = 0;
-  std::stack<int> streams;
-  set_affinity();
-
-  while (true) {
-    Task* task = nullptr;
-    vector<Task*> task_batch;
-
-    if (!queue_.Pop(&task)) {
-      return;
-    }
-    int num_tasks = 1 + queue_.size();
-
-    // Grab all tasks currently in queue so we can run them in parallel
-    // Since we have only one producer, we know this does not block
-
-    // TODO: launch ops in "zig-zag" manner so that we can start multiple
-    // streams as simultaneously as possible
-    for (int i = num_tasks - 1; i >= 0; i--) {
-      assert(task != nullptr);
-      if (streams.empty()) {
-        task->stream_id_ = stream_id_seq++;
-      } else {
-        task->stream_id_ = streams.top();
-        streams.pop();
-      }
-
-      for (auto& op : *task->ops_) {
-        op->RunAsync(task->stream_id_);
-      }
-      task_batch.push_back(task);
-
-      // Get the next one
-      if (i > 0) {
-        if (!queue_.Pop(&task)) {
-          return;
-        }
-      }
-    }
-
-    // Wait for the currently executing streams
-    for (auto& pendtask : task_batch) {
-      cudaStream_t stream =
-          CUDAContext::cuda_stream(gpu_id_, pendtask->stream_id_);
-      CUDA_ENFORCE(cudaStreamSynchronize(stream));
-      streams.push(pendtask->stream_id_);
-      std::unique_lock<std::mutex> lk(*pendtask->mtx_);
-      pendtask->done_ = true;
-      pendtask->cv_->notify_one();
-    }
-  }
-}
-
-class SingleThreadAsyncNet : public SimpleNet {
- public:
-  using SimpleNet::SimpleNet;
-
-  ~SingleThreadAsyncNet() {
-    if (executor_.get()) {
-      // Explicitly reset my holding of the exeuctor so it can be
-      // killed.
-      executor_.reset();
-      GPUExecutor::Release(gpu_id_);
-    }
-  }
-
-  bool Run() override {
-    if (!executor_.get()) {
-      initialize();
-    }
-
-    // Dispatch jobs to the gpu-specific executor thread
-    std::unique_lock<std::mutex> lk(mutex_);
-    Task t;
-    t.ops_ = &operators_;
-    t.cv_ = &cv_;
-    t.mtx_ = &mutex_;
-    t.done_ = false;
-    executor_.get()->RunJob(&t);
-
-    while (!t.done_) {
-      cv_.wait(lk);
-    }
-
-    return true;
-  }
-
- private:
-  std::condition_variable cv_;
-  std::mutex mutex_;
-
-  void initialize() {
-    std::lock_guard<std::mutex> grd(mutex_);
-
-    /* Check the gpu id of this net and check that only one
-       GPU has operators on this net */
-    gpu_id_ = (-1);
-    for (auto& op : operators_) {
-      if (op->device_option().device_type() == CUDA) {
-        if (gpu_id_ < 0) {
-          gpu_id_ = op->device_option().cuda_gpu_id();
-        } else {
-          CAFFE_ENFORCE_EQ(
-              gpu_id_,
-              op->device_option().cuda_gpu_id(),
-              "One net can only have operators for one GPU");
-        }
-      }
-    }
-    executor_ = GPUExecutor::Get(gpu_id_);
-  }
-
-  int gpu_id_;
-  std::shared_ptr<GPUExecutor> executor_;
-};
-
-REGISTER_NET(singlethread_async, SingleThreadAsyncNet)
-
-} // namespace gpu_single_thread
-} // namespace caffe2

From 758adb69fbbfe1e0f4df839caddf1a132d173b21 Mon Sep 17 00:00:00 2001
From: Ilia Cherniavskii <iliacher@fb.com>
Date: Tue, 12 Jun 2018 10:00:30 -0700
Subject: [PATCH 072/118] Inline DFS task execution

Add a DFS inline task execution mode in executor
---
 caffe2/core/net_async_scheduling.cc | 33 ++++++++++++++++++++++-------
 caffe2/core/net_async_scheduling.h  |  3 ++-
 2 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/caffe2/core/net_async_scheduling.cc b/caffe2/core/net_async_scheduling.cc
index 87c2a4b0c237f..fb9ddd22f1524 100644
--- a/caffe2/core/net_async_scheduling.cc
+++ b/caffe2/core/net_async_scheduling.cc
@@ -12,7 +12,16 @@ namespace caffe2 {
 AsyncSchedulingNet::AsyncSchedulingNet(
     const std::shared_ptr<const NetDef>& net_def,
     Workspace* ws)
-    : AsyncNetBase(net_def, ws), running_(false) {}
+    : AsyncNetBase(net_def, ws), running_(false), use_dfs_scheduling_(false) {
+  for (int arg_idx = 0; arg_idx < net_def->arg_size(); ++arg_idx) {
+    auto& arg = net_def->arg(arg_idx);
+    if (arg.has_name() && arg.name() == "deferrable_mode") {
+      CAFFE_ENFORCE(arg.has_i(), "deferrable_mode should be an int");
+      use_dfs_scheduling_ = arg.i() == 1; // corr. to DFS scheduling
+      break;
+    }
+  }
+}
 
 void AsyncSchedulingNet::reset() {
   AsyncNetBase::reset();
@@ -27,12 +36,11 @@ void AsyncSchedulingNet::Wait() {
   }
 }
 
-void AsyncSchedulingNet::schedule(int task_id) {
+void AsyncSchedulingNet::schedule(int task_id, bool run_inline) {
   if (!testAndSetScheduled(task_id)) {
     return;
   }
-  const auto& device_option = event(task_id).GetDeviceOption();
-  pool(device_option)->run([this, task_id]() {
+  auto schedule_func = [this, task_id]() {
     if (success_) {
       int stream_id = 0;
       if (streams_per_gpu_ > 1) {
@@ -56,7 +64,9 @@ void AsyncSchedulingNet::schedule(int task_id) {
         // - in all other cases, check parents with canSchedule
         if (!success_ || always_schedule_child_ || finish_chain_ ||
             canSchedule(child_id)) {
-          schedule(child_id);
+          // if DFS scheduling is enabled, run children inline,
+          // ignore DFS scheduling in callbacks
+          schedule(child_id, use_dfs_scheduling_);
         } else {
           bool parent_failed = false;
           bool parent_needs_polling = false;
@@ -95,7 +105,7 @@ void AsyncSchedulingNet::schedule(int task_id) {
           if (parent_failed) {
             // one of parents failed, set failure flag and wrap up execution
             success_ = false;
-            schedule(child_id);
+            schedule(child_id, use_dfs_scheduling_);
           } else if (parent_needs_polling) {
             // some parents are blocking us from scheduling a child and don't
             // support callbacks, using polling
@@ -112,7 +122,7 @@ void AsyncSchedulingNet::schedule(int task_id) {
             }
           } else {
             // we're ready to schedule a child
-            schedule(child_id);
+            schedule(child_id, use_dfs_scheduling_);
           }
         }
       }
@@ -127,7 +137,14 @@ void AsyncSchedulingNet::schedule(int task_id) {
     if (cur_processed_tasks == tasks_num) {
       finishRun();
     }
-  });
+  };
+
+  if (run_inline) {
+    schedule_func();
+  } else {
+    const auto& device_option = event(task_id).GetDeviceOption();
+    pool(device_option)->run(schedule_func);
+  }
 }
 
 void AsyncSchedulingNet::parentCallback(int parent_id) {
diff --git a/caffe2/core/net_async_scheduling.h b/caffe2/core/net_async_scheduling.h
index 718181887b564..0a15760f765b2 100644
--- a/caffe2/core/net_async_scheduling.h
+++ b/caffe2/core/net_async_scheduling.h
@@ -18,7 +18,7 @@ class AsyncSchedulingNet : public AsyncNetBase {
   bool RunAsync() override;
 
   void pollAndSchedule(int task_id);
-  void schedule(int task_id);
+  void schedule(int task_id, bool run_inline = false);
   void reset() override;
   virtual void finishRun();
   void parentCallback(int parent_id);
@@ -27,6 +27,7 @@ class AsyncSchedulingNet : public AsyncNetBase {
   std::condition_variable running_cv_;
   std::atomic<bool> running_;
   std::atomic<bool> success_;
+  bool use_dfs_scheduling_;
 
   std::atomic<int> processed_tasks_num_;
 

From 8f6ff0a7bbc94d4d449ca8650a3a23c904512abf Mon Sep 17 00:00:00 2001
From: Sebastian Messmer <messmer@fb.com>
Date: Tue, 12 Jun 2018 10:01:01 -0700
Subject: [PATCH 073/118] Add c10 folder to fbcode

This adds the c10 folder and its test cases to fbcode. Build flags are mostly taken from aten.
---
 CMakeLists.txt        |  3 +++
 c10/CMakeLists.txt    | 50 +++++++++++++++++++++++++++++++++++++++++++
 c10/dummy.cpp         |  3 +++
 c10/dummy.h           |  3 +++
 c10/dummy_test.cpp    |  6 ++++++
 caffe2/CMakeLists.txt |  1 +
 6 files changed, 66 insertions(+)
 create mode 100644 c10/CMakeLists.txt
 create mode 100644 c10/dummy.cpp
 create mode 100644 c10/dummy.h
 create mode 100644 c10/dummy_test.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 40028f029353f..2b96e2eec7362 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -302,6 +302,9 @@ if(BUILD_CAFFE2)
   add_subdirectory(caffe/proto)
 endif()
 
+# ---[ Shared build
+add_subdirectory(c10)
+
 # ---[ Main build
 add_subdirectory(caffe2)
 
diff --git a/c10/CMakeLists.txt b/c10/CMakeLists.txt
new file mode 100644
index 0000000000000..1cb1d31d76d32
--- /dev/null
+++ b/c10/CMakeLists.txt
@@ -0,0 +1,50 @@
+project(c10 CXX C)
+
+set(LIB_SOURCES
+        dummy.cpp
+)
+
+set(TEST_SOURCES
+        dummy_test.cpp
+)
+
+if(MSVC)
+  # TODO Also add some warning options that MSVC can understand
+  set(WARNING_OPTIONS "")
+else()
+  set(WARNING_OPTIONS
+        -Wall
+        -Wextra
+        -Wold-style-cast
+        -Wno-missing-braces
+        -Wcast-align
+        -Wcast-qual
+        -Wctor-dtor-privacy
+        -Wdisabled-optimization
+        -Wformat=2
+        -Winit-self
+        -Wmissing-include-dirs
+        -Woverloaded-virtual
+        -Wredundant-decls
+        -Wshadow
+        -Wsign-promo
+        -Wstrict-overflow=5
+        -fdiagnostics-show-option
+        -Wconversion
+        -Wpedantic
+        -Wno-gnu-zero-variadic-macro-arguments
+        -Wundef
+        -Werror
+        )
+endif()
+
+add_library(${PROJECT_NAME} OBJECT ${LIB_SOURCES})
+target_compile_options(${PROJECT_NAME} PRIVATE ${WARNING_OPTIONS})
+
+if(BUILD_TEST)
+    add_executable(${PROJECT_NAME}_test ${TEST_SOURCES} $<TARGET_OBJECTS:${PROJECT_NAME}>)
+    add_test(NAME ${PROJECT_NAME}_test COMMAND $<TARGET_FILE:${PROJECT_NAME}_test>)
+    target_compile_options(${PROJECT_NAME}_test PRIVATE ${WARNING_OPTIONS})
+    target_link_libraries(${PROJECT_NAME}_test gtest_main)
+    install(TARGETS ${PROJECT_NAME}_test DESTINATION test)
+endif()
diff --git a/c10/dummy.cpp b/c10/dummy.cpp
new file mode 100644
index 0000000000000..7eb029f2618e7
--- /dev/null
+++ b/c10/dummy.cpp
@@ -0,0 +1,3 @@
+// This is going to be replaced with actual c10 files
+
+#include <c10/dummy.h>
diff --git a/c10/dummy.h b/c10/dummy.h
new file mode 100644
index 0000000000000..c4be4d6b80872
--- /dev/null
+++ b/c10/dummy.h
@@ -0,0 +1,3 @@
+#pragma once
+
+// This is going to be replaced with actual c10 files
diff --git a/c10/dummy_test.cpp b/c10/dummy_test.cpp
new file mode 100644
index 0000000000000..4e32bef2cd3aa
--- /dev/null
+++ b/c10/dummy_test.cpp
@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+#include <c10/dummy.h>
+
+TEST(DummyTest, dummy) {
+    EXPECT_TRUE(true);
+}
diff --git a/caffe2/CMakeLists.txt b/caffe2/CMakeLists.txt
index 722e6bf4311b6..a34aa8f1cecbc 100644
--- a/caffe2/CMakeLists.txt
+++ b/caffe2/CMakeLists.txt
@@ -184,6 +184,7 @@ if(BUILD_CAFFE2)
 endif()
 
 # Compile exposed libraries.
+list(APPEND Caffe2_CPU_SRCs $<TARGET_OBJECTS:c10>)
 add_library(caffe2 ${Caffe2_CPU_SRCS})
 if (BUILD_CAFFE2)
   caffe2_interface_library(caffe2_protos caffe2_protos_whole)

From ccaf1707074e88d05e1132ff892dcea394271e26 Mon Sep 17 00:00:00 2001
From: Minxing Liu <mxliu@fb.com>
Date: Tue, 12 Jun 2018 10:01:19 -0700
Subject: [PATCH 074/118] add dependencies for online trainer

Add some dependencies so that the online model can use DataPipeline and PredictionTransform operators

Relevent post: https://fb.intern.facebook.com/groups/1324375037655677/permalink/1740993462660497/
---
 caffe2/python/mkl/rewrite_graph.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/caffe2/python/mkl/rewrite_graph.py b/caffe2/python/mkl/rewrite_graph.py
index c81383a3ea97a..157b0251db9ac 100644
--- a/caffe2/python/mkl/rewrite_graph.py
+++ b/caffe2/python/mkl/rewrite_graph.py
@@ -67,7 +67,8 @@ def mkl_tmp(name):
     # Fuse Conv-Relu for IDEEP
     if ideep:
         net.ParseFromString(
-                C.transform_optimizeForIDEEP(net.SerializeToString()))
+            C.transform_optimizeForIDEEP(net.SerializeToString()))
+
 
 def rewrite_model_helper_simple(model, ideep=True):
     model = copy.deepcopy(model)

From 5c495527278ca1262fcfe3ec3ea95416b0b6ee17 Mon Sep 17 00:00:00 2001
From: James Reed <jamesreed@fb.com>
Date: Tue, 12 Jun 2018 10:01:23 -0700
Subject: [PATCH 075/118] Resolve conflicts for tools/jit/gen_jit_dispatch.py

---
 tools/jit/gen_jit_dispatch.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/jit/gen_jit_dispatch.py b/tools/jit/gen_jit_dispatch.py
index 05c959110b906..f494fa0a4f549 100644
--- a/tools/jit/gen_jit_dispatch.py
+++ b/tools/jit/gen_jit_dispatch.py
@@ -94,6 +94,8 @@ def is_jit_op(decl):
     # Only support a single TensorList arg
     if sum(arg['simple_type'] == 'TensorList' for arg in arguments) > 1:
         return False
+    if any(arg['simple_type'] == 'std::string' for arg in arguments):
+        return False
 
     return ((not decl['api_name'].endswith('_') or is_magic_method(decl['api_name'])) and
             not decl['name'].endswith('_out') and

From 4db8a3858ae33c9b6438a231907386be96ae6e55 Mon Sep 17 00:00:00 2001
From: Chenguang Xi <cxi@fb.com>
Date: Tue, 12 Jun 2018 10:04:08 -0700
Subject: [PATCH 076/118] [Fix] sparse regularization in distributed training

---
 caffe2/operators/sparse_normalize_op_gpu.cu |  9 +++++++++
 caffe2/python/layer_model_helper.py         | 18 ++++++++++++++----
 2 files changed, 23 insertions(+), 4 deletions(-)
 create mode 100644 caffe2/operators/sparse_normalize_op_gpu.cu

diff --git a/caffe2/operators/sparse_normalize_op_gpu.cu b/caffe2/operators/sparse_normalize_op_gpu.cu
new file mode 100644
index 0000000000000..d5e6cc73d1910
--- /dev/null
+++ b/caffe2/operators/sparse_normalize_op_gpu.cu
@@ -0,0 +1,9 @@
+#include "caffe2/core/context_gpu.h"
+#include "caffe2/operators/operator_fallback_gpu.h"
+#include "caffe2/operators/sparse_normalize_op.h"
+
+namespace caffe2 {
+REGISTER_CUDA_OPERATOR(
+    SparseNormalize,
+    GPUFallbackOp<SparseNormalizeOp<float, CPUContext>>);
+}
diff --git a/caffe2/python/layer_model_helper.py b/caffe2/python/layer_model_helper.py
index 34914d7a8b7e4..f142fd195237a 100644
--- a/caffe2/python/layer_model_helper.py
+++ b/caffe2/python/layer_model_helper.py
@@ -5,7 +5,7 @@
 from __future__ import print_function
 from __future__ import unicode_literals
 
-from caffe2.python import core, model_helper, schema, scope, utils
+from caffe2.python import core, model_helper, schema, scope, utils, muji
 from caffe2.python.modeling.parameter_info import (
     ParameterInfo,
 )
@@ -549,12 +549,22 @@ def apply_regularizers_after_optimizer(
         grad_map,
         blob_to_device=None,
     ):
+        CPU = muji.OnCPU()
+        # if given, blob_to_device is a map from blob to device_option
+        blob_to_device = blob_to_device or {}
         for param, regularizer in viewitems(self.param_to_reg):
             if regularizer is None or not regularizer.apply_after_optimizer:
                 continue
             assert isinstance(regularizer, Regularizer)
-            regularizer(
-                train_net, train_init_net, param, grad_map.get(str(param)))
+            device = get_param_device(
+                param,
+                grad_map.get(str(param)),
+                param_to_device=blob_to_device,
+                default_device=CPU,
+            )
+            with core.DeviceScope(device):
+                regularizer(
+                    train_net, train_init_net, param, grad_map.get(str(param)))
 
     def apply_post_grad_net_modifiers(
         self,
@@ -592,7 +602,7 @@ def apply_optimizers(
         grad_map,
         blob_to_device=None,
     ):
-        CPU = core.DeviceOption(caffe2_pb2.CPU)
+        CPU = muji.OnCPU()
         # if given, blob_to_device is a map from blob to device_option
         blob_to_device = blob_to_device or {}
         for param, optimizer in viewitems(self.param_to_optim):

From 09590ab55908d4dc858c7fe298dd98014f36ceb6 Mon Sep 17 00:00:00 2001
From: Zhishuai Zhang <zhishuaizhang@fb.com>
Date: Tue, 12 Jun 2018 10:04:44 -0700
Subject: [PATCH 077/118] Support advanced pooling options in sum processor

* support advanced pooling options in sum processor
* remove redundant code
* support attention in sum processor
---
 caffe2/operators/elementwise_add_op.cc |  6 +++
 caffe2/operators/elementwise_div_op.cc |  2 +
 caffe2/operators/elementwise_mul_op.cc |  2 +
 caffe2/operators/elementwise_sub_op.cc |  2 +
 caffe2/operators/log_op.cc             |  4 ++
 caffe2/operators/tanh_op.cc            | 55 ++++++++++++++++++++++++++
 6 files changed, 71 insertions(+)

diff --git a/caffe2/operators/elementwise_add_op.cc b/caffe2/operators/elementwise_add_op.cc
index 849006a3bb32b..0413da5e03418 100644
--- a/caffe2/operators/elementwise_add_op.cc
+++ b/caffe2/operators/elementwise_add_op.cc
@@ -6,4 +6,10 @@ REGISTER_CPU_OPERATOR(
     Add,
     BinaryElementwiseOp<NumericTypes, CPUContext, AddFunctor<CPUContext>>);
 
+} // namespace
+
+REGISTER_GRADIENT(Add, GetAddGradient);
+
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_div_op.cc b/caffe2/operators/elementwise_div_op.cc
index 73f0b23f7d1da..fd9cf4f4ba5f2 100644
--- a/caffe2/operators/elementwise_div_op.cc
+++ b/caffe2/operators/elementwise_div_op.cc
@@ -7,4 +7,6 @@ REGISTER_CPU_OPERATOR(
     Div,
     BinaryElementwiseOp<NumericTypes, CPUContext, DivFunctor<CPUContext>>);
 
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_mul_op.cc b/caffe2/operators/elementwise_mul_op.cc
index a55112a4b7c46..52f740b11f69c 100644
--- a/caffe2/operators/elementwise_mul_op.cc
+++ b/caffe2/operators/elementwise_mul_op.cc
@@ -6,4 +6,6 @@ REGISTER_CPU_OPERATOR(
     Mul,
     BinaryElementwiseOp<NumericTypes, CPUContext, MulFunctor<CPUContext>>);
 
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_sub_op.cc b/caffe2/operators/elementwise_sub_op.cc
index f906883a183bf..299c46640c763 100644
--- a/caffe2/operators/elementwise_sub_op.cc
+++ b/caffe2/operators/elementwise_sub_op.cc
@@ -6,4 +6,6 @@ REGISTER_CPU_OPERATOR(
     Sub,
     BinaryElementwiseOp<NumericTypes, CPUContext, SubFunctor<CPUContext>>);
 
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/log_op.cc b/caffe2/operators/log_op.cc
index 68e95e6f25ffb..28be919e9246e 100644
--- a/caffe2/operators/log_op.cc
+++ b/caffe2/operators/log_op.cc
@@ -9,6 +9,8 @@ REGISTER_CPU_OPERATOR(
     Log,
     UnaryElementwiseOp<TensorTypes<float>, CPUContext, LogFunctor<CPUContext>>);
 
+#if !CAFFE2_MOBILE
+
 OPERATOR_SCHEMA(Log)
     .NumInputs(1)
     .NumOutputs(1)
@@ -44,4 +46,6 @@ class GetLogGradient : public GradientMakerBase {
 
 REGISTER_GRADIENT(Log, GetLogGradient);
 
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/tanh_op.cc b/caffe2/operators/tanh_op.cc
index 69682256cdd49..d6a1b08a60c8b 100644
--- a/caffe2/operators/tanh_op.cc
+++ b/caffe2/operators/tanh_op.cc
@@ -18,12 +18,48 @@ bool TanhFunctor<CPUContext>::operator()<float>(
   return true;
 }
 
+<<<<<<< HEAD
+=======
+#if !CAFFE2_MOBILE
+
+template <>
+template <typename T>
+bool TanhGradientFunctor<CPUContext>::Forward(
+    const std::vector<int>& dY_dims,
+    const std::vector<int>& /* Y_dims */,
+    const T* dY,
+    const T* Y,
+    T* dX,
+    CPUContext* /* context */) const {
+  const int size = std::accumulate(
+      dY_dims.cbegin(), dY_dims.cend(), 1, std::multiplies<int>());
+  ConstEigenVectorArrayMap<T> dY_arr(dY, size);
+  ConstEigenVectorArrayMap<T> Y_arr(Y, size);
+  EigenVectorMap<T>(dX, size) = dY_arr * (1 - Y_arr * Y_arr);
+  return true;
+}
+
+#endif // !CAFFE2_MOBILE
+
+>>>>>>> 8ac1a59... Support advanced pooling options in sum processor
 REGISTER_CPU_OPERATOR(
     Tanh,
     UnaryElementwiseOp<
         TensorTypes<float>,
         CPUContext,
         TanhFunctor<CPUContext>>);
+<<<<<<< HEAD
+=======
+
+#if !CAFFE2_MOBILE
+
+REGISTER_CPU_OPERATOR(
+    TanhGradient,
+    BinaryElementwiseOp<
+        TensorTypes<float>,
+        CPUContext,
+        TanhGradientFunctor<CPUContext>>);
+>>>>>>> 8ac1a59... Support advanced pooling options in sum processor
 
 OPERATOR_SCHEMA(Tanh)
     .NumInputs(1)
@@ -93,4 +129,23 @@ print("X:\n", workspace.FetchBlob("X"))
 
 OPERATOR_SCHEMA(TanhGradient).NumInputs(2).NumOutputs(1).AllowInplace({{0, 0}});
 
+namespace {
+
+class GetTanhGradient : public GradientMakerBase {
+  using GradientMakerBase::GradientMakerBase;
+  std::vector<OperatorDef> GetGradientDefs() override {
+    return SingleGradientDef(
+        "TanhGradient",
+        "",
+        std::vector<std::string>{GO(0), O(0)},
+        std::vector<std::string>{GI(0)});
+  }
+};
+
+} // namespace
+
+REGISTER_GRADIENT(Tanh, GetTanhGradient);
+
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2

From 8b1de0dd24635f37f254a3f9dfeb2ff4e4ce2882 Mon Sep 17 00:00:00 2001
From: Duc Ngo <duc@fb.com>
Date: Tue, 12 Jun 2018 10:04:54 -0700
Subject: [PATCH 078/118] Improve shard logging in net tracing code

Make it handle arbitrary shard ids instead of just one digit ids.
---
 caffe2/core/net_async_tracing.cc      | 66 +++++++++++++++++----------
 caffe2/core/net_async_tracing.h       |  4 ++
 caffe2/core/net_async_tracing_test.cc | 42 +++++++++++++++++
 3 files changed, 88 insertions(+), 24 deletions(-)
 create mode 100644 caffe2/core/net_async_tracing_test.cc

diff --git a/caffe2/core/net_async_tracing.cc b/caffe2/core/net_async_tracing.cc
index 0d3f83aba277e..b2c4a1952b785 100644
--- a/caffe2/core/net_async_tracing.cc
+++ b/caffe2/core/net_async_tracing.cc
@@ -46,32 +46,15 @@ void Tracer::recordEvent(const TracerEvent& event) {
   events_.push_back(event);
 }
 
+// Forward
+int getUniqueShardId(const OperatorDef& op_def);
+
 // Special handling of shard blob annotations
 std::string Tracer::opTraceName(const OperatorBase* op) {
-  if (!op->has_debug_def()) {
-    return op->type();
-  }
-
-  const auto& op_def = op->debug_def();
-  std::unordered_set<int> shards;
-  const std::string kShard = "shard:";
-  int shard = 0;
-  for (const auto& input : op_def.input()) {
-    auto pos = input.find(kShard);
-    if (pos != std::string::npos) {
-      shard = input[pos + kShard.length()] - '0';
-      shards.insert(shard);
-    }
-  }
-  for (const auto& output : op_def.output()) {
-    auto pos = output.find(kShard);
-    if (pos != std::string::npos) {
-      shard = output[pos + kShard.length()] - '0';
-      shards.insert(shard);
-    }
-  }
-  if (shards.size() == 1) {
-    return op->type() + ":" + caffe2::to_string(shard);
+  int unique_shard_id =
+      op->has_debug_def() ? getUniqueShardId(op->debug_def()) : -1;
+  if (unique_shard_id != -1) {
+    return op->type() + ":" + caffe2::to_string(unique_shard_id);
   } else {
     return op->type();
   }
@@ -327,6 +310,41 @@ TracerGuard::~TracerGuard() {
   }
 }
 
+int extractShardId(const std::string& name) {
+  const std::string kShard = "shard:";
+  // We sometimes have multiple shards, but actually need the last one, hence
+  // using rfind here. Hacky but it works till we pass shard id in graph
+  // metadata.
+  auto pos = name.rfind(kShard);
+  if (pos != std::string::npos) {
+    int left_pos = pos + kShard.length();
+    int right_pos = left_pos;
+    while (right_pos < name.length() && isdigit(name[right_pos])) {
+      right_pos++;
+    }
+    return std::stoi(name.substr(left_pos, right_pos - left_pos));
+  } else {
+    return -1;
+  }
+}
+
+// Return unique shard id, or -1 if it is not unique.
+int getUniqueShardId(const OperatorDef& op_def) {
+  int unique_shard_id = -1;
+  for (const auto& names : {op_def.input(), op_def.output()}) {
+    for (const auto& name : names) {
+      int shard_id = extractShardId(name);
+      if (shard_id != -1) {
+        if (unique_shard_id != -1) {
+          return -1;
+        }
+        unique_shard_id = shard_id;
+      }
+    }
+  }
+  return unique_shard_id;
+}
+
 bool isTraceableNet(const std::string& net_name) {
   auto tracing_nets = caffe2::split(',', FLAGS_caffe2_net_async_names_to_trace);
   return !net_name.empty() &&
diff --git a/caffe2/core/net_async_tracing.h b/caffe2/core/net_async_tracing.h
index ace94e0f74f48..54c362c191146 100644
--- a/caffe2/core/net_async_tracing.h
+++ b/caffe2/core/net_async_tracing.h
@@ -104,6 +104,10 @@ class TracerGuard {
   Tracer* tracer_;
 };
 
+// Extract the shard id from name of the form "...shard:123..."
+// Return -1 if there is no shard found
+int extractShardId(const std::string& name);
+
 bool isTraceableNet(const std::string& net_name);
 
 std::shared_ptr<Tracer> create(const NetBase* net, const std::string& net_name);
diff --git a/caffe2/core/net_async_tracing_test.cc b/caffe2/core/net_async_tracing_test.cc
new file mode 100644
index 0000000000000..095d4f83838bb
--- /dev/null
+++ b/caffe2/core/net_async_tracing_test.cc
@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "caffe2/core/net_async_tracing.h"
+
+namespace caffe2 {
+
+namespace tracing {
+
+void testExtractShardId(const string& name, int expectedId) {
+  EXPECT_EQ(extractShardId(name), expectedId);
+}
+
+TEST(NetAsyncTracingTest, ExtractShardId) {
+  testExtractShardId("ABCDEFshard:1705!!A", 1705);
+  // Should use the last one
+  testExtractShardId("ABCDEFshard:4324!!Ashard:01220b", 1220);
+  // Nothing to extract
+  testExtractShardId("ABCDEFsha:222", -1);
+  // Regular cases
+  testExtractShardId("FC:shard:0", 0);
+  testExtractShardId("FC:shard:10", 10);
+  testExtractShardId("FC:shard:15", 15);
+}
+
+} // namespace tracing
+
+} // namespace caffe2

From a97963a8b1c59c5dfc4fdaca275cce85c90ede52 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 10:05:34 -0700
Subject: [PATCH 079/118] [Caffe2] Call GlobalInit in predictor only in mobile

FACEBOOK:
Calling GlobalInit long after the program starts may not be safe. There are issues if the following happens:

User does not call GlobalInit and initFacebook after program starts
User sets a flag manually: https://fburl.com/mcsumw7d
User calls OSS predictor.
OSS predictor calls GlobalInit
GlobalInit calls initFacebook
initFacebook resets all flags: https://fburl.com/tolszha1
Thus, the user manually set flags are overwritten

This would happen anytime GlobalInit is called long after the program starts.
I suppose the intention of the user in this case is not to call GlobalInit throughout the program,
but use Caffe2 regardless (is that desired?)
But adding GlobalInit in the OSS predictor would automatically call GlobalInit when using Caffe2.

This issue doesn't exist in mobile, since initFacebook is not called on mobile.

For now, guard the GlobalInit in predictor for mobile only.
May want to ensure the GlobalInit is always called at the start of the program. @[3501714:kutta] has seen weird issues when not calling GlobalInit at the start of the program on server side. He has made some progress on this.
---
 caffe2/core/predictor.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/caffe2/core/predictor.cc b/caffe2/core/predictor.cc
index e82aa098ce6e8..bbe487b3ac6cd 100644
--- a/caffe2/core/predictor.cc
+++ b/caffe2/core/predictor.cc
@@ -92,8 +92,9 @@ Predictor::Predictor(
   if (run_init) {
     CAFFE_ENFORCE(ws_.RunNetOnce(init_net));
   }
-
+#if CAFFE2_MOBILE
   GlobalInit();
+#endif
 
   if (optimization) {
 #ifdef CAFFE2_OPTIMIZER

From a5d0df98c34b35633ec4c6fc755bce0669c71aed Mon Sep 17 00:00:00 2001
From: Bram Wasti <bwasti@fb.com>
Date: Tue, 12 Jun 2018 10:06:06 -0700
Subject: [PATCH 080/118] resolve conflicts for
 caffe2/core/logging_is_google_glog.h and test/test_torch.py

---
 aten/src/ATen/Declarations.yaml               | 14 +++++-----
 aten/src/ATen/gen.py                          | 16 ++++++-----
 .../include/nomnigraph/Support/Common.h       | 18 +++++++++++++
 caffe2/core/nomnigraph/ops.def                |  6 +++++
 caffe2/opt/converter.cc                       | 27 +++++++++++++++++++
 5 files changed, 68 insertions(+), 13 deletions(-)

diff --git a/aten/src/ATen/Declarations.yaml b/aten/src/ATen/Declarations.yaml
index e865a8ab30c66..71715505f9d59 100644
--- a/aten/src/ATen/Declarations.yaml
+++ b/aten/src/ATen/Declarations.yaml
@@ -22710,7 +22710,7 @@
   abstract: true
   auto_gpu: true
   with_gil: false
-- name: _cast_uint8_t
+- name: _cast_Byte
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22735,7 +22735,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_int8_t
+- name: _cast_Char
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22760,7 +22760,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_double
+- name: _cast_Double
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22785,7 +22785,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_float
+- name: _cast_Float
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22810,7 +22810,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_int
+- name: _cast_Int
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22835,7 +22835,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_int64_t
+- name: _cast_Long
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22860,7 +22860,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_int16_t
+- name: _cast_Short
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
diff --git a/aten/src/ATen/gen.py b/aten/src/ATen/gen.py
index 4a43503d039b2..b46552068947a 100644
--- a/aten/src/ATen/gen.py
+++ b/aten/src/ATen/gen.py
@@ -4,6 +4,10 @@
 import yaml
 from collections import OrderedDict
 
+import sys
+from os import path
+sys.path.append(path.dirname(path.abspath(__file__)))
+
 import cwrap_parser
 import nn_parse
 import native_parse
@@ -23,6 +27,7 @@
 
 parser = argparse.ArgumentParser(description='Generate ATen source files')
 parser.add_argument('files', help='cwrap files', nargs='+')
+
 parser.add_argument(
     '-s',
     '--source-path',
@@ -33,12 +38,11 @@
     '--output-dependencies',
     help='output a list of dependencies into the given file and exit')
 parser.add_argument(
-    '-d', '--output-dir', help='output directory', default='ATen')
+    '-d', '--install_dir', help='output directory', default='ATen')
 options = parser.parse_args()
 
-
-if options.output_dir is not None and not os.path.exists(options.output_dir):
-    os.makedirs(options.output_dir)
+if options.install_dir is not None and not os.path.exists(options.install_dir):
+    os.makedirs(options.install_dir)
 
 
 class FileManager(object):
@@ -48,7 +52,7 @@ def __init__(self):
         self.undeclared_files = []
 
     def will_write(self, filename):
-        filename = '{}/{}'.format(options.output_dir, filename)
+        filename = '{}/{}'.format(options.install_dir, filename)
         if self.outputs_written:
             raise Exception("'will_write' can only be called before " +
                             "the call to write_outputs, refactor so outputs are registered " +
@@ -74,7 +78,7 @@ def write_outputs(self, filename):
         self.outputs_written = True
 
     def write(self, filename, s, env=None):
-        filename = '{}/{}'.format(options.output_dir, filename)
+        filename = '{}/{}'.format(options.install_dir, filename)
         if isinstance(s, CodeTemplate):
             assert env is not None
             env['generated_comment'] = "@" + "generated by aten/src/ATen/gen.py"
diff --git a/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h b/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
index 9a39ab2405cf5..9731d048a31fa 100644
--- a/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
+++ b/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
@@ -14,6 +14,24 @@
 #include <functional>
 #include <list>
 
+// These #defines are useful when writing passes as the collapse
+//
+// if (!cond) {
+//   continue; // or break; or return;
+// }
+//
+// into a single line without negation
+
+#define NOM_REQUIRE_OR_(_cond, _expr) \
+  if (!(_cond)) {                     \
+    _expr;                            \
+  }
+
+#define NOM_REQUIRE_OR_CONT(_cond) NOM_REQUIRE_OR_(_cond, continue)
+#define NOM_REQUIRE_OR_BREAK(_cond) NOM_REQUIRE_OR_(_cond, break)
+#define NOM_REQUIRE_OR_RET_NULL(_cond) NOM_REQUIRE_OR_(_cond, return nullptr)
+#define NOM_REQUIRE_OR_RET(_cond) NOM_REQUIRE_OR_(_cond, return )
+
 // Implements accessors for a generic type T. If the type is not
 // specified (i.e., void template type) then the partial specification
 // gives an empty type.
diff --git a/caffe2/core/nomnigraph/ops.def b/caffe2/core/nomnigraph/ops.def
index 6240ff2b04391..9182c80fbd76b 100644
--- a/caffe2/core/nomnigraph/ops.def
+++ b/caffe2/core/nomnigraph/ops.def
@@ -55,6 +55,8 @@ BatchNormalization
 FC
 GivenTensorFill
 Concat
+- Axis : int : -1
+- AddAxis : bool : false
 Softmax
 ChannelShuffle
 Add
@@ -81,3 +83,7 @@ Int8ConvRelu : ConvRelu
 Int8SumRelu : SumRelu
 Int8AveragePoolRelu : AveragePoolRelu
 Int8MaxPoolRelu : MaxPoolRelu
+
+BatchMatMul
+BatchGather
+ConcatBatchMatMulBatchGatherOp
diff --git a/caffe2/opt/converter.cc b/caffe2/opt/converter.cc
index e0f8dd160b08a..33700204625a8 100644
--- a/caffe2/opt/converter.cc
+++ b/caffe2/opt/converter.cc
@@ -128,6 +128,33 @@ convertToOperatorDef(caffe2::OperatorDef op) {
     nnOp = util::make_unique<repr::BatchNormalization>();
   }
 
+  if (op.type() == "Concat") {
+    nnOp = util::make_unique<repr::Concat>();
+    auto c = dyn_cast<repr::Concat>(nnOp.get());
+    if (argMap.count("axis")) {
+      assert(argMap["axis"].has_i() && "Invalid axis argument");
+      int axis = static_cast<int>(argMap["axis"].i());
+      c->setAxis(axis);
+    }
+    if (argMap.count("add_axis")) {
+      assert(argMap["add_axis"].has_i() && "Invalid add_axis argument");
+      int add_axis = static_cast<int>(argMap["add_axis"].i());
+      c->setAddAxis(!!add_axis);
+    }
+  }
+
+  if (op.type() == "Flatten") {
+    nnOp = util::make_unique<repr::Flatten>();
+  }
+
+  if (op.type() == "BatchGather") {
+    nnOp = util::make_unique<repr::BatchGather>();
+  }
+
+  if (op.type() == "BatchMatMul") {
+    nnOp = util::make_unique<repr::BatchMatMul>();
+  }
+
   if (!nnOp) {
     nnOp = util::make_unique<repr::GenericOperator>(op.type());
   }

From 59f474d2b10183eb8e11b737c95d949f2435e996 Mon Sep 17 00:00:00 2001
From: Xiaomeng Yang <yangxm@fb.com>
Date: Tue, 12 Jun 2018 10:08:55 -0700
Subject: [PATCH 081/118] Add empty fix for SumLikeReduceOp

Add empty fix for SumLikeReduceOp
---
 caffe2/operators/elementwise_ops.cu | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/caffe2/operators/elementwise_ops.cu b/caffe2/operators/elementwise_ops.cu
index 73b60c69ef0cd..b564d8ae8005f 100644
--- a/caffe2/operators/elementwise_ops.cu
+++ b/caffe2/operators/elementwise_ops.cu
@@ -172,6 +172,12 @@ bool SumReduceLikeOp<CUDAContext>::DoRunWithType() {
   C->ResizeLike(B);
   const T* Adata = A.template data<T>();
   auto* Cdata = C->template mutable_data<T>();
+
+  if (C->size() == 0) {
+    // output is empty, nothing to do, not even launching the CUDA kernel
+    return true;
+  }
+
   if (B.size() == 1) {
     device_reduce<T>(Adata, Cdata, count, &sum_buffer_, &context_);
   } else {

From aa02f1f11dd0edc0cd57403e268418dd369b1af4 Mon Sep 17 00:00:00 2001
From: Andrey Malevich <amalevich@fb.com>
Date: Tue, 12 Jun 2018 10:10:08 -0700
Subject: [PATCH 082/118] Revert D7962948: [caffe2][nomnigraph] Concat elim for
 sparseNN

This reverts commit f7f434dc5c34ca6058b9765d2ef615453d2276a9

@bypass-lint

An infra SEV is better than not reverting this diff.
If you copy this password, see you in SEV Review!
@cause_a_sev_many_files
---
 .../include/nomnigraph/Support/Common.h       | 18 ------
 caffe2/core/nomnigraph/ops.def                |  6 --
 caffe2/operators/elementwise_add_op.cc        |  6 --
 caffe2/operators/elementwise_div_op.cc        |  2 -
 caffe2/operators/elementwise_mul_op.cc        |  2 -
 caffe2/operators/elementwise_sub_op.cc        |  2 -
 caffe2/operators/log_op.cc                    |  4 --
 caffe2/operators/tanh_op.cc                   | 55 -------------------
 caffe2/opt/converter.cc                       | 29 +---------
 9 files changed, 1 insertion(+), 123 deletions(-)

diff --git a/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h b/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
index 9731d048a31fa..9a39ab2405cf5 100644
--- a/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
+++ b/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
@@ -14,24 +14,6 @@
 #include <functional>
 #include <list>
 
-// These #defines are useful when writing passes as the collapse
-//
-// if (!cond) {
-//   continue; // or break; or return;
-// }
-//
-// into a single line without negation
-
-#define NOM_REQUIRE_OR_(_cond, _expr) \
-  if (!(_cond)) {                     \
-    _expr;                            \
-  }
-
-#define NOM_REQUIRE_OR_CONT(_cond) NOM_REQUIRE_OR_(_cond, continue)
-#define NOM_REQUIRE_OR_BREAK(_cond) NOM_REQUIRE_OR_(_cond, break)
-#define NOM_REQUIRE_OR_RET_NULL(_cond) NOM_REQUIRE_OR_(_cond, return nullptr)
-#define NOM_REQUIRE_OR_RET(_cond) NOM_REQUIRE_OR_(_cond, return )
-
 // Implements accessors for a generic type T. If the type is not
 // specified (i.e., void template type) then the partial specification
 // gives an empty type.
diff --git a/caffe2/core/nomnigraph/ops.def b/caffe2/core/nomnigraph/ops.def
index 9182c80fbd76b..6240ff2b04391 100644
--- a/caffe2/core/nomnigraph/ops.def
+++ b/caffe2/core/nomnigraph/ops.def
@@ -55,8 +55,6 @@ BatchNormalization
 FC
 GivenTensorFill
 Concat
-- Axis : int : -1
-- AddAxis : bool : false
 Softmax
 ChannelShuffle
 Add
@@ -83,7 +81,3 @@ Int8ConvRelu : ConvRelu
 Int8SumRelu : SumRelu
 Int8AveragePoolRelu : AveragePoolRelu
 Int8MaxPoolRelu : MaxPoolRelu
-
-BatchMatMul
-BatchGather
-ConcatBatchMatMulBatchGatherOp
diff --git a/caffe2/operators/elementwise_add_op.cc b/caffe2/operators/elementwise_add_op.cc
index 0413da5e03418..849006a3bb32b 100644
--- a/caffe2/operators/elementwise_add_op.cc
+++ b/caffe2/operators/elementwise_add_op.cc
@@ -6,10 +6,4 @@ REGISTER_CPU_OPERATOR(
     Add,
     BinaryElementwiseOp<NumericTypes, CPUContext, AddFunctor<CPUContext>>);
 
-} // namespace
-
-REGISTER_GRADIENT(Add, GetAddGradient);
-
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_div_op.cc b/caffe2/operators/elementwise_div_op.cc
index fd9cf4f4ba5f2..73f0b23f7d1da 100644
--- a/caffe2/operators/elementwise_div_op.cc
+++ b/caffe2/operators/elementwise_div_op.cc
@@ -7,6 +7,4 @@ REGISTER_CPU_OPERATOR(
     Div,
     BinaryElementwiseOp<NumericTypes, CPUContext, DivFunctor<CPUContext>>);
 
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_mul_op.cc b/caffe2/operators/elementwise_mul_op.cc
index 52f740b11f69c..a55112a4b7c46 100644
--- a/caffe2/operators/elementwise_mul_op.cc
+++ b/caffe2/operators/elementwise_mul_op.cc
@@ -6,6 +6,4 @@ REGISTER_CPU_OPERATOR(
     Mul,
     BinaryElementwiseOp<NumericTypes, CPUContext, MulFunctor<CPUContext>>);
 
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_sub_op.cc b/caffe2/operators/elementwise_sub_op.cc
index 299c46640c763..f906883a183bf 100644
--- a/caffe2/operators/elementwise_sub_op.cc
+++ b/caffe2/operators/elementwise_sub_op.cc
@@ -6,6 +6,4 @@ REGISTER_CPU_OPERATOR(
     Sub,
     BinaryElementwiseOp<NumericTypes, CPUContext, SubFunctor<CPUContext>>);
 
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/log_op.cc b/caffe2/operators/log_op.cc
index 28be919e9246e..68e95e6f25ffb 100644
--- a/caffe2/operators/log_op.cc
+++ b/caffe2/operators/log_op.cc
@@ -9,8 +9,6 @@ REGISTER_CPU_OPERATOR(
     Log,
     UnaryElementwiseOp<TensorTypes<float>, CPUContext, LogFunctor<CPUContext>>);
 
-#if !CAFFE2_MOBILE
-
 OPERATOR_SCHEMA(Log)
     .NumInputs(1)
     .NumOutputs(1)
@@ -46,6 +44,4 @@ class GetLogGradient : public GradientMakerBase {
 
 REGISTER_GRADIENT(Log, GetLogGradient);
 
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/tanh_op.cc b/caffe2/operators/tanh_op.cc
index d6a1b08a60c8b..69682256cdd49 100644
--- a/caffe2/operators/tanh_op.cc
+++ b/caffe2/operators/tanh_op.cc
@@ -18,48 +18,12 @@ bool TanhFunctor<CPUContext>::operator()<float>(
   return true;
 }
 
-<<<<<<< HEAD
-=======
-#if !CAFFE2_MOBILE
-
-template <>
-template <typename T>
-bool TanhGradientFunctor<CPUContext>::Forward(
-    const std::vector<int>& dY_dims,
-    const std::vector<int>& /* Y_dims */,
-    const T* dY,
-    const T* Y,
-    T* dX,
-    CPUContext* /* context */) const {
-  const int size = std::accumulate(
-      dY_dims.cbegin(), dY_dims.cend(), 1, std::multiplies<int>());
-  ConstEigenVectorArrayMap<T> dY_arr(dY, size);
-  ConstEigenVectorArrayMap<T> Y_arr(Y, size);
-  EigenVectorMap<T>(dX, size) = dY_arr * (1 - Y_arr * Y_arr);
-  return true;
-}
-
-#endif // !CAFFE2_MOBILE
-
->>>>>>> 8ac1a59... Support advanced pooling options in sum processor
 REGISTER_CPU_OPERATOR(
     Tanh,
     UnaryElementwiseOp<
         TensorTypes<float>,
         CPUContext,
         TanhFunctor<CPUContext>>);
-<<<<<<< HEAD
-=======
-
-#if !CAFFE2_MOBILE
-
-REGISTER_CPU_OPERATOR(
-    TanhGradient,
-    BinaryElementwiseOp<
-        TensorTypes<float>,
-        CPUContext,
-        TanhGradientFunctor<CPUContext>>);
->>>>>>> 8ac1a59... Support advanced pooling options in sum processor
 
 OPERATOR_SCHEMA(Tanh)
     .NumInputs(1)
@@ -129,23 +93,4 @@ print("X:\n", workspace.FetchBlob("X"))
 
 OPERATOR_SCHEMA(TanhGradient).NumInputs(2).NumOutputs(1).AllowInplace({{0, 0}});
 
-namespace {
-
-class GetTanhGradient : public GradientMakerBase {
-  using GradientMakerBase::GradientMakerBase;
-  std::vector<OperatorDef> GetGradientDefs() override {
-    return SingleGradientDef(
-        "TanhGradient",
-        "",
-        std::vector<std::string>{GO(0), O(0)},
-        std::vector<std::string>{GI(0)});
-  }
-};
-
-} // namespace
-
-REGISTER_GRADIENT(Tanh, GetTanhGradient);
-
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/opt/converter.cc b/caffe2/opt/converter.cc
index 33700204625a8..08f4ce9ae2ed2 100644
--- a/caffe2/opt/converter.cc
+++ b/caffe2/opt/converter.cc
@@ -128,33 +128,6 @@ convertToOperatorDef(caffe2::OperatorDef op) {
     nnOp = util::make_unique<repr::BatchNormalization>();
   }
 
-  if (op.type() == "Concat") {
-    nnOp = util::make_unique<repr::Concat>();
-    auto c = dyn_cast<repr::Concat>(nnOp.get());
-    if (argMap.count("axis")) {
-      assert(argMap["axis"].has_i() && "Invalid axis argument");
-      int axis = static_cast<int>(argMap["axis"].i());
-      c->setAxis(axis);
-    }
-    if (argMap.count("add_axis")) {
-      assert(argMap["add_axis"].has_i() && "Invalid add_axis argument");
-      int add_axis = static_cast<int>(argMap["add_axis"].i());
-      c->setAddAxis(!!add_axis);
-    }
-  }
-
-  if (op.type() == "Flatten") {
-    nnOp = util::make_unique<repr::Flatten>();
-  }
-
-  if (op.type() == "BatchGather") {
-    nnOp = util::make_unique<repr::BatchGather>();
-  }
-
-  if (op.type() == "BatchMatMul") {
-    nnOp = util::make_unique<repr::BatchMatMul>();
-  }
-
   if (!nnOp) {
     nnOp = util::make_unique<repr::GenericOperator>(op.type());
   }
@@ -514,4 +487,4 @@ caffe2::NetDef convertToCaffe2Proto(repr::NNModule &m, const caffe2::NetDef& old
   return predictNet;
 }
 
-} // namespace caffe2
+} // namespace caffe2 

From 6b83cb1209c12008cddc9be8bc50d349d990bcd4 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 12:04:09 -0700
Subject: [PATCH 083/118] Remove Declarations.yaml

---
 aten/src/ATen/Declarations.yaml | 32527 ------------------------------
 1 file changed, 32527 deletions(-)
 delete mode 100644 aten/src/ATen/Declarations.yaml

diff --git a/aten/src/ATen/Declarations.yaml b/aten/src/ATen/Declarations.yaml
deleted file mode 100644
index 71715505f9d59..0000000000000
--- a/aten/src/ATen/Declarations.yaml
+++ /dev/null
@@ -1,32527 +0,0 @@
-- name: storage_offset
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: resize_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: numel
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: set_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Storage
-    name: storage
-    type: Storage &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: set_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Storage
-    name: sourceStorage
-    type: Storage &
-  - dynamic_type: int64_t
-    name: storage_offset
-    type: int64_t
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: IntList
-    name: stride
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: set_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: set_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: _fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: value
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: is_contiguous
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: is_set_to
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: masked_fill_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  - dynamic_type: real
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: masked_fill_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: value
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: masked_scatter_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: masked_select_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: masked_select
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nonzero_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nonzero
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: contiguous
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clone
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: view
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: resize_as_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: the_template
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_select_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_select
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _indexCopy_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: take_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: take
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: put_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: accumulate
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_add_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: real
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: value
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: unfold
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dimension
-    type: int64_t
-  - dynamic_type: int64_t
-    name: size
-    type: int64_t
-  - dynamic_type: int64_t
-    name: step
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: _range_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: accreal
-    name: start
-    type: Scalar
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _range
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: accreal
-    name: start
-    type: Scalar
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _arange_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: accreal
-    name: start
-    type: Scalar
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _arange
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: accreal
-    name: start
-    type: Scalar
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _arange_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _arange
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: scatter_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: src
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: scatter_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: real
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: scatter_add_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: src
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gather_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gather
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: data_ptr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: void*
-    name: result
-    type: void*
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: true
-- name: equal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __and___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __and__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __and___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __and__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __iand__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __iand__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __or___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __or__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __or___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __or__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ior__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ior__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __xor___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __xor__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __xor___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __xor__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ixor__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ixor__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __lshift___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __lshift__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __lshift___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __lshift__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ilshift__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ilshift__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __rshift___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __rshift__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __rshift___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __rshift__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __irshift__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __irshift__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: min
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: min_indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: min
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: min_indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: min
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: min_indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: max
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: max_indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: max
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: max_indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: max
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: max_indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kthvalue_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: k
-    type: int64_t
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kthvalue
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: k
-    type: int64_t
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mode_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mode
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: median_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: median
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: median
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sort_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: descending
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sort
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: descending
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: topk_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: k
-    type: int64_t
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: largest
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: sorted
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: topk
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: k
-    type: int64_t
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: largest
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: sorted
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: all_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: all
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: all
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: any_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: any
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: any
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: get_device
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _abs_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _abs
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sigmoid_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sigmoid_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sigmoid
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log10_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log10
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log1p_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log1p
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log2_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log2
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lgamma_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lgamma
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lgamma_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: digamma_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: digamma
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: digamma_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: polygamma_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: n
-    type: int64_t
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: polygamma
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: int64_t
-    name: n
-    type: int64_t
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: polygamma_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: n
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _exp_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _exp
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _expm1_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _expm1
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cos_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cos
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _acos_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _acos
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cosh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cosh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sin_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _asin_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _asin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sinh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sinh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tan_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tan
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _atan_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _atan
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_tanh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_tanh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _erf_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _erf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: erfinv_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: erfinv_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: erfinv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sqrt_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sqrt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _rsqrt_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _rsqrt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _ceil_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _ceil
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _floor_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _floor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _round_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _round
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _trunc_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _trunc
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: frac_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: frac_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: frac
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mean_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mean
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mean
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: var_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: var
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: var
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: std_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: std
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: std
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: norm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: p
-    python_default_init: 2
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: p
-    python_default_init: 2
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 2
-    default_init: 2
-    dynamic_type: real
-    name: p
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: renorm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: p
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: real
-    name: maxnorm
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: renorm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: p
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: real
-    name: maxnorm
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: renorm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: p
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: real
-    name: maxnorm
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: dist
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 2
-    default_init: 2
-    dynamic_type: real
-    name: p
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reciprocal_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reciprocal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reciprocal_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: neg_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: neg
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: neg_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan2_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan2
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan2_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: exponent
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: exponent
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: exponent
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: exponent
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: real
-    name: base
-    type: Scalar
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: real
-    name: base
-    type: Scalar
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: exponent
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: exponent
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lerp_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: end
-    type: const Tensor &
-  - dynamic_type: real
-    name: weight
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lerp
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: end
-    type: const Tensor &
-  - dynamic_type: real
-    name: weight
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lerp_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: end
-    type: const Tensor &
-  - dynamic_type: real
-    name: weight
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _linspace_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: real
-    name: start
-    type: Scalar
-  - dynamic_type: real
-    name: end
-    type: Scalar
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _linspace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: real
-    name: start
-    type: Scalar
-  - dynamic_type: real
-    name: end
-    type: Scalar
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _logspace_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: real
-    name: start
-    type: Scalar
-  - dynamic_type: real
-    name: end
-    type: Scalar
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _logspace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: real
-    name: start
-    type: Scalar
-  - dynamic_type: real
-    name: end
-    type: Scalar
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: histc_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: bins
-    type: int64_t
-  - default: 0
-    default_init: 0
-    dynamic_type: real
-    name: min
-    type: Scalar
-  - default: 0
-    default_init: 0
-    dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: histc
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: bins
-    type: int64_t
-  - default: 0
-    default_init: 0
-    dynamic_type: real
-    name: min
-    type: Scalar
-  - default: 0
-    default_init: 0
-    dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: zero_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sumall
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_sum_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _prodall
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_prod_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cumsum_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cumsum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cumprod_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cumprod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sign_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sign
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sign_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: trace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: other
-    type: SparseTensor
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: other
-    type: SparseTensor
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: SparseTensor
-    name: other
-    type: SparseTensor
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_min_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_min
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_min_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_max_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_max
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_max_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dot
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tril_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tril
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tril_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: triu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: triu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: triu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cross_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cross
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: diag_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: diag
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: mat1
-    type: SparseTensor
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: mat1
-    type: SparseTensor
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: SparseTensor
-    name: mat1
-    type: SparseTensor
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addmv_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addmv
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addmv_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addr_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addr
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addr_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _ger_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _ger
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _mv_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _mv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _mm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _mm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: bmm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: bmm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addbmm_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addbmm
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addbmm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: baddbmm_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: baddbmm
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: baddbmm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcmul_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcmul
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcmul_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcdiv_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcdiv
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcdiv_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _gesv_single_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: solution
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: lu
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: solution
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: lu
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _gesv_single
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: solution
-    type: Tensor
-  - dynamic_type: Tensor
-    name: lu
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gels_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gels
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: trtrs_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: transpose
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: unitriangular
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: trtrs
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: transpose
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: unitriangular
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: symeig_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: eigenvectors
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: symeig
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: eigenvectors
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eig_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: eigenvectors
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eig
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: eigenvectors
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: svd_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res3
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: some
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res3
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: svd
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: some
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res3
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: inverse_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: inverse
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potrf_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potrf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potrs_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potrs
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potri_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potri
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pstrf_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  - default: -1
-    default_init: -1
-    dynamic_type: real
-    name: tol
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pstrf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  - default: -1
-    default_init: -1
-    dynamic_type: real
-    name: tol
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: IntegerTensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: qr_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: qr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: geqrf_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: geqrf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: orgqr_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: orgqr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ormqr_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input3
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: left
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: transpose
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ormqr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input3
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: left
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: transpose
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrifact_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: pivots
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    kwarg_only: true
-    name: pivot
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: pivots
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrifact
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    kwarg_only: true
-    name: pivot
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  - dynamic_type: IntegerTensor
-    name: pivots
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrifact_with_info_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: pivots
-    output: true
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: info
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    kwarg_only: true
-    name: pivot
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: pivots
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: info
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrifact_with_info
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    kwarg_only: true
-    name: pivot
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  - dynamic_type: IntegerTensor
-    name: pivots
-    type: Tensor
-  - dynamic_type: IntegerTensor
-    name: info
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrisolve_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: LU_data
-    type: const Tensor &
-  - dynamic_type: IntegerTensor
-    name: LU_pivots
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrisolve
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: LU_data
-    type: const Tensor &
-  - dynamic_type: IntegerTensor
-    name: LU_pivots
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: random_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: from
-    type: int64_t
-  - dynamic_type: int64_t
-    name: to
-    type: int64_t
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: random_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: to
-    type: int64_t
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: random_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multinomial_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: num_samples
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: replacement
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multinomial
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: num_samples
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: replacement
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: uniform_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: double
-    name: from
-    type: double
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: to
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mean
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: std
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: mean
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: std
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: double
-    name: mean
-    type: double
-  - dynamic_type: Tensor
-    name: std
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: double
-    name: mean
-    type: double
-  - dynamic_type: Tensor
-    name: std
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: std
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: std
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: double
-    name: mean
-    type: double
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: std
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cauchy_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: double
-    name: median
-    type: double
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: sigma
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_normal_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: mean
-    type: double
-  - default: 2
-    default_init: 2
-    dynamic_type: double
-    name: std
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: exponential_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: lambd
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: geometric_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: double
-    name: p
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_bernoulli_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_bernoulli
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dirichlet_grad_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: x
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: alpha
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: total
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dirichlet_grad
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: x
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: alpha
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: total
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Storage
-    name: storage
-    type: Storage &
-  - dynamic_type: int64_t
-    name: storageOffset
-    type: int64_t
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: IntList
-    name: stride
-    type: IntList
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    type: IntList
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tensor
-  method_prefix_derived: ''
-  arguments: []
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sparse_coo_tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: values
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sparse_coo_tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: values
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: alias
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sparse_coo_tensor_unsafe
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: values
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _copy_ignoring_overlaps_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: src
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: as_strided_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    type: IntList
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: storage_offset
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: as_strided
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    type: IntList
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: storage_offset
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: as_strided_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    type: IntList
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: storage_offset
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sparse_raw_resize_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: int64_t
-    name: nDimI
-    type: int64_t
-  - dynamic_type: int64_t
-    name: nDimV
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cat_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    output: true
-    type: Tensor &
-  - dynamic_type: TensorList
-    name: tensors
-    type: TensorList
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cat
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: TensorList
-    name: tensors
-    type: TensorList
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sparse_mask
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: mask
-    type: SparseTensor
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: SparseTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: to_dense
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dimI
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dimV
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _nnz
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: coalesce
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: is_coalesced
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _indices
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _values
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hspmm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hspmm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: kl_div
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: p
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: p
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: p
-    type: Scalar
-  - dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: p
-    type: Scalar
-  - dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: p
-    type: Scalar
-  - dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: p
-    type: Scalar
-  - dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - is_target
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - is_target
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: is_target
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: is_target
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: is_target
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: is_target
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: is_target
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: -100
-    default_init: -100
-    dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - total_weight
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: -100
-    default_init: -100
-    dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - total_weight
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: total_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: total_weight
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: total_weight
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: total_weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: total_weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: -100
-    default_init: -100
-    dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - total_weight
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: -100
-    default_init: -100
-    dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - total_weight
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: total_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: total_weight
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: total_weight
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: total_weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: total_weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: elu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: elu_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: elu_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: glu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: glu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: glu_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: glu_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: glu_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: glu_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.5
-    default_init: 0.5
-    dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.5
-    default_init: 0.5
-    dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.01
-    default_init: 0.01
-    dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.01
-    default_init: 0.01
-    dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0.01
-    default_init: 0.01
-    dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - buffer
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - buffer
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: buffer
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: buffer
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: buffer
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: buffer
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: buffer
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prelu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prelu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prelu_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prelu_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prelu_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prelu_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: '{{true, true}}'
-    default_init: '{{true, true}}'
-    dynamic_type: std::array<bool,2>
-    name: output_mask
-    type: std::array<bool,2>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - default: 0.125
-    default_init: 0.125
-    dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    default_init: 0.3333333333333333
-    dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: training
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - default: 0.125
-    default_init: 0.125
-    dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    default_init: 0.3333333333333333
-    dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: training
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - default: 0.125
-    default_init: 0.125
-    dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    default_init: 0.3333333333333333
-    dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: training
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softplus_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - default: 20
-    default_init: 20
-    dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softplus
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - default: 20
-    default_init: 20
-    dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softplus_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softplus_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softplus_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softplus_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.5
-    default_init: 0.5
-    dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softshrink
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.5
-    default_init: 0.5
-    dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: threshold
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: threshold_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: threshold_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: random_samples
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: random_samples
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: random_samples
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: random_samples
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 4
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 4
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 5
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 5
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _tanh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: momentum
-    type: double
-  - dynamic_type: double
-    name: eps
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - save_mean
-  - save_std
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: momentum
-    type: double
-  - dynamic_type: double
-    name: eps
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - save_mean
-  - save_std
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: save_mean
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: save_std
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: momentum
-    type: double
-  - dynamic_type: double
-    name: eps
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: save_mean
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: save_std
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: momentum
-    type: double
-  - dynamic_type: double
-    name: eps
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: save_mean
-    type: Tensor
-  - dynamic_type: Tensor
-    name: save_std
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: eps
-    type: double
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_std
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: eps
-    type: double
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_std
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - default: '{{true, true}}'
-    default_init: '{{true, true}}'
-    dynamic_type: std::array<bool,2>
-    name: output_mask
-    type: std::array<bool,2>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Byte
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Char
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Double
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Float
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Int
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Long
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Short
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Half
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cudnn_rnn_flatten_weight
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: weight_arr
-    type: TensorList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: weight_stride0
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: input_size
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: hidden_size
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_layers
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: batch_first
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: bidirectional
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cudnn_rnn
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: weight
-    type: TensorList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: weight_stride0
-    type: int64_t
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight_buf
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: hx
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: cx
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: hidden_size
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_layers
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: batch_first
-    type: bool
-  - dynamic_type: double
-    is_nullable: false
-    name: dropout
-    type: double
-  - dynamic_type: bool
-    is_nullable: false
-    name: train
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: bidirectional
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: batch_sizes
-    type: IntList
-  - dynamic_type: BoolTensor
-    is_nullable: true
-    name: dropout_state
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result3
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result4
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cudnn_rnn_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: weight
-    type: TensorList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: weight_stride0
-    type: int64_t
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight_buf
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: hx
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: cx
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_hy
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_cy
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: hidden_size
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_layers
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: batch_first
-    type: bool
-  - dynamic_type: double
-    is_nullable: false
-    name: dropout
-    type: double
-  - dynamic_type: bool
-    is_nullable: false
-    name: train
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: bidirectional
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: batch_sizes
-    type: IntList
-  - dynamic_type: BoolTensor
-    is_nullable: true
-    name: dropout_state
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: reserve
-    type: const Tensor &
-  - dynamic_type: std::array<bool,4>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,4>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  - dynamic_type: TensorList
-    name: result3
-    type: std::vector<Tensor>
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cudnn_init_dropout_state
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: self_ty
-    type: const Type &
-  - dynamic_type: double
-    is_nullable: false
-    name: dropout
-    type: double
-  - dynamic_type: bool
-    is_nullable: false
-    name: train
-    type: bool
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dropout_seed
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: abs
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: abs_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: abs_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: acos
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: acos_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: acos_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_size
-    size: 1
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_size
-    size: 1
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: allclose
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  - default: 1.0e-05
-    dynamic_type: double
-    is_nullable: false
-    name: rtol
-    type: double
-  - default: 1.0e-08
-    dynamic_type: double
-    is_nullable: false
-    name: atol
-    type: double
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: equal_nan
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addmv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addmv_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addmv_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addr_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addr_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: arange
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: arange_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: arange
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: arange_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: argmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: argmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _argmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: argmin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: argmin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _argmin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: asin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: asin_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: asin_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: atan_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: batch_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    is_nullable: false
-    name: training
-    type: bool
-  - dynamic_type: double
-    is_nullable: false
-    name: momentum
-    type: double
-  - dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enabled
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: p
-    type: const Tensor &
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: double
-    is_nullable: false
-    name: p
-    type: double
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: p
-    type: const Tensor &
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: double
-    is_nullable: false
-    name: p
-    type: double
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bilinear
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cat
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cat_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ceil
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ceil_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ceil_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: chunk
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: chunks
-    type: int64_t
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: TensorList
-    name: result
-    type: std::vector<Tensor>
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_is_acceptable
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: convolution
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: transposed
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _convolution
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: transposed
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enabled
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _convolution_nogroup
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: transposed
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _convolution_double_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: ggI
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: ggW
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: ggb
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: gO
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: transposed
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enabled
-    type: bool
-  - dynamic_type: std::array<bool,3>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 1
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 1
-    type: IntList
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 1
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 2
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 2
-    type: IntList
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 2
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 3
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 3
-    type: IntList
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 3
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_tbc
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pad
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_tbc_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pad
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_transpose1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 1
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 1
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    size: 1
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 1
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_transpose2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 2
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 2
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    size: 2
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_transpose3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 3
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 3
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    size: 3
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cos
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cos_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cos_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cosh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cosh_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cosh_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cosine_embedding_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: target
-    type: const Tensor &
-  - default: 0.0
-    dynamic_type: double
-    is_nullable: false
-    name: margin
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: size_average
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_affine_grid_generator
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: theta
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: N
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: C
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: H
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: W
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: grid
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_affine_grid_generator_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: N
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: C
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: H
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: W
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: grad_theta
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_batch_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    is_nullable: false
-    name: training
-    type: bool
-  - dynamic_type: double
-    is_nullable: false
-    name: exponential_average_factor
-    type: double
-  - dynamic_type: double
-    is_nullable: false
-    name: epsilon
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_batch_norm_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_var
-    type: const Tensor &
-  - dynamic_type: double
-    is_nullable: false
-    name: epsilon
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_backward_input
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: self_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  - dynamic_type: std::array<bool,3>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_backward_bias
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_backward_weight
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: weight_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  - dynamic_type: std::array<bool,3>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose_backward_bias
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose_backward_input
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose_backward_weight
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: weight_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_grid_sampler
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grid
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_grid_sampler_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grid
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: grad_self
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_grid
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cumsum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumsum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumsum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumsum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumprod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumprod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumprod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumprod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: det
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: diagflat
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: offset
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: diagonal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: offset
-    type: int64_t
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim1
-    type: int64_t
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim2
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: dot
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: tensor
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: dot_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: tensor
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: einsum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: std::string
-    is_nullable: false
-    name: equation
-    type: std::string
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - default: -1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: padding_idx
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: sparse
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: padding_idx
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: sparse
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_dense_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: padding_idx
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: embedding_renorm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: double
-    is_nullable: false
-    name: max_norm
-    type: double
-  - dynamic_type: double
-    is_nullable: false
-    name: norm_type
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: embedding_sparse_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: padding_idx
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_bag
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offsets
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: sparse
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result3
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: embedding_bag_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offsets
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offset2bag
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: bag_size
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: maximum_indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: sparse
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_bag_sparse_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offsets
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offset2bag
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: bag_size
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_bag_dense_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offsets
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offset2bag
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: bag_size
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: maximum_indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: empty
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: empty_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: empty_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: empty_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: erf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: erf_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: erf_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: exp
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: exp_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: exp_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: expm1
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: expm1_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: expm1_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: expand
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    kwarg_only: true
-    name: implicit
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: expand_as
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: eye
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: n
-    type: int64_t
-  - default: -1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: m
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: eye_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: n
-    type: int64_t
-  - default: -1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: m
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: value
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: floor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: floor_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: floor_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: full
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: fill_value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: full_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: fill_value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: full_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: fill_value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: full_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: fill_value
-    type: Scalar
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hinge_embedding_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: target
-    type: const Tensor &
-  - default: 1.0
-    dynamic_type: double
-    is_nullable: false
-    name: margin
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: size_average
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ger
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ger_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: gesv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: gesv_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: solution
-    output: true
-    type: Tensor &
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: lu
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _gesv_helper
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: group_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_groups
-    type: int64_t
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - default: 1.0e-05
-    dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enabled
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: fft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ifft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rfft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: onesided
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: irfft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: onesided
-    type: bool
-  - default: '{}'
-    dynamic_type: IntList
-    is_nullable: false
-    name: signal_sizes
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _fft_with_size
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: complex_input
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: complex_output
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: inverse
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: checked_signal_sizes
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: onesided
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_sizes
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: indices
-    type: TensorList
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: index_copy_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: index_put_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: indices
-    type: TensorList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: values
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: isclose
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  - default: 1.0e-05
-    dynamic_type: double
-    is_nullable: false
-    name: rtol
-    type: double
-  - default: 1.0e-08
-    dynamic_type: double
-    is_nullable: false
-    name: atol
-    type: double
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: equal_nan
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_cuda
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_distributed
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_floating_point
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_nonzero
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_same_size
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_signed
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_sparse
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: layer_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: normalized_shape
-    type: IntList
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - default: 1.0e-05
-    dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enable
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: linspace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 100
-    dynamic_type: int64_t
-    is_nullable: false
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: linspace_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 100
-    dynamic_type: int64_t
-    is_nullable: false
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log10
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log10_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log10_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log1p
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log1p_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log1p_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log2
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log2_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log2_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: logdet
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: logspace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 100
-    dynamic_type: int64_t
-    is_nullable: false
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: logspace_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 100
-    dynamic_type: int64_t
-    is_nullable: false
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log_softmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_softmax_backward_data
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: output
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: logsumexp
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: logsumexp_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: margin_ranking_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: target
-    type: const Tensor &
-  - default: 0.0
-    dynamic_type: double
-    is_nullable: false
-    name: margin
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: size_average
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: matmul
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: matmul_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_values
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: kernel_size
-    size: 1
-    type: IntList
-  - default: '{}'
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 1
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 1
-    type: IntList
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: min_values
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mkldnn_convolution
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mkldnn_convolution_backward_input
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: self_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: bias_defined
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mkldnn_convolution_backward_weights
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: weight_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: bias_defined
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mkldnn_convolution_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: std::array<bool,3>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mm_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mv_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: narrow
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: start
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: length
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ones
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ones_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ones_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ones_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: pairwise_distance
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: x1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: x2
-    type: const Tensor &
-  - default: 2
-    dynamic_type: double
-    is_nullable: false
-    name: p
-    type: double
-  - default: 1.0e-06
-    dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: permute
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dims
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: pin_memory
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rand
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rand_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rand_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rand_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: low
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: low
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: low
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: low
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randn
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randn_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randn_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randn_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randperm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: n
-    type: int64_t
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randperm_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: n
-    type: int64_t
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: range
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: range_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: repeat
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: repeats
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reshape
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: shape
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: RoiPooling2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: rois
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pooledHeight
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pooledWidth
-    type: int64_t
-  - dynamic_type: double
-    is_nullable: false
-    name: spatialScale
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: RoiPooling2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: rois
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pooledHeight
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pooledWidth
-    type: int64_t
-  - dynamic_type: double
-    is_nullable: false
-    name: spatialScale
-    type: double
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: gradOutput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: argmaxes
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: round
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: round_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: round_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: 0.125
-    dynamic_type: Scalar
-    is_nullable: false
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    dynamic_type: Scalar
-    is_nullable: false
-    name: upper
-    type: Scalar
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: training
-    type: bool
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - default: 0.125
-    dynamic_type: Scalar
-    is_nullable: false
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    dynamic_type: Scalar
-    is_nullable: false
-    name: upper
-    type: Scalar
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: training
-    type: bool
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: relu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: relu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rsqrt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rsqrt_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rsqrt_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: select
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: index
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: selu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: selu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sin_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sin_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sinh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sinh_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sinh_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: size
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: slice
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: start
-    type: int64_t
-  - default: 9223372036854775807
-    dynamic_type: int64_t
-    is_nullable: false
-    name: end
-    type: int64_t
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: step
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: slogdet
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: smm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softmax_backward_data
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: output
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: split
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: split_size
-    type: int64_t
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: TensorList
-    name: result
-    type: std::vector<Tensor>
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: split_with_sizes
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: split_sizes
-    type: IntList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: TensorList
-    name: result
-    type: std::vector<Tensor>
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: squeeze
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: squeeze
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: squeeze_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: squeeze_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sspaddmm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sspaddmm_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: stack
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: stack_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: stft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: frame_length
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: hop
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: fft_size
-    python_default_init: frame_length
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: onesided
-    type: bool
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: window
-    type: const Tensor &
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: pad_end
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: stride
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sum_cuda_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sqrt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sqrt_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sqrt_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _prod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: t
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: t_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: tan
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: tan_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tan_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tanh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: tanh_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tanh_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: transpose
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim0
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim1
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: transpose_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim0
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim1
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _trilinear
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: i1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: i2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: i3
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: expand1
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: expand2
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: expand3
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: sumdim
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: unroll_dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: triplet_margin_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: anchor
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: positive
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: negative
-    type: const Tensor &
-  - default: 1.0
-    dynamic_type: double
-    is_nullable: false
-    name: margin
-    type: double
-  - default: 2
-    dynamic_type: double
-    is_nullable: false
-    name: p
-    type: double
-  - default: 1.0e-06
-    dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: swap
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: size_average
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: trunc
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: trunc_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: trunc_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: type_as
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _unique
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: sorted
-    type: bool
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: return_inverse
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _unsafe_view
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: unsqueeze
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: unsqueeze_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: view_as
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: where
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    is_nullable: false
-    name: condition
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _s_where
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    is_nullable: false
-    name: condition
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: zeros
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: zeros_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: zeros_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: zeros_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _standard_gamma_grad
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _standard_gamma
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: poisson
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false

From 7b305c605e98baca7d5bfaea78501974aaf6e6ce Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 16:06:08 -0700
Subject: [PATCH 084/118] Include common.h

---
 caffe2/core/net_async_tracing.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/caffe2/core/net_async_tracing.cc b/caffe2/core/net_async_tracing.cc
index b2c4a1952b785..d9093e985391a 100644
--- a/caffe2/core/net_async_tracing.cc
+++ b/caffe2/core/net_async_tracing.cc
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "caffe2/core/common.h"
 #include "caffe2/core/net_async_tracing.h"
 
 #include "caffe2/utils/string_utils.h"

From 7fc41efa43193bc320f285406f14de9f6dd5ef9f Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 16:17:44 -0700
Subject: [PATCH 085/118] Change std::stoi to caffe2::stoi

---
 caffe2/core/net_async_tracing.cc | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/caffe2/core/net_async_tracing.cc b/caffe2/core/net_async_tracing.cc
index d9093e985391a..b19acb653dad0 100644
--- a/caffe2/core/net_async_tracing.cc
+++ b/caffe2/core/net_async_tracing.cc
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include "caffe2/core/common.h"
 #include "caffe2/core/net_async_tracing.h"
 
 #include "caffe2/utils/string_utils.h"
@@ -323,7 +322,7 @@ int extractShardId(const std::string& name) {
     while (right_pos < name.length() && isdigit(name[right_pos])) {
       right_pos++;
     }
-    return std::stoi(name.substr(left_pos, right_pos - left_pos));
+    return caffe2::stoi(name.substr(left_pos, right_pos - left_pos));
   } else {
     return -1;
   }

From ad58f8992a6da1f7bbd949fb7693b6bdb8cbe563 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 16:31:17 -0700
Subject: [PATCH 086/118] Add thread_name.cc to the CMake file

---
 caffe2/utils/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/caffe2/utils/CMakeLists.txt b/caffe2/utils/CMakeLists.txt
index 90d853c0e7da8..d774caceb4e19 100644
--- a/caffe2/utils/CMakeLists.txt
+++ b/caffe2/utils/CMakeLists.txt
@@ -9,6 +9,7 @@ set(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS}
         utils/bench_utils.cc
         utils/math_cpu.cc
         utils/math_utils.cc
+        utils/thread_name.cc
         )
 
 # ---[ threadpool/pthreadpool* is a local modification of the NNPACK

From 807465ef03d1c4e9e53a50d4cbbb2b490d0f53dd Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 19:37:42 -0700
Subject: [PATCH 087/118] No need to subtract 1. Fix test segfaults

---
 caffe2/core/net.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/caffe2/core/net.cc b/caffe2/core/net.cc
index 19f1c4798c717..dfca11318669e 100644
--- a/caffe2/core/net.cc
+++ b/caffe2/core/net.cc
@@ -122,7 +122,7 @@ void checkExecutorOverride(std::string& net_type) {
   for (const auto& kv : defaultOverrides()) {
     overrides[kv.first] = kv.second;
   }
-  for (size_t idx = 0; idx < executors.size() - 1; idx += 2) {
+  for (size_t idx = 0; idx < executors.size(); idx += 2) {
     overrides[executors[idx]] = executors[idx + 1];
   }
   if (overrides.count(net_type)) {

From b581e16129483e1a03484cffdb5d9aba9a801dd9 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 22:01:46 -0700
Subject: [PATCH 088/118] Fix NetTest, ObserverTest

Fix tests

(cherry picked from commit 3767e66c3f365596cba3d46d3e7322c933a0ab41)
---
 caffe2/core/net_async_base.cc |  6 +++---
 caffe2/core/net_async_base.h  |  5 +++++
 caffe2/core/net_gpu_test.cc   |  2 +-
 caffe2/core/net_test.cc       | 24 ++++++++++--------------
 caffe2/core/observer_test.cc  |  1 -
 5 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/caffe2/core/net_async_base.cc b/caffe2/core/net_async_base.cc
index 89d579aeb4c1d..435b500cc045d 100644
--- a/caffe2/core/net_async_base.cc
+++ b/caffe2/core/net_async_base.cc
@@ -68,9 +68,9 @@ AsyncNetBase::AsyncNetBase(
     operators_.push_back(op_ptr);
   }
 
-  const auto& execution_chains = dag_utils::computeChains(operator_nodes_);
-  chains_.reserve(execution_chains.size());
-  for (const auto& kv : execution_chains) {
+  execution_chains_ = dag_utils::computeChains(operator_nodes_);
+  chains_.reserve(execution_chains_.size());
+  for (const auto& kv : execution_chains_) {
     chains_.push_back(kv.second);
   }
   chain_nodes_ = dag_utils::prepareChainGraphNodes(operator_nodes_, chains_);
diff --git a/caffe2/core/net_async_base.h b/caffe2/core/net_async_base.h
index c7047d2e64162..e93275da1bc03 100644
--- a/caffe2/core/net_async_base.h
+++ b/caffe2/core/net_async_base.h
@@ -48,6 +48,10 @@ class AsyncNetBase : public NetBase {
 
   bool RunAsync() override;
 
+  const dag_utils::ExecutionChains& TEST_execution_chains() const {
+    return execution_chains_;
+  }
+
  protected:
   bool canSchedule(
       int chain_id,
@@ -85,6 +89,7 @@ class AsyncNetBase : public NetBase {
   std::vector<dag_utils::OperatorNode> operator_nodes_;
   std::vector<std::vector<int>> chains_;
   std::vector<dag_utils::OpGraphNode> chain_nodes_; // chains' parents/children
+  dag_utils::ExecutionChains execution_chains_; // for testing
 
   // Pools and streams
   std::mutex pools_mutex_;
diff --git a/caffe2/core/net_gpu_test.cc b/caffe2/core/net_gpu_test.cc
index e093889a6261c..8bc82b53f5b54 100644
--- a/caffe2/core/net_gpu_test.cc
+++ b/caffe2/core/net_gpu_test.cc
@@ -84,7 +84,7 @@ void checkChainingAndRun(
     FLAGS_caffe2_disable_chaining = false;
 
     std::unique_ptr<NetBase> net(CreateNet(net_def, &ws));
-    auto* dag = dynamic_cast_if_rtti<DAGNetBase*>(net.get());
+    auto* dag = dynamic_cast_if_rtti<AsyncNetBase*>(net.get());
     CHECK_NOTNULL(dag);
     const auto& chains = dag->TEST_execution_chains();
     EXPECT_EQ(chains, expected);
diff --git a/caffe2/core/net_test.cc b/caffe2/core/net_test.cc
index ce2252c07189e..ed0b8c49bd3a9 100644
--- a/caffe2/core/net_test.cc
+++ b/caffe2/core/net_test.cc
@@ -155,7 +155,7 @@ void checkChainingAndRun(
     FLAGS_caffe2_disable_chaining = false;
 
     std::unique_ptr<NetBase> net(CreateNet(net_def, &ws));
-    auto* dag = dynamic_cast_if_rtti<DAGNetBase*>(net.get());
+    auto* dag = dynamic_cast_if_rtti<AsyncNetBase*>(net.get());
     CHECK_NOTNULL(dag);
     const auto& chains = dag->TEST_execution_chains();
     EXPECT_TRUE(chains == expected);
@@ -182,7 +182,7 @@ void checkNumChainsAndRun(const char* spec, const int expected_num_chains) {
     FLAGS_caffe2_disable_chaining = false;
 
     std::unique_ptr<NetBase> net(CreateNet(net_def, &ws));
-    auto* dag = dynamic_cast_if_rtti<DAGNetBase*>(net.get());
+    auto* dag = dynamic_cast_if_rtti<AsyncNetBase*>(net.get());
     CHECK_NOTNULL(dag);
     const auto& chains = dag->TEST_execution_chains();
     EXPECT_EQ(expected_num_chains, chains.size());
@@ -579,7 +579,14 @@ TEST(NetTest, FailingOperator) {
     std::unique_ptr<NetBase> net(CreateNet(net_def, &ws));
     for (int i = 0; i < 10; i++) {
       counter.exchange(0);
-      ASSERT_FALSE(net->Run());
+      bool run_result = false;
+      try {
+        run_result = net->Run();
+      } catch (const std::exception&) {
+        // async_scheduling would throw
+      }
+      ASSERT_FALSE(run_result);
+
       ASSERT_EQ(1, counter.load());
     }
   }
@@ -675,17 +682,6 @@ TEST(NetTest, ExecutorOverride) {
   CAFFE_ENFORCE(
       ::google::protobuf::TextFormat::ParseFromString(spec, &net_def));
 
-  {
-    Workspace ws;
-    auto old = FLAGS_caffe2_override_executor;
-    auto g = MakeGuard([&]() { FLAGS_caffe2_override_executor = old; });
-    FLAGS_caffe2_override_executor = "";
-
-    std::unique_ptr<NetBase> net(CreateNet(net_def, &ws));
-    auto dag_net = caffe2::dynamic_cast_if_rtti<DAGNet*>(net.get());
-    ASSERT_TRUE(dag_net != nullptr);
-  }
-
   {
     Workspace ws;
     auto old = FLAGS_caffe2_override_executor;
diff --git a/caffe2/core/observer_test.cc b/caffe2/core/observer_test.cc
index 73baf28b18ba2..f4f4e81a3cb45 100644
--- a/caffe2/core/observer_test.cc
+++ b/caffe2/core/observer_test.cc
@@ -143,7 +143,6 @@ TEST(ObserverTest, TestDAGNetBase) {
   ws.CreateBlob("in");
   NetDef net_def;
   unique_ptr<NetBase> net(CreateNetTestHelper(&ws, true));
-  EXPECT_EQ(caffe2::dynamic_cast_if_rtti<DAGNetBase*>(net.get()), net.get());
   unique_ptr<DummyObserver<NetBase>> net_ob =
       make_unique<DummyObserver<NetBase>>(net.get());
   net.get()->AttachObserver(std::move(net_ob));

From 2b888c02d8b7a75f47c168c4c5fd58f6c5fb03b9 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 23:15:34 -0700
Subject: [PATCH 089/118] CTCGreedyDecoderOp only has CPU implementation, test
 should only run on CPU

---
 caffe2/python/operator_test/ctc_greedy_decoder_op_test.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py b/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py
index 4ae1db3050bc4..632a44d960fc5 100644
--- a/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py
+++ b/caffe2/python/operator_test/ctc_greedy_decoder_op_test.py
@@ -18,7 +18,7 @@ class TestCTCGreedyDecoderOp(hu.HypothesisTestCase):
         max_time=st.sampled_from([2, 10, 30, 50]),
         num_classes=st.sampled_from([2, 10, 26, 40]),
         merge_repeated=st.sampled_from([True, False]),
-        **hu.gcs
+        **hu.gcs_cpu_only
     )
     def test_ctc_greedy_decoder(
         self, batch, max_time,

From 8d01ecb00d0fa1b1cb7e96cbac2b9c593a3a4016 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Wed, 13 Jun 2018 07:08:10 -0700
Subject: [PATCH 090/118] Add a variable to avoid conversion resizing issue

---
 caffe2/operators/ctc_greedy_decoder_op.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/caffe2/operators/ctc_greedy_decoder_op.cc b/caffe2/operators/ctc_greedy_decoder_op.cc
index 5f9792d651b37..1a9c415aac74b 100644
--- a/caffe2/operators/ctc_greedy_decoder_op.cc
+++ b/caffe2/operators/ctc_greedy_decoder_op.cc
@@ -54,7 +54,8 @@ bool CTCGreedyDecoderOp<CPUContext>::RunOnDevice() {
     output_len_data[i] = t_dec;
   }
 
-  values->Resize(vector<TIndex>{values_cach.size()});
+  int32_t values_cach_size = values_cach.size();
+  values->Resize(vector<TIndex>{values_cach_size});
   int* values_data = values->mutable_data<int>();
   for (int i = 0; i < values_cach.size(); ++i) {
     values_data[i] = values_cach.at(i);

From b64bf46f459989be1c344d288c0e88eaf8549774 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Wed, 13 Jun 2018 10:26:39 -0700
Subject: [PATCH 091/118] Remove the code per soumith's comments

---
 tools/jit/gen_jit_dispatch.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tools/jit/gen_jit_dispatch.py b/tools/jit/gen_jit_dispatch.py
index f494fa0a4f549..05c959110b906 100644
--- a/tools/jit/gen_jit_dispatch.py
+++ b/tools/jit/gen_jit_dispatch.py
@@ -94,8 +94,6 @@ def is_jit_op(decl):
     # Only support a single TensorList arg
     if sum(arg['simple_type'] == 'TensorList' for arg in arguments) > 1:
         return False
-    if any(arg['simple_type'] == 'std::string' for arg in arguments):
-        return False
 
     return ((not decl['api_name'].endswith('_') or is_magic_method(decl['api_name'])) and
             not decl['name'].endswith('_out') and

From 4c59602b71c6e1159c0c112353cc4148bc3a9a41 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Wed, 13 Jun 2018 10:28:49 -0700
Subject: [PATCH 092/118] Remove the code per soumith's comments

---
 tools/jit/gen_jit_dispatch.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tools/jit/gen_jit_dispatch.py b/tools/jit/gen_jit_dispatch.py
index f494fa0a4f549..05c959110b906 100644
--- a/tools/jit/gen_jit_dispatch.py
+++ b/tools/jit/gen_jit_dispatch.py
@@ -94,8 +94,6 @@ def is_jit_op(decl):
     # Only support a single TensorList arg
     if sum(arg['simple_type'] == 'TensorList' for arg in arguments) > 1:
         return False
-    if any(arg['simple_type'] == 'std::string' for arg in arguments):
-        return False
 
     return ((not decl['api_name'].endswith('_') or is_magic_method(decl['api_name'])) and
             not decl['name'].endswith('_out') and

From 1fa592bb8e8c95f1e2ff3a6464ad1307bc315800 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Wed, 13 Jun 2018 10:37:59 -0700
Subject: [PATCH 093/118] Remove blank lines in the end of file

---
 tools/nnwrap/generate_wrappers.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tools/nnwrap/generate_wrappers.py b/tools/nnwrap/generate_wrappers.py
index c190f7fc9ee5a..6c78fe3b0705d 100644
--- a/tools/nnwrap/generate_wrappers.py
+++ b/tools/nnwrap/generate_wrappers.py
@@ -128,5 +128,3 @@ def wrap_cunn(thcunn_h_path, install_dir, template_path):
     cwrap(os.path.join(install_dir, 'THCUNN.cwrap'),
           plugins=[NNExtension('torch._C._THCUNN'), NullableArguments(), AutoGPU(has_self=False)],
           template_path=template_path)
-
-

From 855d0a91981c1d5fb282a3cb3a418376a6094ea3 Mon Sep 17 00:00:00 2001
From: Anders Papitto <andersj@fb.com>
Date: Tue, 12 Jun 2018 09:58:03 -0700
Subject: [PATCH 094/118] Resolve conflicts for torch/_thnn/utils.py

---
 tools/autograd/gen_python_functions.py |  6 +++++-
 tools/autograd/utils.py                |  8 +++++---
 tools/nnwrap/generate_wrappers.py      | 12 ++++++++----
 tools/setup_helpers/generate_code.py   | 11 +++++++----
 4 files changed, 25 insertions(+), 12 deletions(-)

diff --git a/tools/autograd/gen_python_functions.py b/tools/autograd/gen_python_functions.py
index c5fcca7b3b0c0..ba58cde552e54 100644
--- a/tools/autograd/gen_python_functions.py
+++ b/tools/autograd/gen_python_functions.py
@@ -9,7 +9,11 @@
 from .gen_variable_type import should_trace
 from .utils import write
 
-CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
+try:
+    from src.ATen.code_template import CodeTemplate
+except ImportError:
+    from tools.shared.module_loader import import_module
+    CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
 
 # These functions require manual Python bindings or are not exposed to Python
 SKIP_PYTHON_BINDINGS = [
diff --git a/tools/autograd/utils.py b/tools/autograd/utils.py
index 608b7ea2d8c38..6758e71ffc97e 100644
--- a/tools/autograd/utils.py
+++ b/tools/autograd/utils.py
@@ -1,6 +1,5 @@
 import re
 import os
-from tools.shared.module_loader import import_module
 from .nested_dict import nested_dict
 
 
@@ -9,8 +8,11 @@
     'split_name_params', 'write',
 ]
 
-
-CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
+try:
+    from src.ATen.code_template import CodeTemplate
+except ImportError:
+    from tools.shared.module_loader import import_module
+    CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
 
 try:
     # use faster C loader if available
diff --git a/tools/nnwrap/generate_wrappers.py b/tools/nnwrap/generate_wrappers.py
index c190f7fc9ee5a..1edbca928c17d 100644
--- a/tools/nnwrap/generate_wrappers.py
+++ b/tools/nnwrap/generate_wrappers.py
@@ -109,7 +109,12 @@ def wrap_nn(thnn_h_path, install_dir, template_path):
     for fn in nn_functions:
         for t in ['Float', 'Double']:
             wrapper += wrap_function(fn.name, t, fn.arguments)
-    with open('torch/csrc/nn/THNN.cwrap', 'w') as f:
+    install_dir = install_dir or 'torch/csrc/nn'
+    try:
+        os.makedirs(install_dir)
+    except OSError:
+        pass
+    with open(os.path.join(install_dir, 'THNN.cwrap'), 'w') as f:
         f.write(wrapper)
     cwrap(os.path.join(install_dir, 'THNN.cwrap'),
           plugins=[NNExtension('torch._C._THNN'), NullableArguments()],
@@ -123,10 +128,9 @@ def wrap_cunn(thcunn_h_path, install_dir, template_path):
     for fn in cunn_functions:
         for t in ['CudaHalf', 'Cuda', 'CudaDouble']:
             wrapper += wrap_function(fn.name, t, fn.arguments)
-    with open('torch/csrc/nn/THCUNN.cwrap', 'w') as f:
+    install_dir = install_dir or 'torch/csrc/nn'
+    with open(os.path.join(install_dir, 'THCUNN.cwrap'), 'w') as f:
         f.write(wrapper)
     cwrap(os.path.join(install_dir, 'THCUNN.cwrap'),
           plugins=[NNExtension('torch._C._THCUNN'), NullableArguments(), AutoGPU(has_self=False)],
           template_path=template_path)
-
-
diff --git a/tools/setup_helpers/generate_code.py b/tools/setup_helpers/generate_code.py
index 7c4b9e1869ed6..c9779fb86972c 100644
--- a/tools/setup_helpers/generate_code.py
+++ b/tools/setup_helpers/generate_code.py
@@ -65,7 +65,8 @@ def generate_code_ninja(w):
 
 def generate_code(ninja_global=None,
                   declarations_path=None,
-                  nn_path=None):
+                  nn_path=None,
+                  install_dir=None):
     # if ninja is enabled, we just register this file as something
     # ninja will need to call if needed
     if ninja_global is not None:
@@ -83,8 +84,8 @@ def generate_code(ninja_global=None,
     generate_nn_wrappers(nn_path, install_dir, 'tools/cwrap/plugins/templates')
 
     # Build ATen based Variable classes
-    autograd_gen_dir = 'torch/csrc/autograd/generated'
-    jit_gen_dir = 'torch/csrc/jit/generated'
+    autograd_gen_dir = install_dir or 'torch/csrc/autograd/generated'
+    jit_gen_dir = install_dir or 'torch/csrc/jit/generated'
     for d in (autograd_gen_dir, jit_gen_dir):
         if not os.path.exists(d):
             os.makedirs(d)
@@ -97,10 +98,12 @@ def main():
     parser.add_argument('--declarations-path')
     parser.add_argument('--nn-path')
     parser.add_argument('--ninja-global')
+    parser.add_argument('--install_dir')
     options = parser.parse_args()
     generate_code(options.ninja_global,
                   options.declarations_path,
-                  options.nn_path)
+                  options.nn_path,
+                  options.install_dir)
 
 
 if __name__ == "__main__":

From 3b78ab791b5a2b9147bea730b1018811349a2b0d Mon Sep 17 00:00:00 2001
From: Viswanath Sivakumar <viswanath@fb.com>
Date: Tue, 12 Jun 2018 09:59:51 -0700
Subject: [PATCH 095/118] Update MKL exporter to IDEEP ops

TSIA
---
 caffe2/python/mkl/rewrite_graph.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/caffe2/python/mkl/rewrite_graph.py b/caffe2/python/mkl/rewrite_graph.py
index 157b0251db9ac..1c8b9aa9416f0 100644
--- a/caffe2/python/mkl/rewrite_graph.py
+++ b/caffe2/python/mkl/rewrite_graph.py
@@ -69,7 +69,6 @@ def mkl_tmp(name):
         net.ParseFromString(
             C.transform_optimizeForIDEEP(net.SerializeToString()))
 
-
 def rewrite_model_helper_simple(model, ideep=True):
     model = copy.deepcopy(model)
     # All parameter initialization should run on MKL

From 2fd907a74af4b10f9aa7fdb0eb5c60027cf87ff4 Mon Sep 17 00:00:00 2001
From: Anders Papitto <andersj@fb.com>
Date: Tue, 12 Jun 2018 10:00:11 -0700
Subject: [PATCH 096/118] Back out "Add support for generating ATen files
 during fbcode build"

Original commit changeset: 28970ddba353

@override-unit-failures
(Note: this ignores all push blocking failures!)
---
 aten/src/ATen/Declarations.yaml        | 32527 +++++++++++++++++++++++
 aten/src/ATen/gen.py                   |    16 +-
 tools/autograd/gen_python_functions.py |     6 +-
 tools/autograd/utils.py                |     8 +-
 tools/nnwrap/generate_wrappers.py      |    10 +-
 5 files changed, 32539 insertions(+), 28 deletions(-)
 create mode 100644 aten/src/ATen/Declarations.yaml

diff --git a/aten/src/ATen/Declarations.yaml b/aten/src/ATen/Declarations.yaml
new file mode 100644
index 0000000000000..e865a8ab30c66
--- /dev/null
+++ b/aten/src/ATen/Declarations.yaml
@@ -0,0 +1,32527 @@
+- name: storage_offset
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: resize_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: numel
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: set_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Storage
+    name: storage
+    type: Storage &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: set_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Storage
+    name: sourceStorage
+    type: Storage &
+  - dynamic_type: int64_t
+    name: storage_offset
+    type: int64_t
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: IntList
+    name: stride
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: set_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: set_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: _fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: value
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: is_contiguous
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: is_set_to
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: masked_fill_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  - dynamic_type: real
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: masked_fill_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: value
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: masked_scatter_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: masked_select_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: masked_select
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: BoolTensor
+    name: mask
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nonzero_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nonzero
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: contiguous
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clone
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: view
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: resize_as_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: the_template
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_select_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_select
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _indexCopy_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: take_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: take
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: put_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: accumulate
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_add_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: real
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index_fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: value
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: unfold
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dimension
+    type: int64_t
+  - dynamic_type: int64_t
+    name: size
+    type: int64_t
+  - dynamic_type: int64_t
+    name: step
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: false
+- name: _range_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: accreal
+    name: start
+    type: Scalar
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _range
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: accreal
+    name: start
+    type: Scalar
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _arange_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: accreal
+    name: start
+    type: Scalar
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _arange
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: accreal
+    name: start
+    type: Scalar
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _arange_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _arange
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: accreal
+    name: end
+    type: Scalar
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: scatter_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: src
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: scatter_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: real
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: scatter_add_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: src
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gather_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gather
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    name: index
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: data_ptr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: void*
+    name: result
+    type: void*
+  inplace: false
+  abstract: true
+  auto_gpu: false
+  with_gil: true
+- name: equal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __and___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __and__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __and___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __and__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __iand__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __iand__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __or___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __or__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __or___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __or__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ior__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ior__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __xor___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __xor__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __xor___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __xor__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ixor__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ixor__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __lshift___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __lshift__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __lshift___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __lshift__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ilshift__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __ilshift__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __rshift___out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __rshift__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __rshift___out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __rshift__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __irshift__
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: __irshift__
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lt_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gt_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: le_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ge_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eq_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: BoolTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: BoolTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ne_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: min
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: min_indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: min
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: min_indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: min
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: min_indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: min
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: max
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: max_indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: max
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: max_indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: max
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: max_indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kthvalue_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: k
+    type: int64_t
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kthvalue
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: k
+    type: int64_t
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mode_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mode
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: median_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: median
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: median
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sort_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: descending
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sort
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: descending
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: topk_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: values
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: k
+    type: int64_t
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: largest
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: sorted
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: topk
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: k
+    type: int64_t
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: largest
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: sorted
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: values
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: all_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: all
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: all
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: any_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: any
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: any
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: real
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: get_device
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _abs_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _abs
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sigmoid_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sigmoid_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sigmoid
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log10_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log10
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log1p_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log1p
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log2_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _log2
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lgamma_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lgamma
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lgamma_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: digamma_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: digamma
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: digamma_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: polygamma_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: n
+    type: int64_t
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: polygamma
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: int64_t
+    name: n
+    type: int64_t
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: polygamma_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: n
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _exp_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _exp
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _expm1_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _expm1
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cos_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cos
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _acos_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _acos
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cosh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cosh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sin_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _asin_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _asin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sinh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sinh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tan_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tan
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _atan_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _atan
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_tanh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_tanh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _erf_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _erf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: erfinv_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: erfinv_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: erfinv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sqrt_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sqrt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _rsqrt_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _rsqrt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _ceil_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _ceil
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _floor_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _floor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _round_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _round
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _trunc_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _trunc
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: frac_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: frac_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: frac
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mean_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mean
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mean
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: var_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: var
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: var
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: std_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: std
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: std
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: unbiased
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: norm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: p
+    python_default_init: 2
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: p
+    python_default_init: 2
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 2
+    default_init: 2
+    dynamic_type: real
+    name: p
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: renorm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: p
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: real
+    name: maxnorm
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: renorm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: p
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: real
+    name: maxnorm
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: renorm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: p
+    type: Scalar
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - dynamic_type: real
+    name: maxnorm
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: dist
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 2
+    default_init: 2
+    dynamic_type: real
+    name: p
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reciprocal_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reciprocal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reciprocal_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: neg_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: neg
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: neg_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan2_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan2
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan2_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: exponent
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: exponent
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: exponent
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: exponent
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: real
+    name: base
+    type: Scalar
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: real
+    name: base
+    type: Scalar
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: exponent
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pow_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: exponent
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lerp_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: end
+    type: const Tensor &
+  - dynamic_type: real
+    name: weight
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lerp
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: end
+    type: const Tensor &
+  - dynamic_type: real
+    name: weight
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: lerp_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: end
+    type: const Tensor &
+  - dynamic_type: real
+    name: weight
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _linspace_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: real
+    name: start
+    type: Scalar
+  - dynamic_type: real
+    name: end
+    type: Scalar
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _linspace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: real
+    name: start
+    type: Scalar
+  - dynamic_type: real
+    name: end
+    type: Scalar
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _logspace_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: real
+    name: start
+    type: Scalar
+  - dynamic_type: real
+    name: end
+    type: Scalar
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _logspace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: real
+    name: start
+    type: Scalar
+  - dynamic_type: real
+    name: end
+    type: Scalar
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: histc_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: bins
+    type: int64_t
+  - default: 0
+    default_init: 0
+    dynamic_type: real
+    name: min
+    type: Scalar
+  - default: 0
+    default_init: 0
+    dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: histc
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 100
+    default_init: 100
+    dynamic_type: int64_t
+    name: bins
+    type: int64_t
+  - default: 0
+    default_init: 0
+    dynamic_type: real
+    name: min
+    type: Scalar
+  - default: 0
+    default_init: 0
+    dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: zero_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sumall
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_sum_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _prodall
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_prod_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cumsum_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cumsum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cumprod_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cumprod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sign_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sign
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sign_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: trace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: other
+    type: SparseTensor
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: other
+    type: SparseTensor
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: add_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: SparseTensor
+    name: other
+    type: SparseTensor
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sub_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mul_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: div_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fmod_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: other
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: remainder_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_min_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_min
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_min_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: min
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_max_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_max
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: clamp_max_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: real
+    name: max
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dot
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: accreal
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tril_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tril
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tril_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: triu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: triu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: triu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cross_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cross
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: other
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: diag_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: diag
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: diagonal
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: mat1
+    type: SparseTensor
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: mat1
+    type: SparseTensor
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addmm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: SparseTensor
+    name: mat1
+    type: SparseTensor
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addmv_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addmv
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addmv_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addr_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addr
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _addr_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _ger_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _ger
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _mv_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _mv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: vec
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _mm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _mm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: bmm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: bmm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addbmm_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addbmm
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addbmm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: baddbmm_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: baddbmm
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: baddbmm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: batch1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: batch2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcmul_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcmul
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcmul_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcdiv_out
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcdiv
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: addcdiv_
+  method_prefix_derived: s_
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: tensor1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: tensor2
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: real
+    kwarg_only: true
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _gesv_single_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: solution
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: lu
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: solution
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: lu
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _gesv_single
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: solution
+    type: Tensor
+  - dynamic_type: Tensor
+    name: lu
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gels_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: gels
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: trtrs_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: transpose
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: unitriangular
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: trtrs
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: A
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: transpose
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: unitriangular
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: symeig_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: eigenvectors
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: symeig
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: eigenvectors
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eig_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: eigenvectors
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: eig
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: eigenvectors
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: svd_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res3
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: some
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res3
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: svd
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: some
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res3
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: inverse_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: inverse
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potrf_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potrf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potrs_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potrs
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potri_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: potri
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pstrf_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  - default: -1
+    default_init: -1
+    dynamic_type: real
+    name: tol
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: pstrf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: upper
+    type: bool
+  - default: -1
+    default_init: -1
+    dynamic_type: real
+    name: tol
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: IntegerTensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: qr_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: qr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: geqrf_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: res1
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: geqrf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: res1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: res2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: orgqr_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: orgqr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ormqr_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input3
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: left
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: transpose
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ormqr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: input3
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: left
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: transpose
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrifact_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: pivots
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    kwarg_only: true
+    name: pivot
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: pivots
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrifact
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    kwarg_only: true
+    name: pivot
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  - dynamic_type: IntegerTensor
+    name: pivots
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrifact_with_info_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: pivots
+    output: true
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: info
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    kwarg_only: true
+    name: pivot
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: pivots
+    type: Tensor &
+  - dynamic_type: IntegerTensor
+    name: info
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrifact_with_info
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    kwarg_only: true
+    name: pivot
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  - dynamic_type: IntegerTensor
+    name: pivots
+    type: Tensor
+  - dynamic_type: IntegerTensor
+    name: info
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrisolve_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: LU_data
+    type: const Tensor &
+  - dynamic_type: IntegerTensor
+    name: LU_pivots
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: btrisolve
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: LU_data
+    type: const Tensor &
+  - dynamic_type: IntegerTensor
+    name: LU_pivots
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: random_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: from
+    type: int64_t
+  - dynamic_type: int64_t
+    name: to
+    type: int64_t
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: random_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    name: to
+    type: int64_t
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: random_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multinomial_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: num_samples
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: replacement
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multinomial
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: num_samples
+    type: int64_t
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: replacement
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: uniform_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: double
+    name: from
+    type: double
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: to
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mean
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: std
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: mean
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: std
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: double
+    name: mean
+    type: double
+  - dynamic_type: Tensor
+    name: std
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: double
+    name: mean
+    type: double
+  - dynamic_type: Tensor
+    name: std
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: std
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: std
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: normal_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: double
+    name: mean
+    type: double
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: std
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cauchy_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0
+    default_init: 0
+    dynamic_type: double
+    name: median
+    type: double
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: sigma
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_normal_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: mean
+    type: double
+  - default: 2
+    default_init: 2
+    dynamic_type: double
+    name: std
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: exponential_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: double
+    name: lambd
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: geometric_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: double
+    name: p
+    type: double
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_bernoulli_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _th_bernoulli
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dirichlet_grad_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: x
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: alpha
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: total
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dirichlet_grad
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: x
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: alpha
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: total
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Storage
+    name: storage
+    type: Storage &
+  - dynamic_type: int64_t
+    name: storageOffset
+    type: int64_t
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: IntList
+    name: stride
+    type: IntList
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    type: IntList
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tensor
+  method_prefix_derived: ''
+  arguments: []
+  method_of:
+  - Type
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sparse_coo_tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: values
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sparse_coo_tensor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: values
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: alias
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sparse_coo_tensor_unsafe
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: values
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _copy_ignoring_overlaps_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: src
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: as_strided_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    type: IntList
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: storage_offset
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: as_strided
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    type: IntList
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: storage_offset
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: as_strided_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    type: IntList
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: storage_offset
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sparse_raw_resize_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: IntList
+    name: size
+    type: IntList
+  - dynamic_type: int64_t
+    name: nDimI
+    type: int64_t
+  - dynamic_type: int64_t
+    name: nDimV
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cat_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    output: true
+    type: Tensor &
+  - dynamic_type: TensorList
+    name: tensors
+    type: TensorList
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cat
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: TensorList
+    name: tensors
+    type: TensorList
+  - default: 0
+    default_init: 0
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sparse_mask
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: SparseTensor
+    name: mask
+    type: SparseTensor
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: SparseTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: to_dense
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dimI
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _dimV
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _nnz
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: coalesce
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: is_coalesced
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _indices
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: IndexTensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _values
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hspmm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hspmm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: TH
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: binary_cross_entropy_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: kl_div
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: kl_div_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: l1_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: mse_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: p
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: p
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: p
+    type: Scalar
+  - dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: p
+    type: Scalar
+  - dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: p
+    type: Scalar
+  - dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multi_margin_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: p
+    type: Scalar
+  - dynamic_type: accreal
+    name: margin
+    type: Scalar
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - is_target
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - is_target
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: is_target
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: is_target
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: is_target
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: is_target
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: multilabel_margin_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: is_target
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: -100
+    default_init: -100
+    dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - total_weight
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: -100
+    default_init: -100
+    dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - total_weight
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: total_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: total_weight
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: total_weight
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: total_weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: total_weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: -100
+    default_init: -100
+    dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - total_weight
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: -100
+    default_init: -100
+    dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - total_weight
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: total_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: total_weight
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: total_weight
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: total_weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: nll_loss2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: int64_t
+    name: ignore_index
+    type: int64_t
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  - dynamic_type: Tensor
+    name: total_weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: smooth_l1_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: size_average
+    type: bool
+  - default: true
+    default_init: true
+    dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: soft_margin_loss_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: target
+    type: const Tensor &
+  - dynamic_type: bool
+    name: size_average
+    type: bool
+  - dynamic_type: bool
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: elu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: elu_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: elu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: elu_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: alpha
+    type: Scalar
+  - dynamic_type: accreal
+    name: scale
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: glu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: glu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: glu_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: glu_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: glu_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: glu_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.5
+    default_init: 0.5
+    dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.5
+    default_init: 0.5
+    dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardshrink_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: -1
+    default_init: -1
+    dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hardtanh_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: min_val
+    type: Scalar
+  - dynamic_type: accreal
+    name: max_val
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.01
+    default_init: 0.01
+    dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.01
+    default_init: 0.01
+    dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - default: 0.01
+    default_init: 0.01
+    dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: leaky_relu_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: negative_slope
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - buffer
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - buffer
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: buffer
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: buffer
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: buffer
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: buffer
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_sigmoid_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: buffer
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prelu_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prelu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prelu_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prelu_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prelu_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prelu_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - default: '{{true, true}}'
+    default_init: '{{true, true}}'
+    dynamic_type: std::array<bool,2>
+    name: output_mask
+    type: std::array<bool,2>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - default: 0.125
+    default_init: 0.125
+    dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    default_init: 0.3333333333333333
+    dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: training
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - default: 0.125
+    default_init: 0.125
+    dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    default_init: 0.3333333333333333
+    dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: training
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - default: 0.125
+    default_init: 0.125
+    dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    default_init: 0.3333333333333333
+    dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: training
+    type: bool
+  - default: nullptr
+    default_init: nullptr
+    dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_with_noise_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: noise
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lower
+    type: Scalar
+  - dynamic_type: accreal
+    name: upper
+    type: Scalar
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: Generator*
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softplus_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - default: 20
+    default_init: 20
+    dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softplus
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 1
+    default_init: 1
+    dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - default: 20
+    default_init: 20
+    dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softplus_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softplus_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softplus_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softplus_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: beta
+    type: Scalar
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.5
+    default_init: 0.5
+    dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softshrink
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - default: 0.5
+    default_init: 0.5
+    dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softshrink_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: lambd
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: threshold
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: threshold_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: threshold_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: threshold_forward_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  - dynamic_type: accreal
+    name: threshold
+    type: Scalar
+  - dynamic_type: accreal
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: avg_pool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: bool
+    name: count_include_pad
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: random_samples
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: random_samples
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: random_samples
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: random_samples
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fractional_max_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: kernel_size
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - default: false
+    default_init: false
+    dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: IndexTensor
+    name: indices
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_pool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: ceil_mode
+    type: bool
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: max_unpool3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad1d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: reflection_pad2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad1d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 4
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: replication_pad3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: padding
+    size: 6
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_linear1d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 1
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 4
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_bilinear2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 4
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 5
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_trilinear3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: output_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: input_size
+    size: 5
+    type: IntList
+  - dynamic_type: bool
+    name: align_corners
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest1d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: upsample_nearest3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    name: scale_factor
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _sigmoid_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _tanh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _tanh_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: momentum
+    type: double
+  - dynamic_type: double
+    name: eps
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - save_mean
+  - save_std
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: momentum
+    type: double
+  - dynamic_type: double
+    name: eps
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - save_mean
+  - save_std
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: save_mean
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: save_std
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: momentum
+    type: double
+  - dynamic_type: double
+    name: eps
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: save_mean
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: save_std
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: momentum
+    type: double
+  - dynamic_type: double
+    name: eps
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: save_mean
+    type: Tensor
+  - dynamic_type: Tensor
+    name: save_std
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: eps
+    type: double
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_std
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_batch_norm_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    name: training
+    type: bool
+  - dynamic_type: double
+    name: eps
+    type: double
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_std
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_transpose3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: output_padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_depthwise2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - default: '{{true, true}}'
+    default_init: '{{true, true}}'
+    dynamic_type: std::array<bool,2>
+    name: output_mask
+    type: std::array<bool,2>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - finput
+  - fgrad_input
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: finput
+    type: Tensor
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: finput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: fgrad_input
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 2
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 2
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - default: '{}'
+    default_init: '{}'
+    dynamic_type: Tensor
+    name: bias
+    type: const Tensor &
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - default: '0'
+    default_init: '0'
+    dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - default: '1'
+    default_init: '1'
+    dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers:
+  - columns
+  - ones
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_forward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: output
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  - dynamic_type: Tensor
+    name: columns
+    type: Tensor
+  - dynamic_type: Tensor
+    name: ones
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_backward_out
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_input
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_weight
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_bias
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: thnn_conv_dilated3d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    name: kernel_size
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: stride
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: padding
+    size: 3
+    type: IntList
+  - dynamic_type: IntList
+    name: dilation
+    size: 3
+    type: IntList
+  - dynamic_type: Tensor
+    name: columns
+    type: const Tensor &
+  - dynamic_type: Tensor
+    name: ones
+    type: const Tensor &
+  - default: '{{true, true, true}}'
+    default_init: '{{true, true, true}}'
+    dynamic_type: std::array<bool,3>
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: NN
+  buffers: []
+  returns:
+  - dynamic_type: Tensor
+    name: grad_input
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_weight
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_bias
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cast_uint8_t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_int8_t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_double
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_float
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_int
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_int64_t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_int16_t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cast_Half
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: non_blocking
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _cudnn_rnn_flatten_weight
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: weight_arr
+    type: TensorList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: weight_stride0
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: input_size
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: hidden_size
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_layers
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: batch_first
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: bidirectional
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cudnn_rnn
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: weight
+    type: TensorList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: weight_stride0
+    type: int64_t
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight_buf
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: hx
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: cx
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: hidden_size
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_layers
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: batch_first
+    type: bool
+  - dynamic_type: double
+    is_nullable: false
+    name: dropout
+    type: double
+  - dynamic_type: bool
+    is_nullable: false
+    name: train
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: bidirectional
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: batch_sizes
+    type: IntList
+  - dynamic_type: BoolTensor
+    is_nullable: true
+    name: dropout_state
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result3
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result4
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cudnn_rnn_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: weight
+    type: TensorList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: weight_stride0
+    type: int64_t
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight_buf
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: hx
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: cx
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_hy
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: grad_cy
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: hidden_size
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_layers
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: batch_first
+    type: bool
+  - dynamic_type: double
+    is_nullable: false
+    name: dropout
+    type: double
+  - dynamic_type: bool
+    is_nullable: false
+    name: train
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: bidirectional
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: batch_sizes
+    type: IntList
+  - dynamic_type: BoolTensor
+    is_nullable: true
+    name: dropout_state
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: reserve
+    type: const Tensor &
+  - dynamic_type: std::array<bool,4>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,4>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  - dynamic_type: TensorList
+    name: result3
+    type: std::vector<Tensor>
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _cudnn_init_dropout_state
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: self_ty
+    type: const Type &
+  - dynamic_type: double
+    is_nullable: false
+    name: dropout
+    type: double
+  - dynamic_type: bool
+    is_nullable: false
+    name: train
+    type: bool
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dropout_seed
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: abs
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: abs_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: abs_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: acos
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: acos_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: acos_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_avg_pool1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_size
+    size: 1
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: adaptive_max_pool1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_size
+    size: 1
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: allclose
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  - default: 1.0e-05
+    dynamic_type: double
+    is_nullable: false
+    name: rtol
+    type: double
+  - default: 1.0e-08
+    dynamic_type: double
+    is_nullable: false
+    name: atol
+    type: double
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: equal_nan
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addmv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addmv_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addmv_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addr
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addr_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: addr_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: arange
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: arange_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: arange
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: arange_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: argmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: argmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _argmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: argmin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: argmin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _argmin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: asin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: asin_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: asin_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: atan_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: atan_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: batch_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    is_nullable: false
+    name: training
+    type: bool
+  - dynamic_type: double
+    is_nullable: false
+    name: momentum
+    type: double
+  - dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enabled
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: p
+    type: const Tensor &
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: double
+    is_nullable: false
+    name: p
+    type: double
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: p
+    type: const Tensor &
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: double
+    is_nullable: false
+    name: p
+    type: double
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bernoulli_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: bilinear
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cat
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cat_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ceil
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ceil_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: ceil_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: chunk
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: chunks
+    type: int64_t
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: TensorList
+    name: result
+    type: std::vector<Tensor>
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_is_acceptable
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: convolution
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: transposed
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _convolution
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: transposed
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enabled
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _convolution_nogroup
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: transposed
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _convolution_double_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: ggI
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: ggW
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: ggb
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: gO
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: transposed
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enabled
+    type: bool
+  - dynamic_type: std::array<bool,3>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 1
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 1
+    type: IntList
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 1
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 2
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 2
+    type: IntList
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 2
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 3
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 3
+    type: IntList
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 3
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_tbc
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pad
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_tbc_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pad
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_transpose1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 1
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 1
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    size: 1
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 1
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_transpose2d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 2
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 2
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    size: 2
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 2
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: conv_transpose3d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: false
+    name: bias
+    type: const Tensor &
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 3
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 3
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    size: 3
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 3
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cos
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cos_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cos_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cosh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cosh_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cosh_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cosine_embedding_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: target
+    type: const Tensor &
+  - default: 0.0
+    dynamic_type: double
+    is_nullable: false
+    name: margin
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: size_average
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_affine_grid_generator
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: theta
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: N
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: C
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: H
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: W
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: grid
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_affine_grid_generator_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: N
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: C
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: H
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: W
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: grad_theta
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_batch_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: bool
+    is_nullable: false
+    name: training
+    type: bool
+  - dynamic_type: double
+    is_nullable: false
+    name: exponential_average_factor
+    type: double
+  - dynamic_type: double
+    is_nullable: false
+    name: epsilon
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_batch_norm_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: running_var
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_mean
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: save_var
+    type: const Tensor &
+  - dynamic_type: double
+    is_nullable: false
+    name: epsilon
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_backward_input
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: self_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  - dynamic_type: std::array<bool,3>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_backward_bias
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_backward_weight
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: weight_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  - dynamic_type: std::array<bool,3>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose_backward_bias
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose_backward_input
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_convolution_transpose_backward_weight
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: weight_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: groups
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: benchmark
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: deterministic
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_grid_sampler
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grid
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: output
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cudnn_grid_sampler_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grid
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: grad_self
+    type: Tensor
+  - dynamic_type: Tensor
+    name: grad_grid
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: cumsum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumsum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumsum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumsum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumprod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumprod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumprod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: cumprod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: det
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: diagflat
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: offset
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: diagonal
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: offset
+    type: int64_t
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim1
+    type: int64_t
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim2
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: dot
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: tensor
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: dot_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: tensor
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: einsum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: std::string
+    is_nullable: false
+    name: equation
+    type: std::string
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - default: -1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: padding_idx
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: sparse
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: padding_idx
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: sparse
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_dense_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: padding_idx
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: embedding_renorm_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: double
+    is_nullable: false
+    name: max_norm
+    type: double
+  - dynamic_type: double
+    is_nullable: false
+    name: norm_type
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: embedding_sparse_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: padding_idx
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_bag
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offsets
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: sparse
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result3
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: embedding_bag_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offsets
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offset2bag
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: bag_size
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: maximum_indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: sparse
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_bag_sparse_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offsets
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offset2bag
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: bag_size
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: embedding_bag_dense_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: indices
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offsets
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: offset2bag
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: bag_size
+    type: const Tensor &
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: maximum_indices
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_weights
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: scale_grad_by_freq
+    type: bool
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: mode
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: empty
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: empty_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: empty_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: empty_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: erf
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: erf_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: erf_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: exp
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: exp_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: exp_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: expm1
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: expm1_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: expm1_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: expand
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    kwarg_only: true
+    name: implicit
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: expand_as
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: eye
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: n
+    type: int64_t
+  - default: -1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: m
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: eye_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: n
+    type: int64_t
+  - default: -1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: m
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: value
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: fill_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: value
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: floor
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: floor_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: floor_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: full
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: fill_value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: full_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: fill_value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: full_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: fill_value
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: full_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: fill_value
+    type: Scalar
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: hinge_embedding_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: target
+    type: const Tensor &
+  - default: 1.0
+    dynamic_type: double
+    is_nullable: false
+    name: margin
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: size_average
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ger
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ger_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: gesv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: gesv_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: solution
+    output: true
+    type: Tensor &
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: lu
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor &
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _gesv_helper
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: A
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: group_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: num_groups
+    type: int64_t
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - default: 1.0e-05
+    dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enabled
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: fft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ifft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rfft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: onesided
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: irfft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: onesided
+    type: bool
+  - default: '{}'
+    dynamic_type: IntList
+    is_nullable: false
+    name: signal_sizes
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _fft_with_size
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: signal_ndim
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: complex_input
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: complex_output
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: inverse
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: checked_signal_sizes
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  - dynamic_type: bool
+    is_nullable: false
+    name: onesided
+    type: bool
+  - dynamic_type: IntList
+    is_nullable: false
+    name: output_sizes
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: index
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: indices
+    type: TensorList
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: index_copy_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: IndexTensor
+    is_nullable: false
+    name: index
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: source
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: index_put_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: indices
+    type: TensorList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: values
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: isclose
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  - default: 1.0e-05
+    dynamic_type: double
+    is_nullable: false
+    name: rtol
+    type: double
+  - default: 1.0e-08
+    dynamic_type: double
+    is_nullable: false
+    name: atol
+    type: double
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: equal_nan
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_cuda
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_distributed
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_floating_point
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_nonzero
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_same_size
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_signed
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: is_sparse
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: bool
+    name: result
+    type: bool
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: layer_norm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: normalized_shape
+    type: IntList
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: weight
+    type: const Tensor &
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - default: 1.0e-05
+    dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: cudnn_enable
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: linspace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 100
+    dynamic_type: int64_t
+    is_nullable: false
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: linspace_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 100
+    dynamic_type: int64_t
+    is_nullable: false
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log10
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log10_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log10_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log1p
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log1p_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log1p_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log2
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log2_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log2_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: logdet
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: logspace
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 100
+    dynamic_type: int64_t
+    is_nullable: false
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: logspace_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 100
+    dynamic_type: int64_t
+    is_nullable: false
+    name: steps
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: log_softmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: log_softmax_backward_data
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: output
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: logsumexp
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: logsumexp_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: margin_ranking_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: target
+    type: const Tensor &
+  - default: 0.0
+    dynamic_type: double
+    is_nullable: false
+    name: margin
+    type: double
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: size_average
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: matmul
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: matmul_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_values
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: max_pool1d
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: kernel_size
+    size: 1
+    type: IntList
+  - default: '{}'
+    dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    size: 1
+    type: IntList
+  - default: 0
+    dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    size: 1
+    type: IntList
+  - default: 1
+    dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: ceil_mode
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: min_values
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mkldnn_convolution
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: true
+    name: bias
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mkldnn_convolution_backward_input
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: self_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: bias_defined
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mkldnn_convolution_backward_weights
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: IntList
+    is_nullable: false
+    name: weight_size
+    type: IntList
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: bias_defined
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mkldnn_convolution_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: weight
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: padding
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: stride
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dilation
+    type: IntList
+  - dynamic_type: std::array<bool,3>
+    is_nullable: false
+    name: output_mask
+    type: std::array<bool,3>
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result2
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mm_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mv
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: mv_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: vec
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: narrow
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: start
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: length
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ones
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ones_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ones_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: ones_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: pairwise_distance
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: x1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: x2
+    type: const Tensor &
+  - default: 2
+    dynamic_type: double
+    is_nullable: false
+    name: p
+    type: double
+  - default: 1.0e-06
+    dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: permute
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dims
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: pin_memory
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rand
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rand_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rand_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rand_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: low
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: low
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: low
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randint_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: low
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: high
+    type: int64_t
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randn
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randn_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randn_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randn_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randperm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: n
+    type: int64_t
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: randperm_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: n
+    type: int64_t
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    kwarg_only: true
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: range
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: range_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: start
+    type: Scalar
+  - dynamic_type: Scalar
+    is_nullable: false
+    name: end
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    name: step
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: repeat
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: repeats
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: reshape
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: shape
+    type: IntList
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: RoiPooling2d_forward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: rois
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pooledHeight
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pooledWidth
+    type: int64_t
+  - dynamic_type: double
+    is_nullable: false
+    name: spatialScale
+    type: double
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: RoiPooling2d_backward
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: input
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: rois
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pooledHeight
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: pooledWidth
+    type: int64_t
+  - dynamic_type: double
+    is_nullable: false
+    name: spatialScale
+    type: double
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: gradOutput
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: argmaxes
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: round
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: round_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: round_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rrelu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: 0.125
+    dynamic_type: Scalar
+    is_nullable: false
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    dynamic_type: Scalar
+    is_nullable: false
+    name: upper
+    type: Scalar
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: training
+    type: bool
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rrelu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - default: 0.125
+    dynamic_type: Scalar
+    is_nullable: false
+    name: lower
+    type: Scalar
+  - default: 0.3333333333333333
+    dynamic_type: Scalar
+    is_nullable: false
+    name: upper
+    type: Scalar
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: training
+    type: bool
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: relu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: relu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rsqrt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: rsqrt_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: rsqrt_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: select
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: index
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: selu
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: selu_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sin
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sin_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sin_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sinh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sinh_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sinh_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: size
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: slice
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: start
+    type: int64_t
+  - default: 9223372036854775807
+    dynamic_type: int64_t
+    is_nullable: false
+    name: end
+    type: int64_t
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: step
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: slogdet
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: smm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: softmax
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: softmax_backward_data
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: grad_output
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: output
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: split
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: split_size
+    type: int64_t
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: TensorList
+    name: result
+    type: std::vector<Tensor>
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: split_with_sizes
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: split_sizes
+    type: IntList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: TensorList
+    name: result
+    type: std::vector<Tensor>
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: squeeze
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: squeeze
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: squeeze_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: squeeze_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sspaddmm
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sspaddmm_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: mat2
+    type: const Tensor &
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: beta
+    type: Scalar
+  - default: 1
+    dynamic_type: Scalar
+    is_nullable: false
+    kwarg_only: true
+    name: alpha
+    type: Scalar
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: stack
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: stack_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: TensorList
+    is_nullable: false
+    name: tensors
+    type: TensorList
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: stft
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: frame_length
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: hop
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: fft_size
+    python_default_init: frame_length
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: normalized
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: onesided
+    type: bool
+  - default: '{}'
+    dynamic_type: Tensor
+    is_nullable: true
+    name: window
+    type: const Tensor &
+  - default: 0
+    dynamic_type: int64_t
+    is_nullable: false
+    name: pad_end
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: stride
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: int64_t
+    name: result
+    type: int64_t
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sum
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sum_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: dim
+    size: 1
+    type: IntList
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _sum_cuda_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sqrt
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: sqrt_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: sqrt_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _prod
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: prod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - dynamic_type: ScalarType
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    type: ScalarType
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _prod_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: keepdim
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: t
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: t_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: tan
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: tan_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tan_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tanh
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: tanh_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: tanh_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: transpose
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim0
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim1
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: transpose_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim0
+    type: int64_t
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim1
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _trilinear
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: i1
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: i2
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: i3
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: expand1
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: expand2
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: expand3
+    type: IntList
+  - dynamic_type: IntList
+    is_nullable: false
+    name: sumdim
+    type: IntList
+  - default: 1
+    dynamic_type: int64_t
+    is_nullable: false
+    name: unroll_dim
+    type: int64_t
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: triplet_margin_loss
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: anchor
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: positive
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: negative
+    type: const Tensor &
+  - default: 1.0
+    dynamic_type: double
+    is_nullable: false
+    name: margin
+    type: double
+  - default: 2
+    dynamic_type: double
+    is_nullable: false
+    name: p
+    type: double
+  - default: 1.0e-06
+    dynamic_type: double
+    is_nullable: false
+    name: eps
+    type: double
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: swap
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: size_average
+    type: bool
+  - default: true
+    dynamic_type: bool
+    is_nullable: false
+    name: reduce
+    type: bool
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: trunc
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: trunc_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: trunc_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: type_as
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _unique
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: sorted
+    type: bool
+  - default: false
+    dynamic_type: bool
+    is_nullable: false
+    name: return_inverse
+    type: bool
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result0
+    type: Tensor
+  - dynamic_type: Tensor
+    name: result1
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _unsafe_view
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: unsqueeze
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: unsqueeze_
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: Tensor &
+  - dynamic_type: int64_t
+    is_nullable: false
+    name: dim
+    type: int64_t
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: self
+    type: Tensor &
+  inplace: true
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: view_as
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: where
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    is_nullable: false
+    name: condition
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _s_where
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: BoolTensor
+    is_nullable: false
+    name: condition
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: other
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: zeros
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Type
+    is_nullable: false
+    is_type_dispatched: true
+    name: dtype
+    type: const Type &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: zeros_out
+  method_prefix_derived: ''
+  arguments:
+  - allocate: true
+    dynamic_type: Tensor
+    is_nullable: false
+    name: result
+    output: true
+    type: Tensor &
+  - dynamic_type: IntList
+    is_nullable: false
+    name: size
+    type: IntList
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor &
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: zeros_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: zeros_like
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Type
+    is_nullable: false
+    kwarg_only: true
+    name: dtype
+    python_default_init: self.type()
+    type: const Type &
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: false
+  auto_gpu: true
+  with_gil: false
+- name: _standard_gamma_grad
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: output
+    type: const Tensor &
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: _standard_gamma
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - Tensor
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
+- name: poisson
+  method_prefix_derived: ''
+  arguments:
+  - dynamic_type: Tensor
+    is_nullable: false
+    name: self
+    type: const Tensor &
+  - default: nullptr
+    dynamic_type: Generator *
+    is_nullable: false
+    name: generator
+    type: Generator *
+  method_of:
+  - Type
+  - namespace
+  mode: native
+  returns:
+  - dynamic_type: Tensor
+    name: result
+    type: Tensor
+  inplace: false
+  abstract: true
+  auto_gpu: true
+  with_gil: false
diff --git a/aten/src/ATen/gen.py b/aten/src/ATen/gen.py
index b46552068947a..4a43503d039b2 100644
--- a/aten/src/ATen/gen.py
+++ b/aten/src/ATen/gen.py
@@ -4,10 +4,6 @@
 import yaml
 from collections import OrderedDict
 
-import sys
-from os import path
-sys.path.append(path.dirname(path.abspath(__file__)))
-
 import cwrap_parser
 import nn_parse
 import native_parse
@@ -27,7 +23,6 @@
 
 parser = argparse.ArgumentParser(description='Generate ATen source files')
 parser.add_argument('files', help='cwrap files', nargs='+')
-
 parser.add_argument(
     '-s',
     '--source-path',
@@ -38,11 +33,12 @@
     '--output-dependencies',
     help='output a list of dependencies into the given file and exit')
 parser.add_argument(
-    '-d', '--install_dir', help='output directory', default='ATen')
+    '-d', '--output-dir', help='output directory', default='ATen')
 options = parser.parse_args()
 
-if options.install_dir is not None and not os.path.exists(options.install_dir):
-    os.makedirs(options.install_dir)
+
+if options.output_dir is not None and not os.path.exists(options.output_dir):
+    os.makedirs(options.output_dir)
 
 
 class FileManager(object):
@@ -52,7 +48,7 @@ def __init__(self):
         self.undeclared_files = []
 
     def will_write(self, filename):
-        filename = '{}/{}'.format(options.install_dir, filename)
+        filename = '{}/{}'.format(options.output_dir, filename)
         if self.outputs_written:
             raise Exception("'will_write' can only be called before " +
                             "the call to write_outputs, refactor so outputs are registered " +
@@ -78,7 +74,7 @@ def write_outputs(self, filename):
         self.outputs_written = True
 
     def write(self, filename, s, env=None):
-        filename = '{}/{}'.format(options.install_dir, filename)
+        filename = '{}/{}'.format(options.output_dir, filename)
         if isinstance(s, CodeTemplate):
             assert env is not None
             env['generated_comment'] = "@" + "generated by aten/src/ATen/gen.py"
diff --git a/tools/autograd/gen_python_functions.py b/tools/autograd/gen_python_functions.py
index ba58cde552e54..c5fcca7b3b0c0 100644
--- a/tools/autograd/gen_python_functions.py
+++ b/tools/autograd/gen_python_functions.py
@@ -9,11 +9,7 @@
 from .gen_variable_type import should_trace
 from .utils import write
 
-try:
-    from src.ATen.code_template import CodeTemplate
-except ImportError:
-    from tools.shared.module_loader import import_module
-    CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
+CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
 
 # These functions require manual Python bindings or are not exposed to Python
 SKIP_PYTHON_BINDINGS = [
diff --git a/tools/autograd/utils.py b/tools/autograd/utils.py
index 6758e71ffc97e..608b7ea2d8c38 100644
--- a/tools/autograd/utils.py
+++ b/tools/autograd/utils.py
@@ -1,5 +1,6 @@
 import re
 import os
+from tools.shared.module_loader import import_module
 from .nested_dict import nested_dict
 
 
@@ -8,11 +9,8 @@
     'split_name_params', 'write',
 ]
 
-try:
-    from src.ATen.code_template import CodeTemplate
-except ImportError:
-    from tools.shared.module_loader import import_module
-    CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
+
+CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
 
 try:
     # use faster C loader if available
diff --git a/tools/nnwrap/generate_wrappers.py b/tools/nnwrap/generate_wrappers.py
index 1edbca928c17d..6c78fe3b0705d 100644
--- a/tools/nnwrap/generate_wrappers.py
+++ b/tools/nnwrap/generate_wrappers.py
@@ -109,12 +109,7 @@ def wrap_nn(thnn_h_path, install_dir, template_path):
     for fn in nn_functions:
         for t in ['Float', 'Double']:
             wrapper += wrap_function(fn.name, t, fn.arguments)
-    install_dir = install_dir or 'torch/csrc/nn'
-    try:
-        os.makedirs(install_dir)
-    except OSError:
-        pass
-    with open(os.path.join(install_dir, 'THNN.cwrap'), 'w') as f:
+    with open('torch/csrc/nn/THNN.cwrap', 'w') as f:
         f.write(wrapper)
     cwrap(os.path.join(install_dir, 'THNN.cwrap'),
           plugins=[NNExtension('torch._C._THNN'), NullableArguments()],
@@ -128,8 +123,7 @@ def wrap_cunn(thcunn_h_path, install_dir, template_path):
     for fn in cunn_functions:
         for t in ['CudaHalf', 'Cuda', 'CudaDouble']:
             wrapper += wrap_function(fn.name, t, fn.arguments)
-    install_dir = install_dir or 'torch/csrc/nn'
-    with open(os.path.join(install_dir, 'THCUNN.cwrap'), 'w') as f:
+    with open('torch/csrc/nn/THCUNN.cwrap', 'w') as f:
         f.write(wrapper)
     cwrap(os.path.join(install_dir, 'THCUNN.cwrap'),
           plugins=[NNExtension('torch._C._THCUNN'), NullableArguments(), AutoGPU(has_self=False)],

From e0ac4ff9facc342ea5c2c2e5ba417684b2d78860 Mon Sep 17 00:00:00 2001
From: Minxing Liu <mxliu@fb.com>
Date: Tue, 12 Jun 2018 10:01:19 -0700
Subject: [PATCH 097/118] add dependencies for online trainer

Add some dependencies so that the online model can use DataPipeline and PredictionTransform operators

Relevent post: https://fb.intern.facebook.com/groups/1324375037655677/permalink/1740993462660497/
---
 caffe2/python/mkl/rewrite_graph.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/caffe2/python/mkl/rewrite_graph.py b/caffe2/python/mkl/rewrite_graph.py
index 1c8b9aa9416f0..157b0251db9ac 100644
--- a/caffe2/python/mkl/rewrite_graph.py
+++ b/caffe2/python/mkl/rewrite_graph.py
@@ -69,6 +69,7 @@ def mkl_tmp(name):
         net.ParseFromString(
             C.transform_optimizeForIDEEP(net.SerializeToString()))
 
+
 def rewrite_model_helper_simple(model, ideep=True):
     model = copy.deepcopy(model)
     # All parameter initialization should run on MKL

From 65dfa2f32848aafb0bd7dd53bfa0376d6ba92011 Mon Sep 17 00:00:00 2001
From: James Reed <jamesreed@fb.com>
Date: Tue, 12 Jun 2018 10:01:23 -0700
Subject: [PATCH 098/118] Resolve conflicts for tools/jit/gen_jit_dispatch.py

---
 tools/jit/gen_jit_dispatch.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/jit/gen_jit_dispatch.py b/tools/jit/gen_jit_dispatch.py
index 05c959110b906..f494fa0a4f549 100644
--- a/tools/jit/gen_jit_dispatch.py
+++ b/tools/jit/gen_jit_dispatch.py
@@ -94,6 +94,8 @@ def is_jit_op(decl):
     # Only support a single TensorList arg
     if sum(arg['simple_type'] == 'TensorList' for arg in arguments) > 1:
         return False
+    if any(arg['simple_type'] == 'std::string' for arg in arguments):
+        return False
 
     return ((not decl['api_name'].endswith('_') or is_magic_method(decl['api_name'])) and
             not decl['name'].endswith('_out') and

From a3b90b0935b94caac33e74b09b5702cd6b9ca2ed Mon Sep 17 00:00:00 2001
From: Zhishuai Zhang <zhishuaizhang@fb.com>
Date: Tue, 12 Jun 2018 10:04:44 -0700
Subject: [PATCH 099/118] Support advanced pooling options in sum processor

* support advanced pooling options in sum processor
* remove redundant code
* support attention in sum processor
---
 caffe2/operators/elementwise_add_op.cc |  6 +++
 caffe2/operators/elementwise_div_op.cc |  2 +
 caffe2/operators/elementwise_mul_op.cc |  2 +
 caffe2/operators/elementwise_sub_op.cc |  2 +
 caffe2/operators/log_op.cc             |  4 ++
 caffe2/operators/tanh_op.cc            | 55 ++++++++++++++++++++++++++
 6 files changed, 71 insertions(+)

diff --git a/caffe2/operators/elementwise_add_op.cc b/caffe2/operators/elementwise_add_op.cc
index 849006a3bb32b..0413da5e03418 100644
--- a/caffe2/operators/elementwise_add_op.cc
+++ b/caffe2/operators/elementwise_add_op.cc
@@ -6,4 +6,10 @@ REGISTER_CPU_OPERATOR(
     Add,
     BinaryElementwiseOp<NumericTypes, CPUContext, AddFunctor<CPUContext>>);
 
+} // namespace
+
+REGISTER_GRADIENT(Add, GetAddGradient);
+
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_div_op.cc b/caffe2/operators/elementwise_div_op.cc
index 73f0b23f7d1da..fd9cf4f4ba5f2 100644
--- a/caffe2/operators/elementwise_div_op.cc
+++ b/caffe2/operators/elementwise_div_op.cc
@@ -7,4 +7,6 @@ REGISTER_CPU_OPERATOR(
     Div,
     BinaryElementwiseOp<NumericTypes, CPUContext, DivFunctor<CPUContext>>);
 
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_mul_op.cc b/caffe2/operators/elementwise_mul_op.cc
index a55112a4b7c46..52f740b11f69c 100644
--- a/caffe2/operators/elementwise_mul_op.cc
+++ b/caffe2/operators/elementwise_mul_op.cc
@@ -6,4 +6,6 @@ REGISTER_CPU_OPERATOR(
     Mul,
     BinaryElementwiseOp<NumericTypes, CPUContext, MulFunctor<CPUContext>>);
 
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_sub_op.cc b/caffe2/operators/elementwise_sub_op.cc
index f906883a183bf..299c46640c763 100644
--- a/caffe2/operators/elementwise_sub_op.cc
+++ b/caffe2/operators/elementwise_sub_op.cc
@@ -6,4 +6,6 @@ REGISTER_CPU_OPERATOR(
     Sub,
     BinaryElementwiseOp<NumericTypes, CPUContext, SubFunctor<CPUContext>>);
 
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/log_op.cc b/caffe2/operators/log_op.cc
index 68e95e6f25ffb..28be919e9246e 100644
--- a/caffe2/operators/log_op.cc
+++ b/caffe2/operators/log_op.cc
@@ -9,6 +9,8 @@ REGISTER_CPU_OPERATOR(
     Log,
     UnaryElementwiseOp<TensorTypes<float>, CPUContext, LogFunctor<CPUContext>>);
 
+#if !CAFFE2_MOBILE
+
 OPERATOR_SCHEMA(Log)
     .NumInputs(1)
     .NumOutputs(1)
@@ -44,4 +46,6 @@ class GetLogGradient : public GradientMakerBase {
 
 REGISTER_GRADIENT(Log, GetLogGradient);
 
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2
diff --git a/caffe2/operators/tanh_op.cc b/caffe2/operators/tanh_op.cc
index 69682256cdd49..d6a1b08a60c8b 100644
--- a/caffe2/operators/tanh_op.cc
+++ b/caffe2/operators/tanh_op.cc
@@ -18,12 +18,48 @@ bool TanhFunctor<CPUContext>::operator()<float>(
   return true;
 }
 
+<<<<<<< HEAD
+=======
+#if !CAFFE2_MOBILE
+
+template <>
+template <typename T>
+bool TanhGradientFunctor<CPUContext>::Forward(
+    const std::vector<int>& dY_dims,
+    const std::vector<int>& /* Y_dims */,
+    const T* dY,
+    const T* Y,
+    T* dX,
+    CPUContext* /* context */) const {
+  const int size = std::accumulate(
+      dY_dims.cbegin(), dY_dims.cend(), 1, std::multiplies<int>());
+  ConstEigenVectorArrayMap<T> dY_arr(dY, size);
+  ConstEigenVectorArrayMap<T> Y_arr(Y, size);
+  EigenVectorMap<T>(dX, size) = dY_arr * (1 - Y_arr * Y_arr);
+  return true;
+}
+
+#endif // !CAFFE2_MOBILE
+
+>>>>>>> 8ac1a59... Support advanced pooling options in sum processor
 REGISTER_CPU_OPERATOR(
     Tanh,
     UnaryElementwiseOp<
         TensorTypes<float>,
         CPUContext,
         TanhFunctor<CPUContext>>);
+<<<<<<< HEAD
+=======
+
+#if !CAFFE2_MOBILE
+
+REGISTER_CPU_OPERATOR(
+    TanhGradient,
+    BinaryElementwiseOp<
+        TensorTypes<float>,
+        CPUContext,
+        TanhGradientFunctor<CPUContext>>);
+>>>>>>> 8ac1a59... Support advanced pooling options in sum processor
 
 OPERATOR_SCHEMA(Tanh)
     .NumInputs(1)
@@ -93,4 +129,23 @@ print("X:\n", workspace.FetchBlob("X"))
 
 OPERATOR_SCHEMA(TanhGradient).NumInputs(2).NumOutputs(1).AllowInplace({{0, 0}});
 
+namespace {
+
+class GetTanhGradient : public GradientMakerBase {
+  using GradientMakerBase::GradientMakerBase;
+  std::vector<OperatorDef> GetGradientDefs() override {
+    return SingleGradientDef(
+        "TanhGradient",
+        "",
+        std::vector<std::string>{GO(0), O(0)},
+        std::vector<std::string>{GI(0)});
+  }
+};
+
+} // namespace
+
+REGISTER_GRADIENT(Tanh, GetTanhGradient);
+
+#endif // !CAFFE2_MOBILE
+
 } // namespace caffe2

From 83ba250ff82410dc2b5b205c1697e399889a88a7 Mon Sep 17 00:00:00 2001
From: Bram Wasti <bwasti@fb.com>
Date: Tue, 12 Jun 2018 10:06:06 -0700
Subject: [PATCH 100/118] resolve conflicts for
 caffe2/core/logging_is_google_glog.h and test/test_torch.py

---
 aten/src/ATen/Declarations.yaml               | 14 +++++-----
 aten/src/ATen/gen.py                          | 16 ++++++-----
 .../include/nomnigraph/Support/Common.h       | 18 +++++++++++++
 caffe2/core/nomnigraph/ops.def                |  6 +++++
 caffe2/opt/converter.cc                       | 27 +++++++++++++++++++
 5 files changed, 68 insertions(+), 13 deletions(-)

diff --git a/aten/src/ATen/Declarations.yaml b/aten/src/ATen/Declarations.yaml
index e865a8ab30c66..71715505f9d59 100644
--- a/aten/src/ATen/Declarations.yaml
+++ b/aten/src/ATen/Declarations.yaml
@@ -22710,7 +22710,7 @@
   abstract: true
   auto_gpu: true
   with_gil: false
-- name: _cast_uint8_t
+- name: _cast_Byte
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22735,7 +22735,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_int8_t
+- name: _cast_Char
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22760,7 +22760,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_double
+- name: _cast_Double
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22785,7 +22785,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_float
+- name: _cast_Float
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22810,7 +22810,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_int
+- name: _cast_Int
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22835,7 +22835,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_int64_t
+- name: _cast_Long
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
@@ -22860,7 +22860,7 @@
   abstract: false
   auto_gpu: true
   with_gil: false
-- name: _cast_int16_t
+- name: _cast_Short
   method_prefix_derived: ''
   arguments:
   - dynamic_type: Tensor
diff --git a/aten/src/ATen/gen.py b/aten/src/ATen/gen.py
index 4a43503d039b2..b46552068947a 100644
--- a/aten/src/ATen/gen.py
+++ b/aten/src/ATen/gen.py
@@ -4,6 +4,10 @@
 import yaml
 from collections import OrderedDict
 
+import sys
+from os import path
+sys.path.append(path.dirname(path.abspath(__file__)))
+
 import cwrap_parser
 import nn_parse
 import native_parse
@@ -23,6 +27,7 @@
 
 parser = argparse.ArgumentParser(description='Generate ATen source files')
 parser.add_argument('files', help='cwrap files', nargs='+')
+
 parser.add_argument(
     '-s',
     '--source-path',
@@ -33,12 +38,11 @@
     '--output-dependencies',
     help='output a list of dependencies into the given file and exit')
 parser.add_argument(
-    '-d', '--output-dir', help='output directory', default='ATen')
+    '-d', '--install_dir', help='output directory', default='ATen')
 options = parser.parse_args()
 
-
-if options.output_dir is not None and not os.path.exists(options.output_dir):
-    os.makedirs(options.output_dir)
+if options.install_dir is not None and not os.path.exists(options.install_dir):
+    os.makedirs(options.install_dir)
 
 
 class FileManager(object):
@@ -48,7 +52,7 @@ def __init__(self):
         self.undeclared_files = []
 
     def will_write(self, filename):
-        filename = '{}/{}'.format(options.output_dir, filename)
+        filename = '{}/{}'.format(options.install_dir, filename)
         if self.outputs_written:
             raise Exception("'will_write' can only be called before " +
                             "the call to write_outputs, refactor so outputs are registered " +
@@ -74,7 +78,7 @@ def write_outputs(self, filename):
         self.outputs_written = True
 
     def write(self, filename, s, env=None):
-        filename = '{}/{}'.format(options.output_dir, filename)
+        filename = '{}/{}'.format(options.install_dir, filename)
         if isinstance(s, CodeTemplate):
             assert env is not None
             env['generated_comment'] = "@" + "generated by aten/src/ATen/gen.py"
diff --git a/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h b/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
index 9a39ab2405cf5..9731d048a31fa 100644
--- a/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
+++ b/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
@@ -14,6 +14,24 @@
 #include <functional>
 #include <list>
 
+// These #defines are useful when writing passes as the collapse
+//
+// if (!cond) {
+//   continue; // or break; or return;
+// }
+//
+// into a single line without negation
+
+#define NOM_REQUIRE_OR_(_cond, _expr) \
+  if (!(_cond)) {                     \
+    _expr;                            \
+  }
+
+#define NOM_REQUIRE_OR_CONT(_cond) NOM_REQUIRE_OR_(_cond, continue)
+#define NOM_REQUIRE_OR_BREAK(_cond) NOM_REQUIRE_OR_(_cond, break)
+#define NOM_REQUIRE_OR_RET_NULL(_cond) NOM_REQUIRE_OR_(_cond, return nullptr)
+#define NOM_REQUIRE_OR_RET(_cond) NOM_REQUIRE_OR_(_cond, return )
+
 // Implements accessors for a generic type T. If the type is not
 // specified (i.e., void template type) then the partial specification
 // gives an empty type.
diff --git a/caffe2/core/nomnigraph/ops.def b/caffe2/core/nomnigraph/ops.def
index 6240ff2b04391..9182c80fbd76b 100644
--- a/caffe2/core/nomnigraph/ops.def
+++ b/caffe2/core/nomnigraph/ops.def
@@ -55,6 +55,8 @@ BatchNormalization
 FC
 GivenTensorFill
 Concat
+- Axis : int : -1
+- AddAxis : bool : false
 Softmax
 ChannelShuffle
 Add
@@ -81,3 +83,7 @@ Int8ConvRelu : ConvRelu
 Int8SumRelu : SumRelu
 Int8AveragePoolRelu : AveragePoolRelu
 Int8MaxPoolRelu : MaxPoolRelu
+
+BatchMatMul
+BatchGather
+ConcatBatchMatMulBatchGatherOp
diff --git a/caffe2/opt/converter.cc b/caffe2/opt/converter.cc
index 08f4ce9ae2ed2..832df0a382865 100644
--- a/caffe2/opt/converter.cc
+++ b/caffe2/opt/converter.cc
@@ -128,6 +128,33 @@ convertToOperatorDef(caffe2::OperatorDef op) {
     nnOp = util::make_unique<repr::BatchNormalization>();
   }
 
+  if (op.type() == "Concat") {
+    nnOp = util::make_unique<repr::Concat>();
+    auto c = dyn_cast<repr::Concat>(nnOp.get());
+    if (argMap.count("axis")) {
+      assert(argMap["axis"].has_i() && "Invalid axis argument");
+      int axis = static_cast<int>(argMap["axis"].i());
+      c->setAxis(axis);
+    }
+    if (argMap.count("add_axis")) {
+      assert(argMap["add_axis"].has_i() && "Invalid add_axis argument");
+      int add_axis = static_cast<int>(argMap["add_axis"].i());
+      c->setAddAxis(!!add_axis);
+    }
+  }
+
+  if (op.type() == "Flatten") {
+    nnOp = util::make_unique<repr::Flatten>();
+  }
+
+  if (op.type() == "BatchGather") {
+    nnOp = util::make_unique<repr::BatchGather>();
+  }
+
+  if (op.type() == "BatchMatMul") {
+    nnOp = util::make_unique<repr::BatchMatMul>();
+  }
+
   if (!nnOp) {
     nnOp = util::make_unique<repr::GenericOperator>(op.type());
   }

From 9d3e363e5f503788b6393fef5d4573b2d05de125 Mon Sep 17 00:00:00 2001
From: Andrey Malevich <amalevich@fb.com>
Date: Tue, 12 Jun 2018 10:10:08 -0700
Subject: [PATCH 101/118] Revert D7962948: [caffe2][nomnigraph] Concat elim for
 sparseNN

This reverts commit f7f434dc5c34ca6058b9765d2ef615453d2276a9

@bypass-lint

An infra SEV is better than not reverting this diff.
If you copy this password, see you in SEV Review!
@cause_a_sev_many_files
---
 .../include/nomnigraph/Support/Common.h       | 18 ------
 caffe2/core/nomnigraph/ops.def                |  6 --
 caffe2/operators/elementwise_add_op.cc        |  6 --
 caffe2/operators/elementwise_div_op.cc        |  2 -
 caffe2/operators/elementwise_mul_op.cc        |  2 -
 caffe2/operators/elementwise_sub_op.cc        |  2 -
 caffe2/operators/log_op.cc                    |  4 --
 caffe2/operators/tanh_op.cc                   | 55 -------------------
 caffe2/opt/converter.cc                       | 27 ---------
 9 files changed, 122 deletions(-)

diff --git a/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h b/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
index 9731d048a31fa..9a39ab2405cf5 100644
--- a/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
+++ b/caffe2/core/nomnigraph/include/nomnigraph/Support/Common.h
@@ -14,24 +14,6 @@
 #include <functional>
 #include <list>
 
-// These #defines are useful when writing passes as the collapse
-//
-// if (!cond) {
-//   continue; // or break; or return;
-// }
-//
-// into a single line without negation
-
-#define NOM_REQUIRE_OR_(_cond, _expr) \
-  if (!(_cond)) {                     \
-    _expr;                            \
-  }
-
-#define NOM_REQUIRE_OR_CONT(_cond) NOM_REQUIRE_OR_(_cond, continue)
-#define NOM_REQUIRE_OR_BREAK(_cond) NOM_REQUIRE_OR_(_cond, break)
-#define NOM_REQUIRE_OR_RET_NULL(_cond) NOM_REQUIRE_OR_(_cond, return nullptr)
-#define NOM_REQUIRE_OR_RET(_cond) NOM_REQUIRE_OR_(_cond, return )
-
 // Implements accessors for a generic type T. If the type is not
 // specified (i.e., void template type) then the partial specification
 // gives an empty type.
diff --git a/caffe2/core/nomnigraph/ops.def b/caffe2/core/nomnigraph/ops.def
index 9182c80fbd76b..6240ff2b04391 100644
--- a/caffe2/core/nomnigraph/ops.def
+++ b/caffe2/core/nomnigraph/ops.def
@@ -55,8 +55,6 @@ BatchNormalization
 FC
 GivenTensorFill
 Concat
-- Axis : int : -1
-- AddAxis : bool : false
 Softmax
 ChannelShuffle
 Add
@@ -83,7 +81,3 @@ Int8ConvRelu : ConvRelu
 Int8SumRelu : SumRelu
 Int8AveragePoolRelu : AveragePoolRelu
 Int8MaxPoolRelu : MaxPoolRelu
-
-BatchMatMul
-BatchGather
-ConcatBatchMatMulBatchGatherOp
diff --git a/caffe2/operators/elementwise_add_op.cc b/caffe2/operators/elementwise_add_op.cc
index 0413da5e03418..849006a3bb32b 100644
--- a/caffe2/operators/elementwise_add_op.cc
+++ b/caffe2/operators/elementwise_add_op.cc
@@ -6,10 +6,4 @@ REGISTER_CPU_OPERATOR(
     Add,
     BinaryElementwiseOp<NumericTypes, CPUContext, AddFunctor<CPUContext>>);
 
-} // namespace
-
-REGISTER_GRADIENT(Add, GetAddGradient);
-
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_div_op.cc b/caffe2/operators/elementwise_div_op.cc
index fd9cf4f4ba5f2..73f0b23f7d1da 100644
--- a/caffe2/operators/elementwise_div_op.cc
+++ b/caffe2/operators/elementwise_div_op.cc
@@ -7,6 +7,4 @@ REGISTER_CPU_OPERATOR(
     Div,
     BinaryElementwiseOp<NumericTypes, CPUContext, DivFunctor<CPUContext>>);
 
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_mul_op.cc b/caffe2/operators/elementwise_mul_op.cc
index 52f740b11f69c..a55112a4b7c46 100644
--- a/caffe2/operators/elementwise_mul_op.cc
+++ b/caffe2/operators/elementwise_mul_op.cc
@@ -6,6 +6,4 @@ REGISTER_CPU_OPERATOR(
     Mul,
     BinaryElementwiseOp<NumericTypes, CPUContext, MulFunctor<CPUContext>>);
 
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/elementwise_sub_op.cc b/caffe2/operators/elementwise_sub_op.cc
index 299c46640c763..f906883a183bf 100644
--- a/caffe2/operators/elementwise_sub_op.cc
+++ b/caffe2/operators/elementwise_sub_op.cc
@@ -6,6 +6,4 @@ REGISTER_CPU_OPERATOR(
     Sub,
     BinaryElementwiseOp<NumericTypes, CPUContext, SubFunctor<CPUContext>>);
 
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/log_op.cc b/caffe2/operators/log_op.cc
index 28be919e9246e..68e95e6f25ffb 100644
--- a/caffe2/operators/log_op.cc
+++ b/caffe2/operators/log_op.cc
@@ -9,8 +9,6 @@ REGISTER_CPU_OPERATOR(
     Log,
     UnaryElementwiseOp<TensorTypes<float>, CPUContext, LogFunctor<CPUContext>>);
 
-#if !CAFFE2_MOBILE
-
 OPERATOR_SCHEMA(Log)
     .NumInputs(1)
     .NumOutputs(1)
@@ -46,6 +44,4 @@ class GetLogGradient : public GradientMakerBase {
 
 REGISTER_GRADIENT(Log, GetLogGradient);
 
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/operators/tanh_op.cc b/caffe2/operators/tanh_op.cc
index d6a1b08a60c8b..69682256cdd49 100644
--- a/caffe2/operators/tanh_op.cc
+++ b/caffe2/operators/tanh_op.cc
@@ -18,48 +18,12 @@ bool TanhFunctor<CPUContext>::operator()<float>(
   return true;
 }
 
-<<<<<<< HEAD
-=======
-#if !CAFFE2_MOBILE
-
-template <>
-template <typename T>
-bool TanhGradientFunctor<CPUContext>::Forward(
-    const std::vector<int>& dY_dims,
-    const std::vector<int>& /* Y_dims */,
-    const T* dY,
-    const T* Y,
-    T* dX,
-    CPUContext* /* context */) const {
-  const int size = std::accumulate(
-      dY_dims.cbegin(), dY_dims.cend(), 1, std::multiplies<int>());
-  ConstEigenVectorArrayMap<T> dY_arr(dY, size);
-  ConstEigenVectorArrayMap<T> Y_arr(Y, size);
-  EigenVectorMap<T>(dX, size) = dY_arr * (1 - Y_arr * Y_arr);
-  return true;
-}
-
-#endif // !CAFFE2_MOBILE
-
->>>>>>> 8ac1a59... Support advanced pooling options in sum processor
 REGISTER_CPU_OPERATOR(
     Tanh,
     UnaryElementwiseOp<
         TensorTypes<float>,
         CPUContext,
         TanhFunctor<CPUContext>>);
-<<<<<<< HEAD
-=======
-
-#if !CAFFE2_MOBILE
-
-REGISTER_CPU_OPERATOR(
-    TanhGradient,
-    BinaryElementwiseOp<
-        TensorTypes<float>,
-        CPUContext,
-        TanhGradientFunctor<CPUContext>>);
->>>>>>> 8ac1a59... Support advanced pooling options in sum processor
 
 OPERATOR_SCHEMA(Tanh)
     .NumInputs(1)
@@ -129,23 +93,4 @@ print("X:\n", workspace.FetchBlob("X"))
 
 OPERATOR_SCHEMA(TanhGradient).NumInputs(2).NumOutputs(1).AllowInplace({{0, 0}});
 
-namespace {
-
-class GetTanhGradient : public GradientMakerBase {
-  using GradientMakerBase::GradientMakerBase;
-  std::vector<OperatorDef> GetGradientDefs() override {
-    return SingleGradientDef(
-        "TanhGradient",
-        "",
-        std::vector<std::string>{GO(0), O(0)},
-        std::vector<std::string>{GI(0)});
-  }
-};
-
-} // namespace
-
-REGISTER_GRADIENT(Tanh, GetTanhGradient);
-
-#endif // !CAFFE2_MOBILE
-
 } // namespace caffe2
diff --git a/caffe2/opt/converter.cc b/caffe2/opt/converter.cc
index 832df0a382865..08f4ce9ae2ed2 100644
--- a/caffe2/opt/converter.cc
+++ b/caffe2/opt/converter.cc
@@ -128,33 +128,6 @@ convertToOperatorDef(caffe2::OperatorDef op) {
     nnOp = util::make_unique<repr::BatchNormalization>();
   }
 
-  if (op.type() == "Concat") {
-    nnOp = util::make_unique<repr::Concat>();
-    auto c = dyn_cast<repr::Concat>(nnOp.get());
-    if (argMap.count("axis")) {
-      assert(argMap["axis"].has_i() && "Invalid axis argument");
-      int axis = static_cast<int>(argMap["axis"].i());
-      c->setAxis(axis);
-    }
-    if (argMap.count("add_axis")) {
-      assert(argMap["add_axis"].has_i() && "Invalid add_axis argument");
-      int add_axis = static_cast<int>(argMap["add_axis"].i());
-      c->setAddAxis(!!add_axis);
-    }
-  }
-
-  if (op.type() == "Flatten") {
-    nnOp = util::make_unique<repr::Flatten>();
-  }
-
-  if (op.type() == "BatchGather") {
-    nnOp = util::make_unique<repr::BatchGather>();
-  }
-
-  if (op.type() == "BatchMatMul") {
-    nnOp = util::make_unique<repr::BatchMatMul>();
-  }
-
   if (!nnOp) {
     nnOp = util::make_unique<repr::GenericOperator>(op.type());
   }

From 1bcf7436242d09b289651d7831625439b09185c0 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 12:04:09 -0700
Subject: [PATCH 102/118] Remove Declarations.yaml

---
 aten/src/ATen/Declarations.yaml | 32527 ------------------------------
 1 file changed, 32527 deletions(-)
 delete mode 100644 aten/src/ATen/Declarations.yaml

diff --git a/aten/src/ATen/Declarations.yaml b/aten/src/ATen/Declarations.yaml
deleted file mode 100644
index 71715505f9d59..0000000000000
--- a/aten/src/ATen/Declarations.yaml
+++ /dev/null
@@ -1,32527 +0,0 @@
-- name: storage_offset
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: resize_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: numel
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: set_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Storage
-    name: storage
-    type: Storage &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: set_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Storage
-    name: sourceStorage
-    type: Storage &
-  - dynamic_type: int64_t
-    name: storage_offset
-    type: int64_t
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: IntList
-    name: stride
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: set_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: set_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: _fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: value
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: is_contiguous
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: is_set_to
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: masked_fill_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  - dynamic_type: real
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: masked_fill_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: value
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: masked_scatter_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: masked_select_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: masked_select
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: BoolTensor
-    name: mask
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nonzero_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nonzero
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: contiguous
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clone
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: view
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: resize_as_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: the_template
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_select_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_select
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _indexCopy_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: take_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: take
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: put_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: accumulate
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_add_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: real
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index_fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: value
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: unfold
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dimension
-    type: int64_t
-  - dynamic_type: int64_t
-    name: size
-    type: int64_t
-  - dynamic_type: int64_t
-    name: step
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: false
-- name: _range_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: accreal
-    name: start
-    type: Scalar
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _range
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: accreal
-    name: start
-    type: Scalar
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _arange_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: accreal
-    name: start
-    type: Scalar
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _arange
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: accreal
-    name: start
-    type: Scalar
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _arange_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _arange
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: accreal
-    name: end
-    type: Scalar
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: scatter_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: src
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: scatter_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: real
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: scatter_add_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: src
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gather_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gather
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    name: index
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: data_ptr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: void*
-    name: result
-    type: void*
-  inplace: false
-  abstract: true
-  auto_gpu: false
-  with_gil: true
-- name: equal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __and___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __and__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __and___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __and__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __iand__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __iand__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __or___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __or__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __or___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __or__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ior__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ior__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __xor___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __xor__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __xor___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __xor__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ixor__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ixor__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __lshift___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __lshift__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __lshift___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __lshift__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ilshift__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __ilshift__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __rshift___out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __rshift__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __rshift___out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __rshift__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __irshift__
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: __irshift__
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lt_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gt_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: le_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ge_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eq_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: BoolTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: BoolTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ne_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: min
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: min_indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: min
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: min_indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: min
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: min_indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: min
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: max
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: max_indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: max
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: max_indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: max
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: max_indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kthvalue_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: k
-    type: int64_t
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kthvalue
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: k
-    type: int64_t
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mode_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mode
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: median_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: median
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: median
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sort_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: descending
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sort
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: descending
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: topk_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: values
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: k
-    type: int64_t
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: largest
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: sorted
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: topk
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: k
-    type: int64_t
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: largest
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: sorted
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: values
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: all_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: all
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: all
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: any_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: any
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: any
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: real
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: get_device
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _abs_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _abs
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sigmoid_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sigmoid_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sigmoid
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log10_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log10
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log1p_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log1p
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log2_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _log2
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lgamma_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lgamma
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lgamma_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: digamma_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: digamma
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: digamma_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: polygamma_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: n
-    type: int64_t
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: polygamma
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: int64_t
-    name: n
-    type: int64_t
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: polygamma_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: n
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _exp_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _exp
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _expm1_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _expm1
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cos_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cos
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _acos_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _acos
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cosh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cosh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sin_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _asin_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _asin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sinh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sinh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tan_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tan
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _atan_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _atan
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_tanh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_tanh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _erf_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _erf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: erfinv_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: erfinv_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: erfinv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sqrt_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sqrt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _rsqrt_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _rsqrt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _ceil_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _ceil
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _floor_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _floor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _round_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _round
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _trunc_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _trunc
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: frac_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: frac_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: frac
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mean_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mean
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mean
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: var_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: var
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: var
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: std_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: std
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: std
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: unbiased
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: norm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: p
-    python_default_init: 2
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: p
-    python_default_init: 2
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 2
-    default_init: 2
-    dynamic_type: real
-    name: p
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: renorm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: p
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: real
-    name: maxnorm
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: renorm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: p
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: real
-    name: maxnorm
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: renorm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: p
-    type: Scalar
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - dynamic_type: real
-    name: maxnorm
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: dist
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 2
-    default_init: 2
-    dynamic_type: real
-    name: p
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reciprocal_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reciprocal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reciprocal_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: neg_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: neg
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: neg_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan2_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan2
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan2_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: exponent
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: exponent
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: exponent
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: exponent
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: real
-    name: base
-    type: Scalar
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: real
-    name: base
-    type: Scalar
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: exponent
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pow_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: exponent
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lerp_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: end
-    type: const Tensor &
-  - dynamic_type: real
-    name: weight
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lerp
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: end
-    type: const Tensor &
-  - dynamic_type: real
-    name: weight
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: lerp_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: end
-    type: const Tensor &
-  - dynamic_type: real
-    name: weight
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _linspace_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: real
-    name: start
-    type: Scalar
-  - dynamic_type: real
-    name: end
-    type: Scalar
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _linspace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: real
-    name: start
-    type: Scalar
-  - dynamic_type: real
-    name: end
-    type: Scalar
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _logspace_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: real
-    name: start
-    type: Scalar
-  - dynamic_type: real
-    name: end
-    type: Scalar
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _logspace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: real
-    name: start
-    type: Scalar
-  - dynamic_type: real
-    name: end
-    type: Scalar
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: histc_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: bins
-    type: int64_t
-  - default: 0
-    default_init: 0
-    dynamic_type: real
-    name: min
-    type: Scalar
-  - default: 0
-    default_init: 0
-    dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: histc
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 100
-    default_init: 100
-    dynamic_type: int64_t
-    name: bins
-    type: int64_t
-  - default: 0
-    default_init: 0
-    dynamic_type: real
-    name: min
-    type: Scalar
-  - default: 0
-    default_init: 0
-    dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: zero_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sumall
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_sum_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _prodall
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_prod_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cumsum_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cumsum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cumprod_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cumprod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sign_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sign
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sign_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: trace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: other
-    type: SparseTensor
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: other
-    type: SparseTensor
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: add_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: SparseTensor
-    name: other
-    type: SparseTensor
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sub_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mul_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: div_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fmod_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: other
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: remainder_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_min_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_min
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_min_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: min
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_max_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_max
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: clamp_max_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: real
-    name: max
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dot
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: accreal
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tril_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tril
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tril_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: triu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: triu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: triu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cross_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cross
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: other
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: diag_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: diag
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: diagonal
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: mat1
-    type: SparseTensor
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: mat1
-    type: SparseTensor
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addmm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: SparseTensor
-    name: mat1
-    type: SparseTensor
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addmv_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addmv
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addmv_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addr_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addr
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _addr_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _ger_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _ger
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _mv_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _mv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: vec
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _mm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _mm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: bmm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: bmm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addbmm_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addbmm
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addbmm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: baddbmm_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: baddbmm
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: baddbmm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: batch1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: batch2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcmul_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcmul
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcmul_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcdiv_out
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcdiv
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: addcdiv_
-  method_prefix_derived: s_
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: tensor1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: tensor2
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: real
-    kwarg_only: true
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _gesv_single_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: solution
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: lu
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: solution
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: lu
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _gesv_single
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: solution
-    type: Tensor
-  - dynamic_type: Tensor
-    name: lu
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gels_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: gels
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: trtrs_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: transpose
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: unitriangular
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: trtrs
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: A
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: transpose
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: unitriangular
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: symeig_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: eigenvectors
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: symeig
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: eigenvectors
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eig_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: eigenvectors
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: eig
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: eigenvectors
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: svd_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res3
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: some
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res3
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: svd
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: some
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res3
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: inverse_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: inverse
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potrf_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potrf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potrs_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potrs
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potri_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: potri
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pstrf_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  - default: -1
-    default_init: -1
-    dynamic_type: real
-    name: tol
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: pstrf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: upper
-    type: bool
-  - default: -1
-    default_init: -1
-    dynamic_type: real
-    name: tol
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: IntegerTensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: qr_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: qr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: geqrf_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: res1
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: geqrf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: res1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: res2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: orgqr_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: orgqr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ormqr_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input3
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: left
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: transpose
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ormqr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: input3
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: left
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: transpose
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrifact_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: pivots
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    kwarg_only: true
-    name: pivot
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: pivots
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrifact
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    kwarg_only: true
-    name: pivot
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  - dynamic_type: IntegerTensor
-    name: pivots
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrifact_with_info_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: pivots
-    output: true
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: info
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    kwarg_only: true
-    name: pivot
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: pivots
-    type: Tensor &
-  - dynamic_type: IntegerTensor
-    name: info
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrifact_with_info
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    kwarg_only: true
-    name: pivot
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  - dynamic_type: IntegerTensor
-    name: pivots
-    type: Tensor
-  - dynamic_type: IntegerTensor
-    name: info
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrisolve_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: LU_data
-    type: const Tensor &
-  - dynamic_type: IntegerTensor
-    name: LU_pivots
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: btrisolve
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: LU_data
-    type: const Tensor &
-  - dynamic_type: IntegerTensor
-    name: LU_pivots
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: random_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: from
-    type: int64_t
-  - dynamic_type: int64_t
-    name: to
-    type: int64_t
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: random_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    name: to
-    type: int64_t
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: random_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multinomial_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: num_samples
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: replacement
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multinomial
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: num_samples
-    type: int64_t
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: replacement
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: uniform_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: double
-    name: from
-    type: double
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: to
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mean
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: std
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: mean
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: std
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: double
-    name: mean
-    type: double
-  - dynamic_type: Tensor
-    name: std
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: double
-    name: mean
-    type: double
-  - dynamic_type: Tensor
-    name: std
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: std
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: std
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: normal_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: double
-    name: mean
-    type: double
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: std
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cauchy_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0
-    default_init: 0
-    dynamic_type: double
-    name: median
-    type: double
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: sigma
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_normal_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: mean
-    type: double
-  - default: 2
-    default_init: 2
-    dynamic_type: double
-    name: std
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: exponential_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: double
-    name: lambd
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: geometric_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: double
-    name: p
-    type: double
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_bernoulli_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _th_bernoulli
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dirichlet_grad_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: x
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: alpha
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: total
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dirichlet_grad
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: x
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: alpha
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: total
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Storage
-    name: storage
-    type: Storage &
-  - dynamic_type: int64_t
-    name: storageOffset
-    type: int64_t
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: IntList
-    name: stride
-    type: IntList
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    type: IntList
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tensor
-  method_prefix_derived: ''
-  arguments: []
-  method_of:
-  - Type
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sparse_coo_tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: values
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sparse_coo_tensor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: values
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: alias
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sparse_coo_tensor_unsafe
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: values
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _copy_ignoring_overlaps_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: src
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: as_strided_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    type: IntList
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: storage_offset
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: as_strided
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    type: IntList
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: storage_offset
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: as_strided_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    type: IntList
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: storage_offset
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sparse_raw_resize_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: IntList
-    name: size
-    type: IntList
-  - dynamic_type: int64_t
-    name: nDimI
-    type: int64_t
-  - dynamic_type: int64_t
-    name: nDimV
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cat_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    output: true
-    type: Tensor &
-  - dynamic_type: TensorList
-    name: tensors
-    type: TensorList
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cat
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: TensorList
-    name: tensors
-    type: TensorList
-  - default: 0
-    default_init: 0
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sparse_mask
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: SparseTensor
-    name: mask
-    type: SparseTensor
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: SparseTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: to_dense
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dimI
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _dimV
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _nnz
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: coalesce
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: is_coalesced
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _indices
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: IndexTensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _values
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hspmm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hspmm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: TH
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: binary_cross_entropy_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: kl_div
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: kl_div_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: l1_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: mse_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: p
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: p
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: p
-    type: Scalar
-  - dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: p
-    type: Scalar
-  - dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: p
-    type: Scalar
-  - dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multi_margin_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: p
-    type: Scalar
-  - dynamic_type: accreal
-    name: margin
-    type: Scalar
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - is_target
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - is_target
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: is_target
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: is_target
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: is_target
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: is_target
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: multilabel_margin_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: is_target
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: -100
-    default_init: -100
-    dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - total_weight
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: -100
-    default_init: -100
-    dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - total_weight
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: total_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: total_weight
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: total_weight
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: total_weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: total_weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: -100
-    default_init: -100
-    dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - total_weight
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: -100
-    default_init: -100
-    dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - total_weight
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: total_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: total_weight
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: total_weight
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: total_weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: nll_loss2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: int64_t
-    name: ignore_index
-    type: int64_t
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  - dynamic_type: Tensor
-    name: total_weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: smooth_l1_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: size_average
-    type: bool
-  - default: true
-    default_init: true
-    dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: soft_margin_loss_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: target
-    type: const Tensor &
-  - dynamic_type: bool
-    name: size_average
-    type: bool
-  - dynamic_type: bool
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: elu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: elu_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: elu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: elu_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: alpha
-    type: Scalar
-  - dynamic_type: accreal
-    name: scale
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: glu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: glu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: glu_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: glu_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: glu_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: glu_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.5
-    default_init: 0.5
-    dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.5
-    default_init: 0.5
-    dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardshrink_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: -1
-    default_init: -1
-    dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hardtanh_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: min_val
-    type: Scalar
-  - dynamic_type: accreal
-    name: max_val
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.01
-    default_init: 0.01
-    dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.01
-    default_init: 0.01
-    dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - default: 0.01
-    default_init: 0.01
-    dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: leaky_relu_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: negative_slope
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - buffer
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - buffer
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: buffer
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: buffer
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: buffer
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: buffer
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_sigmoid_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: buffer
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prelu_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prelu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prelu_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prelu_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prelu_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prelu_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - default: '{{true, true}}'
-    default_init: '{{true, true}}'
-    dynamic_type: std::array<bool,2>
-    name: output_mask
-    type: std::array<bool,2>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - default: 0.125
-    default_init: 0.125
-    dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    default_init: 0.3333333333333333
-    dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: training
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - default: 0.125
-    default_init: 0.125
-    dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    default_init: 0.3333333333333333
-    dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: training
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - default: 0.125
-    default_init: 0.125
-    dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    default_init: 0.3333333333333333
-    dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: training
-    type: bool
-  - default: nullptr
-    default_init: nullptr
-    dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_with_noise_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: noise
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lower
-    type: Scalar
-  - dynamic_type: accreal
-    name: upper
-    type: Scalar
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: Generator*
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softplus_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - default: 20
-    default_init: 20
-    dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softplus
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 1
-    default_init: 1
-    dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - default: 20
-    default_init: 20
-    dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softplus_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softplus_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softplus_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softplus_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: beta
-    type: Scalar
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.5
-    default_init: 0.5
-    dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softshrink
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - default: 0.5
-    default_init: 0.5
-    dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softshrink_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: lambd
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: threshold
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: threshold_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: threshold_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: threshold_forward_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  - dynamic_type: accreal
-    name: threshold
-    type: Scalar
-  - dynamic_type: accreal
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: avg_pool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: bool
-    name: count_include_pad
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: random_samples
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: random_samples
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: random_samples
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: random_samples
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fractional_max_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: kernel_size
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - default: false
-    default_init: false
-    dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: IndexTensor
-    name: indices
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_pool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: ceil_mode
-    type: bool
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: max_unpool3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad1d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: reflection_pad2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad1d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 4
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: replication_pad3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: padding
-    size: 6
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_linear1d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 1
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 4
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_bilinear2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 4
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 5
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_trilinear3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: output_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: input_size
-    size: 5
-    type: IntList
-  - dynamic_type: bool
-    name: align_corners
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest1d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: upsample_nearest3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    name: scale_factor
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _sigmoid_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _tanh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _tanh_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: momentum
-    type: double
-  - dynamic_type: double
-    name: eps
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - save_mean
-  - save_std
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: momentum
-    type: double
-  - dynamic_type: double
-    name: eps
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - save_mean
-  - save_std
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: save_mean
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: save_std
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: momentum
-    type: double
-  - dynamic_type: double
-    name: eps
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: save_mean
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: save_std
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: momentum
-    type: double
-  - dynamic_type: double
-    name: eps
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: save_mean
-    type: Tensor
-  - dynamic_type: Tensor
-    name: save_std
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: eps
-    type: double
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_std
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_batch_norm_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    name: training
-    type: bool
-  - dynamic_type: double
-    name: eps
-    type: double
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_std
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_transpose3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: output_padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_depthwise2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - default: '{{true, true}}'
-    default_init: '{{true, true}}'
-    dynamic_type: std::array<bool,2>
-    name: output_mask
-    type: std::array<bool,2>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - finput
-  - fgrad_input
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: finput
-    type: Tensor
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: finput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: fgrad_input
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 2
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 2
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - default: '{}'
-    default_init: '{}'
-    dynamic_type: Tensor
-    name: bias
-    type: const Tensor &
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - default: '0'
-    default_init: '0'
-    dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - default: '1'
-    default_init: '1'
-    dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers:
-  - columns
-  - ones
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_forward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: output
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  - dynamic_type: Tensor
-    name: columns
-    type: Tensor
-  - dynamic_type: Tensor
-    name: ones
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_backward_out
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_input
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_weight
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_bias
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: thnn_conv_dilated3d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    name: kernel_size
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: stride
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: padding
-    size: 3
-    type: IntList
-  - dynamic_type: IntList
-    name: dilation
-    size: 3
-    type: IntList
-  - dynamic_type: Tensor
-    name: columns
-    type: const Tensor &
-  - dynamic_type: Tensor
-    name: ones
-    type: const Tensor &
-  - default: '{{true, true, true}}'
-    default_init: '{{true, true, true}}'
-    dynamic_type: std::array<bool,3>
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: NN
-  buffers: []
-  returns:
-  - dynamic_type: Tensor
-    name: grad_input
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_weight
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_bias
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Byte
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Char
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Double
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Float
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Int
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Long
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Short
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cast_Half
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: non_blocking
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _cudnn_rnn_flatten_weight
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: weight_arr
-    type: TensorList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: weight_stride0
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: input_size
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: hidden_size
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_layers
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: batch_first
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: bidirectional
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cudnn_rnn
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: weight
-    type: TensorList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: weight_stride0
-    type: int64_t
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight_buf
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: hx
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: cx
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: hidden_size
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_layers
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: batch_first
-    type: bool
-  - dynamic_type: double
-    is_nullable: false
-    name: dropout
-    type: double
-  - dynamic_type: bool
-    is_nullable: false
-    name: train
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: bidirectional
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: batch_sizes
-    type: IntList
-  - dynamic_type: BoolTensor
-    is_nullable: true
-    name: dropout_state
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result3
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result4
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cudnn_rnn_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: weight
-    type: TensorList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: weight_stride0
-    type: int64_t
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight_buf
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: hx
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: cx
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_hy
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: grad_cy
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: hidden_size
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_layers
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: batch_first
-    type: bool
-  - dynamic_type: double
-    is_nullable: false
-    name: dropout
-    type: double
-  - dynamic_type: bool
-    is_nullable: false
-    name: train
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: bidirectional
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: batch_sizes
-    type: IntList
-  - dynamic_type: BoolTensor
-    is_nullable: true
-    name: dropout_state
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: reserve
-    type: const Tensor &
-  - dynamic_type: std::array<bool,4>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,4>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  - dynamic_type: TensorList
-    name: result3
-    type: std::vector<Tensor>
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _cudnn_init_dropout_state
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: self_ty
-    type: const Type &
-  - dynamic_type: double
-    is_nullable: false
-    name: dropout
-    type: double
-  - dynamic_type: bool
-    is_nullable: false
-    name: train
-    type: bool
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dropout_seed
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: abs
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: abs_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: abs_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: acos
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: acos_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: acos_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_avg_pool1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_size
-    size: 1
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: adaptive_max_pool1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_size
-    size: 1
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: allclose
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  - default: 1.0e-05
-    dynamic_type: double
-    is_nullable: false
-    name: rtol
-    type: double
-  - default: 1.0e-08
-    dynamic_type: double
-    is_nullable: false
-    name: atol
-    type: double
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: equal_nan
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addmv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addmv_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addmv_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addr
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addr_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: addr_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: arange
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: arange_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: arange
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: arange_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: argmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: argmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _argmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: argmin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: argmin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _argmin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: asin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: asin_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: asin_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: atan_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: atan_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: batch_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    is_nullable: false
-    name: training
-    type: bool
-  - dynamic_type: double
-    is_nullable: false
-    name: momentum
-    type: double
-  - dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enabled
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: p
-    type: const Tensor &
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: double
-    is_nullable: false
-    name: p
-    type: double
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: p
-    type: const Tensor &
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: double
-    is_nullable: false
-    name: p
-    type: double
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bernoulli_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: bilinear
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cat
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cat_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ceil
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ceil_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: ceil_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: chunk
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: chunks
-    type: int64_t
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: TensorList
-    name: result
-    type: std::vector<Tensor>
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_is_acceptable
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: convolution
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: transposed
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _convolution
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: transposed
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enabled
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _convolution_nogroup
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: transposed
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _convolution_double_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: ggI
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: ggW
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: ggb
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: gO
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: transposed
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enabled
-    type: bool
-  - dynamic_type: std::array<bool,3>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 1
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 1
-    type: IntList
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 1
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 2
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 2
-    type: IntList
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 2
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 3
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 3
-    type: IntList
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 3
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_tbc
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pad
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_tbc_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pad
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_transpose1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 1
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 1
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    size: 1
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 1
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_transpose2d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 2
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 2
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    size: 2
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 2
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: conv_transpose3d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: false
-    name: bias
-    type: const Tensor &
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 3
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 3
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    size: 3
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 3
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cos
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cos_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cos_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cosh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cosh_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cosh_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cosine_embedding_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: target
-    type: const Tensor &
-  - default: 0.0
-    dynamic_type: double
-    is_nullable: false
-    name: margin
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: size_average
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_affine_grid_generator
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: theta
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: N
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: C
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: H
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: W
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: grid
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_affine_grid_generator_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: N
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: C
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: H
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: W
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: grad_theta
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_batch_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: bool
-    is_nullable: false
-    name: training
-    type: bool
-  - dynamic_type: double
-    is_nullable: false
-    name: exponential_average_factor
-    type: double
-  - dynamic_type: double
-    is_nullable: false
-    name: epsilon
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_batch_norm_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: running_var
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_mean
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: save_var
-    type: const Tensor &
-  - dynamic_type: double
-    is_nullable: false
-    name: epsilon
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_backward_input
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: self_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  - dynamic_type: std::array<bool,3>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_backward_bias
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_backward_weight
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: weight_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  - dynamic_type: std::array<bool,3>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose_backward_bias
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose_backward_input
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_convolution_transpose_backward_weight
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: weight_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: groups
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: benchmark
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: deterministic
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_grid_sampler
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grid
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: output
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cudnn_grid_sampler_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grid
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: grad_self
-    type: Tensor
-  - dynamic_type: Tensor
-    name: grad_grid
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: cumsum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumsum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumsum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumsum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumprod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumprod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumprod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: cumprod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: det
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: diagflat
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: offset
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: diagonal
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: offset
-    type: int64_t
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim1
-    type: int64_t
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim2
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: dot
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: tensor
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: dot_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: tensor
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: einsum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: std::string
-    is_nullable: false
-    name: equation
-    type: std::string
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - default: -1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: padding_idx
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: sparse
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: padding_idx
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: sparse
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_dense_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: padding_idx
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: embedding_renorm_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: double
-    is_nullable: false
-    name: max_norm
-    type: double
-  - dynamic_type: double
-    is_nullable: false
-    name: norm_type
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: embedding_sparse_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: padding_idx
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_bag
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offsets
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: sparse
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result3
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: embedding_bag_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offsets
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offset2bag
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: bag_size
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: maximum_indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: sparse
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_bag_sparse_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offsets
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offset2bag
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: bag_size
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: embedding_bag_dense_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: indices
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offsets
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: offset2bag
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: bag_size
-    type: const Tensor &
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: maximum_indices
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_weights
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: scale_grad_by_freq
-    type: bool
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: mode
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: empty
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: empty_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: empty_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: empty_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: erf
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: erf_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: erf_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: exp
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: exp_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: exp_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: expm1
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: expm1_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: expm1_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: expand
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    kwarg_only: true
-    name: implicit
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: expand_as
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: eye
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: n
-    type: int64_t
-  - default: -1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: m
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: eye_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: n
-    type: int64_t
-  - default: -1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: m
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: value
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: fill_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: value
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: floor
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: floor_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: floor_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: full
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: fill_value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: full_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: fill_value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: full_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: fill_value
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: full_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: fill_value
-    type: Scalar
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: hinge_embedding_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: target
-    type: const Tensor &
-  - default: 1.0
-    dynamic_type: double
-    is_nullable: false
-    name: margin
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: size_average
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ger
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ger_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: gesv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: gesv_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: solution
-    output: true
-    type: Tensor &
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: lu
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor &
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _gesv_helper
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: A
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: group_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: num_groups
-    type: int64_t
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - default: 1.0e-05
-    dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enabled
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: fft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ifft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rfft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: onesided
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: irfft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: onesided
-    type: bool
-  - default: '{}'
-    dynamic_type: IntList
-    is_nullable: false
-    name: signal_sizes
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _fft_with_size
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: signal_ndim
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: complex_input
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: complex_output
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: inverse
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: checked_signal_sizes
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  - dynamic_type: bool
-    is_nullable: false
-    name: onesided
-    type: bool
-  - dynamic_type: IntList
-    is_nullable: false
-    name: output_sizes
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: index
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: indices
-    type: TensorList
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: index_copy_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: IndexTensor
-    is_nullable: false
-    name: index
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: source
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: index_put_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: indices
-    type: TensorList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: values
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: isclose
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  - default: 1.0e-05
-    dynamic_type: double
-    is_nullable: false
-    name: rtol
-    type: double
-  - default: 1.0e-08
-    dynamic_type: double
-    is_nullable: false
-    name: atol
-    type: double
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: equal_nan
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_cuda
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_distributed
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_floating_point
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_nonzero
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_same_size
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_signed
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: is_sparse
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: bool
-    name: result
-    type: bool
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: layer_norm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: normalized_shape
-    type: IntList
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: weight
-    type: const Tensor &
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - default: 1.0e-05
-    dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: cudnn_enable
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: linspace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 100
-    dynamic_type: int64_t
-    is_nullable: false
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: linspace_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 100
-    dynamic_type: int64_t
-    is_nullable: false
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log10
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log10_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log10_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log1p
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log1p_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log1p_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log2
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log2_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log2_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: logdet
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: logspace
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 100
-    dynamic_type: int64_t
-    is_nullable: false
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: logspace_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 100
-    dynamic_type: int64_t
-    is_nullable: false
-    name: steps
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: log_softmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: log_softmax_backward_data
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: output
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: logsumexp
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: logsumexp_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: margin_ranking_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: target
-    type: const Tensor &
-  - default: 0.0
-    dynamic_type: double
-    is_nullable: false
-    name: margin
-    type: double
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: size_average
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: matmul
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: matmul_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_values
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: max_pool1d
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: kernel_size
-    size: 1
-    type: IntList
-  - default: '{}'
-    dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    size: 1
-    type: IntList
-  - default: 0
-    dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    size: 1
-    type: IntList
-  - default: 1
-    dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: ceil_mode
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: min_values
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mkldnn_convolution
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: true
-    name: bias
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mkldnn_convolution_backward_input
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: self_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: bias_defined
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mkldnn_convolution_backward_weights
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: IntList
-    is_nullable: false
-    name: weight_size
-    type: IntList
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: bias_defined
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mkldnn_convolution_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: weight
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: padding
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: stride
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dilation
-    type: IntList
-  - dynamic_type: std::array<bool,3>
-    is_nullable: false
-    name: output_mask
-    type: std::array<bool,3>
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result2
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mm_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mv
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: mv_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: vec
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: narrow
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: start
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: length
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ones
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ones_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ones_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: ones_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: pairwise_distance
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: x1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: x2
-    type: const Tensor &
-  - default: 2
-    dynamic_type: double
-    is_nullable: false
-    name: p
-    type: double
-  - default: 1.0e-06
-    dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: permute
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dims
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: pin_memory
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rand
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rand_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rand_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rand_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: low
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: low
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: low
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randint_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: low
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: high
-    type: int64_t
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randn
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randn_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randn_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randn_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randperm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: n
-    type: int64_t
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: randperm_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: n
-    type: int64_t
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    kwarg_only: true
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: range
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: range_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: start
-    type: Scalar
-  - dynamic_type: Scalar
-    is_nullable: false
-    name: end
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    name: step
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: repeat
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: repeats
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: reshape
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: shape
-    type: IntList
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: RoiPooling2d_forward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: rois
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pooledHeight
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pooledWidth
-    type: int64_t
-  - dynamic_type: double
-    is_nullable: false
-    name: spatialScale
-    type: double
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: RoiPooling2d_backward
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: input
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: rois
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pooledHeight
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: pooledWidth
-    type: int64_t
-  - dynamic_type: double
-    is_nullable: false
-    name: spatialScale
-    type: double
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: gradOutput
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: argmaxes
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: round
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: round_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: round_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rrelu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: 0.125
-    dynamic_type: Scalar
-    is_nullable: false
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    dynamic_type: Scalar
-    is_nullable: false
-    name: upper
-    type: Scalar
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: training
-    type: bool
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rrelu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - default: 0.125
-    dynamic_type: Scalar
-    is_nullable: false
-    name: lower
-    type: Scalar
-  - default: 0.3333333333333333
-    dynamic_type: Scalar
-    is_nullable: false
-    name: upper
-    type: Scalar
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: training
-    type: bool
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: relu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: relu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rsqrt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: rsqrt_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: rsqrt_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: select
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: index
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: selu
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: selu_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sin
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sin_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sin_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sinh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sinh_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sinh_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: size
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: slice
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: start
-    type: int64_t
-  - default: 9223372036854775807
-    dynamic_type: int64_t
-    is_nullable: false
-    name: end
-    type: int64_t
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: step
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: slogdet
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: smm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: softmax
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: softmax_backward_data
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: grad_output
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: output
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: split
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: split_size
-    type: int64_t
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: TensorList
-    name: result
-    type: std::vector<Tensor>
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: split_with_sizes
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: split_sizes
-    type: IntList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: TensorList
-    name: result
-    type: std::vector<Tensor>
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: squeeze
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: squeeze
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: squeeze_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: squeeze_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sspaddmm
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sspaddmm_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: mat2
-    type: const Tensor &
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: beta
-    type: Scalar
-  - default: 1
-    dynamic_type: Scalar
-    is_nullable: false
-    kwarg_only: true
-    name: alpha
-    type: Scalar
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: stack
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: stack_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: TensorList
-    is_nullable: false
-    name: tensors
-    type: TensorList
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: stft
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: frame_length
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: hop
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: fft_size
-    python_default_init: frame_length
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: normalized
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: onesided
-    type: bool
-  - default: '{}'
-    dynamic_type: Tensor
-    is_nullable: true
-    name: window
-    type: const Tensor &
-  - default: 0
-    dynamic_type: int64_t
-    is_nullable: false
-    name: pad_end
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: stride
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: int64_t
-    name: result
-    type: int64_t
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sum
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sum_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: dim
-    size: 1
-    type: IntList
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _sum_cuda_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sqrt
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: sqrt_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: sqrt_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _prod
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: prod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - dynamic_type: ScalarType
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    type: ScalarType
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _prod_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: keepdim
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: t
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: t_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: tan
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: tan_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tan_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tanh
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: tanh_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: tanh_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: transpose
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim0
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim1
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: transpose_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim0
-    type: int64_t
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim1
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _trilinear
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: i1
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: i2
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: i3
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: expand1
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: expand2
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: expand3
-    type: IntList
-  - dynamic_type: IntList
-    is_nullable: false
-    name: sumdim
-    type: IntList
-  - default: 1
-    dynamic_type: int64_t
-    is_nullable: false
-    name: unroll_dim
-    type: int64_t
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: triplet_margin_loss
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: anchor
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: positive
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: negative
-    type: const Tensor &
-  - default: 1.0
-    dynamic_type: double
-    is_nullable: false
-    name: margin
-    type: double
-  - default: 2
-    dynamic_type: double
-    is_nullable: false
-    name: p
-    type: double
-  - default: 1.0e-06
-    dynamic_type: double
-    is_nullable: false
-    name: eps
-    type: double
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: swap
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: size_average
-    type: bool
-  - default: true
-    dynamic_type: bool
-    is_nullable: false
-    name: reduce
-    type: bool
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: trunc
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: trunc_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: trunc_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: type_as
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _unique
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: sorted
-    type: bool
-  - default: false
-    dynamic_type: bool
-    is_nullable: false
-    name: return_inverse
-    type: bool
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result0
-    type: Tensor
-  - dynamic_type: Tensor
-    name: result1
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _unsafe_view
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: unsqueeze
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: unsqueeze_
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: Tensor &
-  - dynamic_type: int64_t
-    is_nullable: false
-    name: dim
-    type: int64_t
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: self
-    type: Tensor &
-  inplace: true
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: view_as
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: where
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    is_nullable: false
-    name: condition
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _s_where
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: BoolTensor
-    is_nullable: false
-    name: condition
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: other
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: zeros
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Type
-    is_nullable: false
-    is_type_dispatched: true
-    name: dtype
-    type: const Type &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: zeros_out
-  method_prefix_derived: ''
-  arguments:
-  - allocate: true
-    dynamic_type: Tensor
-    is_nullable: false
-    name: result
-    output: true
-    type: Tensor &
-  - dynamic_type: IntList
-    is_nullable: false
-    name: size
-    type: IntList
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor &
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: zeros_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: zeros_like
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Type
-    is_nullable: false
-    kwarg_only: true
-    name: dtype
-    python_default_init: self.type()
-    type: const Type &
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: false
-  auto_gpu: true
-  with_gil: false
-- name: _standard_gamma_grad
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: output
-    type: const Tensor &
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: _standard_gamma
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - Tensor
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false
-- name: poisson
-  method_prefix_derived: ''
-  arguments:
-  - dynamic_type: Tensor
-    is_nullable: false
-    name: self
-    type: const Tensor &
-  - default: nullptr
-    dynamic_type: Generator *
-    is_nullable: false
-    name: generator
-    type: Generator *
-  method_of:
-  - Type
-  - namespace
-  mode: native
-  returns:
-  - dynamic_type: Tensor
-    name: result
-    type: Tensor
-  inplace: false
-  abstract: true
-  auto_gpu: true
-  with_gil: false

From cb7bbaa6e8e9e17b4ed2c7641231f5339f8b1fab Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 16:06:08 -0700
Subject: [PATCH 103/118] Include common.h

---
 caffe2/core/net_async_tracing.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/caffe2/core/net_async_tracing.cc b/caffe2/core/net_async_tracing.cc
index b19acb653dad0..fe24c6d6409b0 100644
--- a/caffe2/core/net_async_tracing.cc
+++ b/caffe2/core/net_async_tracing.cc
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "caffe2/core/common.h"
 #include "caffe2/core/net_async_tracing.h"
 
 #include "caffe2/utils/string_utils.h"

From c254f73e6a41af8bc842559e830c68e2148f4c18 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Tue, 12 Jun 2018 16:17:44 -0700
Subject: [PATCH 104/118] Change std::stoi to caffe2::stoi

---
 caffe2/core/net_async_tracing.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/caffe2/core/net_async_tracing.cc b/caffe2/core/net_async_tracing.cc
index fe24c6d6409b0..b19acb653dad0 100644
--- a/caffe2/core/net_async_tracing.cc
+++ b/caffe2/core/net_async_tracing.cc
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include "caffe2/core/common.h"
 #include "caffe2/core/net_async_tracing.h"
 
 #include "caffe2/utils/string_utils.h"

From 2931292cc7c0d56a01a5e8949eb9a4e1411299a1 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Wed, 13 Jun 2018 10:28:49 -0700
Subject: [PATCH 105/118] Remove the code per soumith's comments

---
 tools/jit/gen_jit_dispatch.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tools/jit/gen_jit_dispatch.py b/tools/jit/gen_jit_dispatch.py
index f494fa0a4f549..05c959110b906 100644
--- a/tools/jit/gen_jit_dispatch.py
+++ b/tools/jit/gen_jit_dispatch.py
@@ -94,8 +94,6 @@ def is_jit_op(decl):
     # Only support a single TensorList arg
     if sum(arg['simple_type'] == 'TensorList' for arg in arguments) > 1:
         return False
-    if any(arg['simple_type'] == 'std::string' for arg in arguments):
-        return False
 
     return ((not decl['api_name'].endswith('_') or is_magic_method(decl['api_name'])) and
             not decl['name'].endswith('_out') and

From f47c0c24c93895c9a06dbad99ac4bb8c37ad720b Mon Sep 17 00:00:00 2001
From: Jinghui <31264804+gujinghui@users.noreply.github.com>
Date: Wed, 13 Jun 2018 13:06:16 +0800
Subject: [PATCH 106/118] [caffe2] uprade IDEEP and hotfix for conv op accuracy
 issue (#8364)

* [IDEEP] Upgrade IDEEP version

Signed-off-by: Gu, Jinghui <jinghui.gu@intel.com>

* [IDEEP] Fix accuracy issue in conv op

Signed-off-by: Gu, Jinghui <jinghui.gu@intel.com>

* Fix build error due to lack of src in CMakeLists

Signed-off-by: Gu, Jinghui <jinghui.gu@intel.com>
---
 caffe2/ideep/operators/conv_op.cc | 19 ++++++++++++-------
 caffe2/utils/CMakeLists.txt       |  1 +
 third_party/ideep                 |  2 +-
 3 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/caffe2/ideep/operators/conv_op.cc b/caffe2/ideep/operators/conv_op.cc
index e86028db31465..e3f2ca672ce62 100644
--- a/caffe2/ideep/operators/conv_op.cc
+++ b/caffe2/ideep/operators/conv_op.cc
@@ -40,15 +40,20 @@ class IDEEPConvOp final : public IDEEPConvPoolOpBase {
         (cached_weights_descriptor_ != filter.get_descriptor());
     if (weights_changed && !training_mode_) {
       cached_weights_descriptor_ = filter.get_descriptor();
-      filter_ = filter;
+      auto filter_in = filter;
+      filter_in.make_group(group_);
       auto expected_descriptor =
           ideep::convolution_forward::expected_weights_descriptor(
-              filter.get_dims());
-      if (filter_.get_descriptor() != expected_descriptor) {
-        filter_.init<ideep::utils::allocator, ideep::convolution_forward>(
-            expected_descriptor);
-        ideep::reorder::compute(filter, filter_);
-      }
+              filter_in.get_dims(),
+              filter_in.get_data_type(),
+              stride_,
+              pad_tl(),
+              pad_br(),
+              dilation_,
+              group_);
+      filter_.init<ideep::utils::allocator, ideep::convolution_forward>(
+          expected_descriptor);
+      ideep::reorder::compute(filter_in, filter_);
     }
 
     // NB: actually, in the case when `group_ > 1`, IDEEP will create
diff --git a/caffe2/utils/CMakeLists.txt b/caffe2/utils/CMakeLists.txt
index d774caceb4e19..5e7801c1f653c 100644
--- a/caffe2/utils/CMakeLists.txt
+++ b/caffe2/utils/CMakeLists.txt
@@ -5,6 +5,7 @@ set(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS}
         utils/signal_handler.cc
         utils/string_utils.cc
         utils/threadpool/ThreadPool.cc
+        utils/thread_name.cc
         utils/cpuid.cc
         utils/bench_utils.cc
         utils/math_cpu.cc
diff --git a/third_party/ideep b/third_party/ideep
index a861d8c2b2cce..4bd9a6800bf7d 160000
--- a/third_party/ideep
+++ b/third_party/ideep
@@ -1 +1 @@
-Subproject commit a861d8c2b2cceddb4d17b924b75bc1ce0a20eec0
+Subproject commit 4bd9a6800bf7db068187619e0582d34dec9651dc

From c3ac213a9015af1d1b0fda30509fa7366522c616 Mon Sep 17 00:00:00 2001
From: James Reed <jamesreed@fb.com>
Date: Tue, 12 Jun 2018 22:59:45 -0700
Subject: [PATCH 107/118] [ONNX] Add an ATen fallback pathway for ONNX export
 (#8273)

* ATen fallback for ONNX export

* Move to enum

* Fix model test

* Add comment

* Address comments

BC interface
---
 ...torchExportModes.test_aten_fallback.expect | 17 ++++
 test/onnx/test_models.py                      |  3 +-
 test/test_jit.py                              | 43 +++++++---
 torch/csrc/Module.cpp                         |  5 +-
 torch/csrc/jit/export.cpp                     | 43 +++++-----
 torch/csrc/jit/export.h                       |  7 +-
 torch/csrc/jit/passes/onnx.cpp                |  9 +--
 torch/csrc/jit/passes/onnx.h                  |  5 +-
 torch/csrc/jit/python_ir.cpp                  | 14 ++--
 torch/csrc/onnx/init.cpp                      |  6 ++
 torch/csrc/onnx/onnx.h                        |  7 ++
 torch/onnx/__init__.py                        | 18 +++--
 torch/onnx/utils.py                           | 80 ++++++++++++-------
 13 files changed, 175 insertions(+), 82 deletions(-)
 create mode 100644 test/expect/TestPytorchExportModes.test_aten_fallback.expect

diff --git a/test/expect/TestPytorchExportModes.test_aten_fallback.expect b/test/expect/TestPytorchExportModes.test_aten_fallback.expect
new file mode 100644
index 0000000000000..fdb6194f2db72
--- /dev/null
+++ b/test/expect/TestPytorchExportModes.test_aten_fallback.expect
@@ -0,0 +1,17 @@
+ModelProto {
+  producer_name: "pytorch"
+  domain: ""
+  doc_string: ""
+  graph:
+    GraphProto {
+      name: "torch-jit-export"
+      inputs: [{name: "0", type:Tensor dims: 3 4},{name: "1", type:Tensor dims: 3 4}]
+      outputs: [{name: "3", type:Tensor dims: 3 3},{name: "4", type:Tensor dims: 3 4}]
+      initializers: []
+      nodes: [
+        Node {type: "Add", inputs: [0,1], outputs: [2], attributes: []},
+        Node {type: "ATen", inputs: [2], outputs: [3,4], attributes: [{ name: 'operator', type: string, value: 'qr'}]}
+      ]
+    }
+  opset_import: [OperatorSetIdProto { domain: }],
+}
diff --git a/test/onnx/test_models.py b/test/onnx/test_models.py
index e928855aeface..d20dfa25b7e64 100644
--- a/test/onnx/test_models.py
+++ b/test/onnx/test_models.py
@@ -19,6 +19,7 @@
 import torch.onnx.utils
 from torch.autograd import Variable, Function
 from torch.nn import Module
+from torch.onnx import OperatorExportTypes
 
 import onnx
 import onnx.checker
@@ -45,7 +46,7 @@ def toC(x):
 
 class TestModels(TestCase):
     def exportTest(self, model, inputs, rtol=1e-2, atol=1e-7):
-        trace = torch.onnx.utils._trace(model, inputs)
+        trace = torch.onnx.utils._trace(model, inputs, OperatorExportTypes.ONNX)
         torch._C._jit_pass_lint(trace.graph())
         verify(model, inputs, backend, rtol=rtol, atol=atol)
 
diff --git a/test/test_jit.py b/test/test_jit.py
index 7cccc6a73d9a2..d5148244e6192 100644
--- a/test/test_jit.py
+++ b/test/test_jit.py
@@ -8,6 +8,7 @@
 from torch.autograd import Variable, Function
 from torch.autograd.function import traceable
 from torch.testing import assert_allclose
+from torch.onnx import OperatorExportTypes
 from common import TestCase, run_tests, IS_WINDOWS
 from textwrap import dedent
 import os
@@ -94,7 +95,7 @@ def get_fn(file_name, script_path):
 
 class JitTestCase(TestCase):
     def assertExpectedONNXGraph(self, trace, *args, **kwargs):
-        torch.onnx._optimize_trace(trace, aten=False)
+        torch.onnx._optimize_trace(trace, operator_export_type=OperatorExportTypes.ONNX)
         self.assertExpectedGraph(trace, *args, **kwargs)
 
     def assertExpectedGraph(self, trace, *args, **kwargs):
@@ -137,7 +138,8 @@ def run(graph):
             return torch._C.GraphExecutor(graph, False)(*inputs)
 
         proto, _ = trace.graph().export(initializers, onnx_opset_version=0,
-                                        defer_weight_export=False, export_raw_ir=True)
+                                        defer_weight_export=False,
+                                        operator_export_type=OperatorExportTypes.RAW)
         self.assertFalse(initializers)
 
         imported_graph, initializers = torch._C._jit_import_graph(proto)
@@ -2531,7 +2533,7 @@ def forward(self, x):
 
         mte = ModuleToExport()
         outputs = mte(torch.zeros(1, 2, 3))
-        self.assertExpected(torch.onnx._export_to_pretty_string(
+        self.assertExpected(torch.onnx.export_to_pretty_string(
             mte, (torch.zeros(1, 2, 3),), None, verbose=False,
             example_outputs=outputs))
 
@@ -2580,7 +2582,7 @@ def forward(self, x):
 
         mte = ModuleToExport()
         outputs = mte(torch.zeros(1, 2, 3))
-        self.assertExpected(torch.onnx._export_to_pretty_string(
+        self.assertExpected(torch.onnx.export_to_pretty_string(
             mte, (torch.zeros(1, 2, 3),), None, verbose=False,
             example_outputs=outputs))
 
@@ -2605,7 +2607,7 @@ def forward(self, x):
 
         mte = ModuleToExport()
         outputs = mte(torch.zeros(1, 2, 3))
-        self.assertExpected(torch.onnx._export_to_pretty_string(
+        self.assertExpected(torch.onnx.export_to_pretty_string(
             mte, (torch.zeros(1, 2, 3),), None, verbose=False,
             example_outputs=outputs))
 
@@ -2622,7 +2624,7 @@ def forward(self, x):
 
         mte = ModuleToExport()
         outputs = mte(torch.zeros(1, 2, 3))
-        self.assertExpected(torch.onnx._export_to_pretty_string(
+        self.assertExpected(torch.onnx.export_to_pretty_string(
             mte, (torch.zeros(1, 2, 3),), None, verbose=False,
             example_outputs=outputs))
 
@@ -2639,7 +2641,7 @@ def forward(self, x):
 
         mte = ModuleToExport()
         outputs = mte(torch.zeros(1, 2, 3, dtype=torch.long))
-        self.assertExpected(torch.onnx._export_to_pretty_string(
+        self.assertExpected(torch.onnx.export_to_pretty_string(
             mte, (torch.zeros(1, 2, 3),), None, verbose=False,
             example_outputs=outputs))
 
@@ -2669,7 +2671,7 @@ def forward(self, x):
         result = mte(torch.zeros(2, 3))
         reference = torch.mm(torch.mm(torch.zeros(2, 3), torch.ones(3, 3)), torch.ones(3, 4))
         self.assertEqual(result, reference)
-        self.assertExpected(torch.onnx._export_to_pretty_string(
+        self.assertExpected(torch.onnx.export_to_pretty_string(
             mte, (torch.ones(2, 3),), None, verbose=False,
             example_outputs=result, propagate=True))
 
@@ -2728,12 +2730,12 @@ def transpose(x):
         f2 = Foo(linear)
         outputs_f2 = f2(torch.ones(1, 10, dtype=torch.float))
 
-        onnx_ish = torch.onnx._export_to_pretty_string(
+        onnx_ish = torch.onnx.export_to_pretty_string(
             f1,
             (torch.ones(1, 10, dtype=torch.float), ),
             None, verbose=False, example_outputs=outputs_f1)
         self.assertExpected(onnx_ish, subname='f1')
-        onnx_ish = torch.onnx._export_to_pretty_string(
+        onnx_ish = torch.onnx.export_to_pretty_string(
             f2,
             (torch.ones(1, 10, dtype=torch.float), ),
             None, verbose=False, example_outputs=outputs_f2)
@@ -2751,8 +2753,8 @@ def forward(self, x):
         foo = torch.jit.trace(torch.zeros(1, 2, 3))(Foo())
         outputs = foo(torch.zeros(1, 2, 3))
         f = io.BytesIO()
-        s = torch.onnx._export_to_pretty_string(foo, (torch.zeros(1, 2, 3)), f,
-                                                example_outputs=outputs)
+        s = torch.onnx.export_to_pretty_string(foo, (torch.zeros(1, 2, 3)), f,
+                                               example_outputs=outputs)
         self.assertExpected(s)
 
     def test_shape_analysis_loop(self):
@@ -3027,7 +3029,7 @@ def fn(x):
 
 
 # Smoke tests for export methods
-class TestPytorchExportModes(unittest.TestCase):
+class TestPytorchExportModes(JitTestCase):
     class MyModel(nn.Module):
         def __init__(self):
             super(TestPytorchExportModes.MyModel, self).__init__()
@@ -3064,6 +3066,21 @@ def test_directory(self):
                            export_type=torch.onnx.ExportTypes.DIRECTORY)
         shutil.rmtree(d)
 
+    def test_aten_fallback(self):
+        class ModelWithAtenNotONNXOp(nn.Module):
+            def forward(self, x, y):
+                abcd = x + y
+                defg = torch.qr(abcd)
+                return defg
+
+        x = torch.rand(3, 4)
+        y = torch.rand(3, 4)
+        f = io.BytesIO()
+        exported = torch.onnx.export_to_pretty_string(
+            ModelWithAtenNotONNXOp(), (x, y), f,
+            operator_export_type=OperatorExportTypes.ONNX_ATEN_FALLBACK)
+        self.assertExpected(exported)
+
 
 if __name__ == '__main__':
     run_tests()
diff --git a/torch/csrc/Module.cpp b/torch/csrc/Module.cpp
index b4f3e2d0f8829..0c4ab5d954c51 100644
--- a/torch/csrc/Module.cpp
+++ b/torch/csrc/Module.cpp
@@ -517,8 +517,11 @@ static PyObject* initModule() {
   ASSERT_TRUE(THPVariable_initModule(module));
   ASSERT_TRUE(THPFunction_initModule(module));
   ASSERT_TRUE(THPEngine_initModule(module));
-  torch::jit::initJITBindings(module);
+  // NOTE: We need to be able to access OperatorExportTypes from ONNX for use in
+  // the export side of JIT, so this ONNX init needs to appear before the JIT
+  // init.
   torch::onnx::initONNXBindings(module);
+  torch::jit::initJITBindings(module);
   torch::autograd::initNNFunctions(module);
   torch::autograd::init_legacy_variable(module);
 #ifdef WITH_CUDA
diff --git a/torch/csrc/jit/export.cpp b/torch/csrc/jit/export.cpp
index 939ed883678fb..aed47f3474d8a 100644
--- a/torch/csrc/jit/export.cpp
+++ b/torch/csrc/jit/export.cpp
@@ -24,7 +24,7 @@ std::string value_name(Value* n) {
 
 struct ExportContext {
   size_t num_blocks = 0;
-  bool export_raw_ir = false;
+  onnx::OperatorExportTypes operator_export_type;
 };
 
 void encodeGraph(onnx::GraphProto * p_g, const std::shared_ptr<Graph> & g,
@@ -224,7 +224,8 @@ void encodeBlock(onnx::GraphProto * p_g, Block *b,
     encodeValueInfo(v, output);
   }
   for (auto node : b->nodes()) {
-    if (node->kind() == prim::Undefined && !ctx->export_raw_ir) {
+    bool is_raw_export = ctx->operator_export_type == onnx::OperatorExportTypes::RAW;
+    if (node->kind() == prim::Undefined && !is_raw_export) {
       // Undefined nodes are used to implement optional inputs. One
       // way to "not provide" an optional input is to create an
       // Undefined node, and pass its output as that input.
@@ -237,7 +238,7 @@ void encodeBlock(onnx::GraphProto * p_g, Block *b,
       p_n->set_doc_string(ss.str());
     }
     for(auto input : node->inputs()) {
-      if (input->node()->kind() == prim::Undefined && !ctx->export_raw_ir) {
+      if (input->node()->kind() == prim::Undefined && !is_raw_export) {
         p_n->add_input("");
       } else {
         p_n->add_input(value_name(input));
@@ -246,18 +247,18 @@ void encodeBlock(onnx::GraphProto * p_g, Block *b,
     for(auto output : node->outputs()) {
       p_n->add_output(value_name(output));
     }
-    if (ctx->export_raw_ir) {
+    if (is_raw_export) {
       JIT_ASSERT(!node->kind().is_onnx());
       p_n->set_domain(node->kind().domainString());
     }
-    else {
+    else if (ctx->operator_export_type != onnx::OperatorExportTypes::ONNX_ATEN_FALLBACK) {
       JIT_ASSERT(node->kind().is_onnx());
     }
     p_n->set_op_type(node->kind().toUnqualString());
     for(auto attr_name : node->attributeNames()) {
       addAttribute(p_n, node, attr_name, ctx);
     }
-    if (ctx->export_raw_ir && node->blocks().size() > 0) {
+    if (is_raw_export && node->blocks().size() > 0) {
       auto blocks = p_n->add_attribute();
       blocks->set_name("_blocks");
       blocks->set_type(onnx::aGRAPHS);
@@ -311,10 +312,11 @@ void encodeBlock(onnx::GraphProto * p_g, Block *b,
 void encodeModel(onnx::ModelProto* p_m, const std::shared_ptr<Graph>& g,
                  const std::vector<at::Tensor>& initializers,
                  RawDataExportMap* raw_data_export_map = nullptr,
-                 bool export_raw_ir = false) {
+                 onnx::OperatorExportTypes operator_export_type
+                   = onnx::OperatorExportTypes::ONNX) {
   onnx::GraphProto* p_g = p_m->mutable_graph();
   ExportContext ctx;
-  ctx.export_raw_ir = export_raw_ir;
+  ctx.operator_export_type = operator_export_type;
   encodeGraph(p_g, g, initializers, &ctx, raw_data_export_map);
 }
 
@@ -330,7 +332,7 @@ std::string getNodeStackTraceString(Node* n) {
 }
 } // namespace
 
-void validateGraph(const std::shared_ptr<Graph>& graph) {
+void validateGraph(const std::shared_ptr<Graph>& graph, onnx::OperatorExportTypes operator_export_type) {
   for (auto node : graph->nodes()) {
       // Macro'ed so we get a marginally better line number on failed export
 #define FAIL_EXPORT(name) \
@@ -357,7 +359,8 @@ void validateGraph(const std::shared_ptr<Graph>& graph) {
             "Cannot export individual pack_padded_sequence or pad_packed_sequence; these operations must occur in pairs.\n\nUsage of this operation occurred at:\n" +
             getNodeStackTraceString(node));
       }
-      if (!node->kind().is_onnx() && node->kind() != prim::Undefined) {
+      bool is_aten_fallback = operator_export_type == onnx::OperatorExportTypes::ONNX_ATEN_FALLBACK;
+      if (!node->kind().is_onnx() && !is_aten_fallback && node->kind() != prim::Undefined) {
         FAIL_EXPORT(
             "Couldn't export operator " + node->kind().toDisplayString() + "\n\nDefined at:\n" +
             getNodeStackTraceString(node));
@@ -376,10 +379,10 @@ RawDataExportMap ToModelProto(
     const std::vector<at::Tensor> & initializers,
     int64_t onnx_opset_version,
     bool defer_weight_export,
-    bool export_raw_ir,
+    onnx::OperatorExportTypes operator_export_type,
     onnx::ModelProto *model_proto) {
-  if (!export_raw_ir) {
-    validateGraph(graph);
+  if (operator_export_type != onnx::OperatorExportTypes::RAW) {
+    validateGraph(graph, operator_export_type);
   }
 
   model_proto->set_producer_name("pytorch");
@@ -394,9 +397,9 @@ RawDataExportMap ToModelProto(
   // Set up nanopb callbacks and compute the amount of space needed to store
   // the resulting protobuf
   if (defer_weight_export) {
-    encodeModel(model_proto, graph, initializers, &raw_data_export_map, export_raw_ir);
+    encodeModel(model_proto, graph, initializers, &raw_data_export_map, operator_export_type);
   } else {
-    encodeModel(model_proto, graph, initializers, nullptr, export_raw_ir);
+    encodeModel(model_proto, graph, initializers, nullptr, operator_export_type);
   }
 
   return raw_data_export_map;
@@ -410,11 +413,12 @@ std::string PrettyPrintExportedGraph(
                         const std::vector<at::Tensor> & initializers,
                         int64_t onnx_opset_version,
                         bool defer_weight_export,
-                        bool export_raw_ir) {
+                        ::torch::onnx::OperatorExportTypes operator_export_type) {
   ::torch::onnx::ModelProto model_proto;
   RawDataExportMap raw_data_export_map;
   raw_data_export_map = ToModelProto(
-    graph, initializers, onnx_opset_version, defer_weight_export, export_raw_ir, &model_proto);
+    graph, initializers, onnx_opset_version, defer_weight_export, operator_export_type,
+    &model_proto);
   return model_proto.prettyPrint();
 }
 
@@ -428,11 +432,12 @@ std::tuple<std::string, RawDataExportMap> ExportGraph(
                         const std::vector<at::Tensor> & initializers,
                         int64_t onnx_opset_version,
                         bool defer_weight_export,
-                        bool export_raw_ir) {
+                        ::torch::onnx::OperatorExportTypes operator_export_type) {
   ::torch::onnx::ModelProto model_proto;
   RawDataExportMap raw_data_export_map;
   raw_data_export_map = ToModelProto(
-    graph, initializers, onnx_opset_version, defer_weight_export, export_raw_ir, &model_proto);
+    graph, initializers, onnx_opset_version, defer_weight_export, operator_export_type,
+    &model_proto);
 
   size_t out_size;
   pb_get_encoded_size(&out_size, onnx_ModelProto_fields, &model_proto.proto);
diff --git a/torch/csrc/jit/export.h b/torch/csrc/jit/export.h
index 96de79cbc3fb9..95758dc9aa392 100644
--- a/torch/csrc/jit/export.h
+++ b/torch/csrc/jit/export.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "torch/csrc/jit/ir.h"
+#include "torch/csrc/onnx/onnx.h"
 
 namespace torch { namespace jit {
 
@@ -19,7 +20,8 @@ std::tuple<std::string, RawDataExportMap> ExportGraph(
     const std::vector<at::Tensor>& initializers,
     int64_t onnx_opset_version,
     bool defer_weight_export = false,
-    bool export_raw_ir = false);
+    ::torch::onnx::OperatorExportTypes operator_export_type
+      = ::torch::onnx::OperatorExportTypes::ONNX);
 
 // For testing purposes
 std::string PrettyPrintExportedGraph(
@@ -27,6 +29,7 @@ std::string PrettyPrintExportedGraph(
     const std::vector<at::Tensor> & initializers,
     int64_t onnx_opset_version,
     bool defer_weight_export,
-    bool export_raw_ir);
+    ::torch::onnx::OperatorExportTypes operator_export_type
+      = ::torch::onnx::OperatorExportTypes::ONNX);
 
 }}
diff --git a/torch/csrc/jit/passes/onnx.cpp b/torch/csrc/jit/passes/onnx.cpp
index aad64f2b3fca1..6114a0fc4cece 100644
--- a/torch/csrc/jit/passes/onnx.cpp
+++ b/torch/csrc/jit/passes/onnx.cpp
@@ -24,15 +24,14 @@ bool hasUsedHandle(Node *node) {
 } // anonymous namespace
 
 // Transform PythonOps and Cpp Ops into Node's that match ONNX semantics.
-// Argument aten indicates whether we should export ops as "ATen" ONNX ops if possible.
-std::shared_ptr<Graph> ToONNX(std::shared_ptr<Graph>& graph, bool aten) {
+std::shared_ptr<Graph> ToONNX(std::shared_ptr<Graph>& graph, ::torch::onnx::OperatorExportTypes operator_export_type) {
   auto new_graph = std::make_shared<Graph>(graph->scope_root());
   std::unordered_map<Value*, Value*> env;
-  BlockToONNX(graph->block(), new_graph->block(), aten, env);
+  BlockToONNX(graph->block(), new_graph->block(), operator_export_type, env);
   return new_graph;
 }
 
-void BlockToONNX(Block* old_block, Block* new_block, bool aten, std::unordered_map<Value*, Value*> env) {
+void BlockToONNX(Block* old_block, Block* new_block, ::torch::onnx::OperatorExportTypes operator_export_type, std::unordered_map<Value*, Value*> env) {
   torch::autograd::SymbolicContext ctx;
   ctx.block = new_block;
 
@@ -144,7 +143,7 @@ void BlockToONNX(Block* old_block, Block* new_block, bool aten, std::unordered_m
 
     WithInsertPoint insert_point_guard(ctx.block);
     WithCurrentScope scope_guard(*ctx.block->owningGraph(), n->scope());
-    py::object raw_output = onnx.attr("_run_symbolic_function")(ctx.block->owningGraph(), n, py_inputs, env, aten);
+    py::object raw_output = onnx.attr("_run_symbolic_function")(ctx.block->owningGraph(), n, py_inputs, env, operator_export_type);
 
     // TODO: Assert it's an ATen identifier???
     // (Sometimes it's not...)
diff --git a/torch/csrc/jit/passes/onnx.h b/torch/csrc/jit/passes/onnx.h
index d85ebe4c18a16..bd6f6e4444fcc 100644
--- a/torch/csrc/jit/passes/onnx.h
+++ b/torch/csrc/jit/passes/onnx.h
@@ -2,10 +2,11 @@
 
 #include "torch/csrc/jit/ir.h"
 #include "torch/csrc/jit/tracer_state.h"
+#include "torch/csrc/onnx/onnx.h"
 
 namespace torch { namespace jit {
 
-std::shared_ptr<Graph> ToONNX(std::shared_ptr<Graph>& state, bool aten);
-void BlockToONNX(Block* old_block, Block* new_block, bool aten, std::unordered_map<Value*, Value*> env);
+std::shared_ptr<Graph> ToONNX(std::shared_ptr<Graph>& state, ::torch::onnx::OperatorExportTypes operator_export_type);
+void BlockToONNX(Block* old_block, Block* new_block, ::torch::onnx::OperatorExportTypes operator_export_type, std::unordered_map<Value*, Value*> env);
 
 }}
diff --git a/torch/csrc/jit/python_ir.cpp b/torch/csrc/jit/python_ir.cpp
index a42c2611fbfcf..b4df18e2ccaf7 100644
--- a/torch/csrc/jit/python_ir.cpp
+++ b/torch/csrc/jit/python_ir.cpp
@@ -148,11 +148,12 @@ void initPythonIRBindings(PyObject * module_) {
       PropagateInputShapes(g, ArgumentSpec(with_grad, variable_tensor_list(std::move(inputs))));
     })
     .def("export", [](const std::shared_ptr<Graph> g, const std::vector<at::Tensor>& initializers,
-                      int64_t onnx_opset_version, bool defer_weight_export, bool export_raw_ir) {
+                      int64_t onnx_opset_version, bool defer_weight_export,
+                      ::torch::onnx::OperatorExportTypes operator_export_type) {
       std::string graph;
       RawDataExportMap export_map;
       std::tie(graph, export_map) = ExportGraph(
-        g, initializers, onnx_opset_version, defer_weight_export, export_raw_ir);
+        g, initializers, onnx_opset_version, defer_weight_export, operator_export_type);
       std::unordered_map<std::string, py::bytes> python_serialized_export_map;
       for (auto& kv : export_map) {
         auto t = kv.second;
@@ -166,15 +167,16 @@ void initPythonIRBindings(PyObject * module_) {
     }, py::arg("initializers"),
        py::arg("onnx_opset_version")=0,
        py::arg("defer_weight_export")=false,
-       py::arg("export_raw_ir")=false )
+       py::arg("operator_export_type")=::torch::onnx::OperatorExportTypes::ONNX)
     .def("prettyPrintExport", [](const std::shared_ptr<Graph> g, const std::vector<at::Tensor>& initializers,
-                      int64_t onnx_opset_version, bool defer_weight_export, bool export_raw_ir) {
+                      int64_t onnx_opset_version, bool defer_weight_export,
+                      ::torch::onnx::OperatorExportTypes operator_export_type) {
       return PrettyPrintExportedGraph(
-        g, initializers, onnx_opset_version, defer_weight_export, export_raw_ir);
+        g, initializers, onnx_opset_version, defer_weight_export, operator_export_type);
     }, py::arg("initializers"),
        py::arg("onnx_opset_version")=0,
        py::arg("defer_weight_export")=false,
-       py::arg("export_raw_ir")=false )
+       py::arg("operator_export_type")=::torch::onnx::OperatorExportTypes::ONNX)
     .def("wrapPyFuncWithSymbolic", [](Graph &g, py::function func, std::vector<Value*> inputs, size_t n_outputs, py::function symbolic) {
       // This function should be used for situations where we have a Python function
       // that should have different behavior when exporting for JIT interpreter
diff --git a/torch/csrc/onnx/init.cpp b/torch/csrc/onnx/init.cpp
index e668fb56e18a0..e221ffbf7f263 100644
--- a/torch/csrc/onnx/init.cpp
+++ b/torch/csrc/onnx/init.cpp
@@ -24,6 +24,12 @@ void initONNXBindings(PyObject* module) {
       .value("COMPLEX64", onnx_TensorProto_DataType_COMPLEX64)
       .value("COMPLEX128", onnx_TensorProto_DataType_COMPLEX128);
 
+  py::enum_<OperatorExportTypes>(onnx, "OperatorExportTypes")
+    .value("ONNX", OperatorExportTypes::ONNX)
+    .value("ONNX_ATEN", OperatorExportTypes::ONNX_ATEN)
+    .value("ONNX_ATEN_FALLBACK", OperatorExportTypes::ONNX_ATEN_FALLBACK)
+    .value("RAW", OperatorExportTypes::RAW);
+
   py::class_<ModelProto>(onnx, "ModelProto")
       .def("prettyPrint", &ModelProto::prettyPrint);
 }
diff --git a/torch/csrc/onnx/onnx.h b/torch/csrc/onnx/onnx.h
index 4aa06fcf556f5..b5f3be6474e20 100644
--- a/torch/csrc/onnx/onnx.h
+++ b/torch/csrc/onnx/onnx.h
@@ -425,4 +425,11 @@ class ModelProto : public MicroProto<onnx_ModelProto> {
   }
 };
 
+enum class OperatorExportTypes {
+  ONNX, // Strict ONNX export
+  ONNX_ATEN, // ONNX With ATen op everywhere
+  ONNX_ATEN_FALLBACK, // ONNX export with ATen fallback
+  RAW, // Raw export (no ONNX)
+};
+
 }} // namespace torch::onnx
diff --git a/torch/onnx/__init__.py b/torch/onnx/__init__.py
index 95201c9e29745..1807b711a1cce 100644
--- a/torch/onnx/__init__.py
+++ b/torch/onnx/__init__.py
@@ -4,6 +4,7 @@
 import torch._C as _C
 
 TensorProtoDataType = _C._onnx.TensorProtoDataType
+OperatorExportTypes = _C._onnx.OperatorExportTypes
 
 ONNX_ARCHIVE_MODEL_PROTO_NAME = "__MODEL_PROTO"
 
@@ -20,19 +21,24 @@ def _export(*args, **kwargs):
     return utils._export(*args, **kwargs)
 
 
-def _export_to_pretty_string(*args, **kwargs):
+def export(*args, **kwargs):
     from torch.onnx import utils
-    return utils._export_to_pretty_string(*args, **kwargs)
+    return utils.export(*args, **kwargs)
 
 
-def export(*args, **kwargs):
+def export_to_pretty_string(*args, **kwargs):
     from torch.onnx import utils
-    return utils.export(*args, **kwargs)
+    return utils.export_to_pretty_string(*args, **kwargs)
+
+
+def _export_to_pretty_string(*args, **kwargs):
+    from torch.onnx import utils
+    return utils._export_to_pretty_string(*args, **kwargs)
 
 
-def _optimize_trace(trace, aten):
+def _optimize_trace(trace, operator_export_type):
     from torch.onnx import utils
-    trace.set_graph(utils._optimize_graph(trace.graph(), aten))
+    trace.set_graph(utils._optimize_graph(trace.graph(), operator_export_type))
 
 
 def set_training(*args, **kwargs):
diff --git a/torch/onnx/utils.py b/torch/onnx/utils.py
index 4bd4989a54b37..af8e5608c7891 100644
--- a/torch/onnx/utils.py
+++ b/torch/onnx/utils.py
@@ -18,7 +18,7 @@
 from torch._six import string_classes
 from torch.autograd import Function, function
 from torch.jit import _unique_state_dict
-from torch.onnx import ONNX_ARCHIVE_MODEL_PROTO_NAME, ExportTypes
+from torch.onnx import ONNX_ARCHIVE_MODEL_PROTO_NAME, ExportTypes, OperatorExportTypes
 
 
 @contextlib.contextmanager
@@ -42,7 +42,8 @@ def set_training(model, mode):
 
 
 def export(model, args, f, export_params=True, verbose=False, training=False,
-           input_names=None, output_names=None, aten=False, export_raw_ir=False):
+           input_names=None, output_names=None, aten=False, export_raw_ir=False,
+           operator_export_type=None):
     r"""
     Export a model into ONNX format.  This exporter runs your model
     once in order to get a trace of its execution to be exported;
@@ -77,17 +78,23 @@ def export(model, args, f, export_params=True, verbose=False, training=False,
             input nodes of the graph, in order
         output_names(list of strings, default empty list): names to assign to the
             output nodes of the graph, in order
-        aten (bool, default False): export the model in aten mode. If using aten mode,
-            all the ops original exported by the functions in symbolic.py are exported
-            as ATen ops.
-        export_raw_ir (bool, default False): export the internal IR directly instead
-            of converting it to ONNX ops.
+        aten (bool, default False): [DEPRECATED. use operator_export_type] export the
+            model in aten mode. If using aten mode, all the ops original exported
+            by the functions in symbolic.py are exported as ATen ops.
+        export_raw_ir (bool, default False): [DEPRECATED. use operator_export_type]
+            export the internal IR directly instead of converting it to ONNX ops.
     """
+    if aten or export_raw_ir:
+        assert operator_export_type is None
+        assert aten ^ export_raw_ir
+        operator_export_type = OperatorExportTypes.ATEN if aten else OperatorExportTypes.RAW
+    elif operator_export_type is None:
+        operator_export_type = OperatorExportTypes.ONNX
     _export(model, args, f, export_params, verbose, training, input_names, output_names,
-            aten, export_raw_ir=export_raw_ir)
+            operator_export_type=operator_export_type)
 
 
-def _optimize_graph(graph, aten, export_raw_ir=False):
+def _optimize_graph(graph, operator_export_type):
     # run dce first to eliminate dead parts of the graph that might have been
     # left behind by things like symbolic_override
 
@@ -96,8 +103,8 @@ def _optimize_graph(graph, aten, export_raw_ir=False):
 
     torch._C._jit_pass_peephole(graph)
     torch._C._jit_pass_lint(graph)
-    if not export_raw_ir:
-        graph = torch._C._jit_pass_onnx(graph, aten)
+    if operator_export_type != OperatorExportTypes.RAW:
+        graph = torch._C._jit_pass_onnx(graph, operator_export_type)
         torch._C._jit_pass_lint(graph)
         torch._C._jit_pass_onnx_peephole(graph)
         torch._C._jit_pass_lint(graph)
@@ -110,13 +117,13 @@ def _optimize_graph(graph, aten, export_raw_ir=False):
     return graph
 
 
-def _trace(func, args, return_outs=False, aten=False):
+def _trace(func, args, operator_export_type, return_outs=False):
     # Special case for common case of passing a single Tensor
     if isinstance(args, torch.Tensor):
         args = (args, )
 
     trace, torch_out = torch.jit.get_trace_graph(func, args)
-    trace.set_graph(_optimize_graph(trace.graph(), aten))
+    trace.set_graph(_optimize_graph(trace.graph(), operator_export_type))
     if return_outs:
         return trace, torch_out
     return trace
@@ -144,8 +151,9 @@ def _trace_and_get_graph_from_model(model, args, training):
 
 
 def _model_to_graph(model, args, f, verbose=False, training=False,
-                    input_names=None, output_names=None, aten=False,
-                    export_raw_ir=False, example_outputs=None, propagate=False):
+                    input_names=None, output_names=None,
+                    operator_export_type=OperatorExportTypes.ONNX,
+                    example_outputs=None, propagate=False):
     # Special case for common case of passing a single Variable
     if isinstance(args, torch.Tensor):
         args = (args, )
@@ -167,7 +175,7 @@ def _model_to_graph(model, args, f, verbose=False, training=False,
         graph, torch_out = _trace_and_get_graph_from_model(model, args, training)
         params = list(_unique_state_dict(model).values())
 
-    graph = _optimize_graph(graph, aten, export_raw_ir)
+    graph = _optimize_graph(graph, operator_export_type)
 
     _set_input_and_output_names(graph, input_names, output_names)
     if verbose:
@@ -176,16 +184,31 @@ def _model_to_graph(model, args, f, verbose=False, training=False,
     return graph, params, torch_out
 
 
+def export_to_pretty_string(model, args, f, export_params=True, verbose=False, training=False,
+                            input_names=None, output_names=None, aten=False, export_raw_ir=False,
+                            operator_export_type=None, export_type=ExportTypes.PROTOBUF_FILE,
+                            example_outputs=None, propagate=False):
+    if aten or export_raw_ir:
+        assert operator_export_type is None
+        assert aten ^ export_raw_ir
+        operator_export_type = OperatorExportTypes.ATEN if aten else OperatorExportTypes.RAW
+    elif operator_export_type is None:
+        operator_export_type = OperatorExportTypes.ONNX
+    return _export_to_pretty_string(model, args, f, export_params, verbose, training,
+                                    input_names, output_names, operator_export_type,
+                                    export_type, example_outputs, propagate)
+
+
 def _export_to_pretty_string(model, args, f, export_params=True, verbose=False, training=False,
-                             input_names=None, output_names=None, aten=False, export_raw_ir=False,
+                             input_names=None, output_names=None, operator_export_type=OperatorExportTypes.ONNX,
                              export_type=ExportTypes.PROTOBUF_FILE, example_outputs=None, propagate=False):
     graph, params, torch_out = _model_to_graph(model, args, f, verbose,
                                                training, input_names,
-                                               output_names, aten, export_raw_ir,
+                                               output_names, operator_export_type,
                                                example_outputs, propagate)
 
     from torch.onnx.symbolic import _onnx_opset_version
-    return graph.prettyPrintExport(params, _onnx_opset_version, False, export_raw_ir)
+    return graph.prettyPrintExport(params, _onnx_opset_version, False, operator_export_type)
 
 
 # NOTE: the output `torch_out` will contain the output tensors resulting from
@@ -193,20 +216,20 @@ def _export_to_pretty_string(model, args, f, export_params=True, verbose=False,
 # this output will be None, since we are not doing any tracing but rather
 # directly extracting the graph.
 def _export(model, args, f, export_params=True, verbose=False, training=False,
-            input_names=None, output_names=None, aten=False, export_raw_ir=False,
+            input_names=None, output_names=None, operator_export_type=OperatorExportTypes.ONNX,
             export_type=ExportTypes.PROTOBUF_FILE, example_outputs=None, propagate=False):
     graph, params, torch_out = _model_to_graph(model, args, f, verbose,
                                                training, input_names,
-                                               output_names, aten, export_raw_ir,
+                                               output_names, operator_export_type,
                                                example_outputs, propagate)
 
     # TODO: Don't allocate a in-memory string for the protobuf
     from torch.onnx.symbolic import _onnx_opset_version
     defer_weight_export = export_type is not ExportTypes.PROTOBUF_FILE
     if export_params:
-        proto, export_map = graph.export(params, _onnx_opset_version, defer_weight_export, export_raw_ir)
+        proto, export_map = graph.export(params, _onnx_opset_version, defer_weight_export, operator_export_type)
     else:
-        proto, export_map = graph.export([], _onnx_opset_version, False, export_raw_ir)
+        proto, export_map = graph.export([], _onnx_opset_version, False, operator_export_type)
 
     if export_type == ExportTypes.PROTOBUF_FILE:
         assert(len(export_map) == 0)
@@ -384,7 +407,7 @@ def const_if_tensor(arg):
 # inplace annotations, but we are losing information this way.
 
 
-def _run_symbolic_function(g, n, inputs, env, aten=False):
+def _run_symbolic_function(g, n, inputs, env, operator_export_type=OperatorExportTypes.ONNX):
     # NB: Returning None means the node gets cloned as is into
     # the new graph
     try:
@@ -403,7 +426,10 @@ def _run_symbolic_function(g, n, inputs, env, aten=False):
             return None
 
         elif ns == "aten":
-            if aten:
+            is_exportable_aten_op = hasattr(torch.onnx.symbolic, op_name)
+            is_onnx_aten_export = operator_export_type == OperatorExportTypes.ONNX_ATEN
+            is_aten_fallback_export = operator_export_type == OperatorExportTypes.ONNX_ATEN_FALLBACK
+            if is_onnx_aten_export or (not is_exportable_aten_op and is_aten_fallback_export):
                 # Direct ATen export requested
                 attrs = {k + "_" + n.kindOf(k)[0]: n[k] for k in n.attributeNames()}
                 outputs = n.outputsSize()
@@ -413,7 +439,7 @@ def _run_symbolic_function(g, n, inputs, env, aten=False):
             else:
                 # Export it regularly
                 attrs = {k: n[k] for k in n.attributeNames()}
-                if not hasattr(torch.onnx.symbolic, op_name):
+                if not is_exportable_aten_op:
                     warnings.warn("ONNX export failed on ATen operator {} because torch.onnx.symbolic.{} does not exist"
                                   .format(op_name, op_name))
                     return None
@@ -433,7 +459,7 @@ def _run_symbolic_function(g, n, inputs, env, aten=False):
                 new_node = new_op_outputs[0].node() if n.outputsSize() > 1 else new_op_outputs.node()
                 for b in n.blocks():
                     new_block = new_node.addBlock()
-                    torch._C._jit_pass_onnx_block(b, new_block, aten, env)
+                    torch._C._jit_pass_onnx_block(b, new_block, operator_export_type, env)
                 return new_op_outputs
             else:
                 warnings.warn("ONNX export failed on primitive operator {}; please report a bug".format(op_name))

From 9f73a68a556bd43042f9ae566bc64dc3657189ac Mon Sep 17 00:00:00 2001
From: Peter Goldsborough <peter@goldsborough.me>
Date: Tue, 12 Jun 2018 23:17:19 -0700
Subject: [PATCH 108/118] Remove imaginary file (#8415)

---
 caffe2/utils/CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/caffe2/utils/CMakeLists.txt b/caffe2/utils/CMakeLists.txt
index 5e7801c1f653c..d774caceb4e19 100644
--- a/caffe2/utils/CMakeLists.txt
+++ b/caffe2/utils/CMakeLists.txt
@@ -5,7 +5,6 @@ set(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS}
         utils/signal_handler.cc
         utils/string_utils.cc
         utils/threadpool/ThreadPool.cc
-        utils/thread_name.cc
         utils/cpuid.cc
         utils/bench_utils.cc
         utils/math_cpu.cc

From 262de7007c6977c5c3c21fa035812d7c2fea35bf Mon Sep 17 00:00:00 2001
From: Peter Yeh <petrex@users.noreply.github.com>
Date: Wed, 13 Jun 2018 04:00:39 -0700
Subject: [PATCH 109/118] [Caffe2] Enable AMD/MIOPEN ops for Caffe2  (#8306)

* Add hip support for caffe2 core

* Add MIOPEN header/wrapper to caffe2 core

* Add HIP device into caffe2 PB

* top level makefile change for rocm/hip

* makefile scaffolding for AMD/RocM/HIP

* Makefile scafodding for AMD/RocM/HIP; add makefile/utility for HIP files

* caffe2 PB update for AMD/ROCM HIP device

* Add AMD/RocM/Thrust dependency

* HIP threadpool update

* Fix makefile macro

* makefile fix: duplicate test/binary name

* makefile clean-up

* makefile clean-up

* add HIP operator registry

* add utilities for hip device

* Add USE_HIP to config summary

* makefile fix for BUILD_TEST

* merge latest

* Fix indentation

* code clean-up

* Guard builds without HIP and use the same cmake script as PyTorch to find HIP

* Setup rocm environment variables in build.sh (ideally should be done in the docker images)

* setup locale

* set HIP_PLATFORM

* Revert "set HIP_PLATFORM"

This reverts commit 8ec58db2b390c9259220c49fa34cd403568300ad.

* continue the build script environment variables mess

* HCC_AMDGPU_TARGET

* Cleanup the mess, has been fixed in the lastest docker images

* Assign protobuf field hip_gpu_id a new field number for backward compatibility

* change name to avoid conflict

* Fix duplicated thread pool flag

* Refactor cmake files to not add hip includes and libs globally

* Fix the wrong usage of environment variables detection in cmake

* Add MIOPEN CNN operators

* Revert "Add MIOPEN CNN operators"

This reverts commit 6e89ad4385b5b8967a7854c4adda52c012cee42a.

* Add MIOPEN pooling operator

* Add MIOPEN activation operator

* Add MIOPEN softmax operator

* Add MIOPEN spatial batch norm operator

* Add MIOPEN loacl response normalization operator

* Add MIOPEN conv operator

* Clean-up LRN ops

* enable fp16 in MIOPEN pool ops

* Enable fp16 for MIOPEN relu op

* Enable fp16 for MIOPEN spatial batch norm op

* code clean-up

* revert float16 support

* Create Caffe2 python binding for AMD/ROCM/HIP

* Add op fallback for HIP operator

* add hip src/test files in cmake

* exclude hip src/test files

* fix python binding for hip backend

* fix MIOPEN pooling op workspace

* hack to compile miopen operators

* fix include path for MIOPEN ops

* Fix include path

* Add HIP math utilities

* Fix path for HIP math utils

* cmake fix

* Cmake fix / hipcc for hip files

* suppress hipcc warning

* cmake fix /replcae USE_HIP with USE_ROCM

* revert LoadHIP.cmake change

* fix include for thrust/cub-hip

* include path fix for conversion.h

* Updated with latest upstream changes

* clang format fixes

* Context_hip updates

* Fixed typo in rocblas handle get function

* Updated hipified math utils

* Updated math hip test util

* Updated context hip test

* Updated common_hip

* Updated net async dag for HIP

* Added MIOPEN in operator hip test

* fix

* C2 dependencies clean-up

* fix include path for building custom protobuf

* Decouple miopen pool op and conv_pool_op base

* cmake refactor

* fix operator_hip_test

* move all hip/miopen ops files into caffe2/operators/hip

* sanitize cmake

* permission issue

* remove extra parenthesis

* remove artifact from resolving merge conflict

* cont. sanitize cmake files

* fix syntax error

* sanitize conversion.h

* .

* Revert "."

This reverts commit 56020cb0e996a31ae27bf1f8f491955ed0b121b9.

* clang-format
---
 .jenkins/caffe2/build.sh                      |    8 +
 caffe2/CMakeLists.txt                         |   64 +-
 caffe2/core/hip/common_hip.cc                 |    4 +-
 caffe2/core/hip/common_hip.h                  |  299 +-
 caffe2/core/hip/context_hip.cc                |   27 +-
 caffe2/core/hip/context_hip.h                 |  525 +--
 caffe2/core/hip/context_hip_test.cc           |   13 +-
 caffe2/core/hip/net_async_dag_hip.cc          |   11 +-
 caffe2/core/hip/operator_hip_test.cc          |   18 +
 caffe2/operators/CMakeLists.txt               |   23 +-
 caffe2/operators/hip/conv_op_miopen.cc        |  859 +++++
 .../local_response_normalization_op_miopen.cc |  248 ++
 caffe2/operators/hip/operator_fallback_hip.h  |  114 +
 .../hip/operator_fallback_hip_test.cc         |   80 +
 caffe2/operators/hip/pool_op_miopen.cc        |  310 ++
 caffe2/operators/hip/relu_op_miopen.cc        |  205 +
 caffe2/operators/hip/softmax_op_miopen.cc     |  138 +
 .../hip/spatial_batch_norm_op_miopen.cc       |  318 ++
 caffe2/python/CMakeLists.txt                  |   10 +
 caffe2/python/pybind_state_hip.cc             |   91 +
 caffe2/utils/CMakeLists.txt                   |   33 +-
 caffe2/utils/conversions.h                    |   15 +-
 caffe2/utils/math_blas_hip_test.cc            |  391 ++
 caffe2/utils/math_hip.cc                      | 3319 +++++++++++++++++
 caffe2/utils/math_hip_test.cc                 |  898 +++++
 caffe2/utils/mixed_utils_hip.h                |  101 +
 cmake/Dependencies.cmake                      |   18 +-
 cmake/public/LoadHIP.cmake                    |    6 +-
 28 files changed, 7752 insertions(+), 394 deletions(-)
 create mode 100644 caffe2/operators/hip/conv_op_miopen.cc
 create mode 100644 caffe2/operators/hip/local_response_normalization_op_miopen.cc
 create mode 100644 caffe2/operators/hip/operator_fallback_hip.h
 create mode 100644 caffe2/operators/hip/operator_fallback_hip_test.cc
 create mode 100644 caffe2/operators/hip/pool_op_miopen.cc
 create mode 100644 caffe2/operators/hip/relu_op_miopen.cc
 create mode 100644 caffe2/operators/hip/softmax_op_miopen.cc
 create mode 100644 caffe2/operators/hip/spatial_batch_norm_op_miopen.cc
 create mode 100644 caffe2/python/pybind_state_hip.cc
 create mode 100644 caffe2/utils/math_blas_hip_test.cc
 create mode 100644 caffe2/utils/math_hip.cc
 create mode 100644 caffe2/utils/math_hip_test.cc
 create mode 100644 caffe2/utils/mixed_utils_hip.h

diff --git a/.jenkins/caffe2/build.sh b/.jenkins/caffe2/build.sh
index fb44d4be6ad46..9bb4cc3199404 100755
--- a/.jenkins/caffe2/build.sh
+++ b/.jenkins/caffe2/build.sh
@@ -149,6 +149,14 @@ if [[ $BUILD_ENVIRONMENT == *cuda* ]]; then
   export PATH="/usr/local/cuda/bin:$PATH"
 fi
 if [[ $BUILD_ENVIRONMENT == *rocm* ]]; then
+  # TODO: This is patching the official FindHip to properly handly
+  # cmake generator expression. A PR is opened in the upstream repo here:
+  # https://github.com/ROCm-Developer-Tools/HIP/pull/516
+  # remove this hack once it's merged.
+  if [[ -f /opt/rocm/hip/cmake/FindHIP.cmake ]]; then
+    sudo sed -i 's/\ -I${dir}/\ $<$<BOOL:${dir}>:-I${dir}>/' /opt/rocm/hip/cmake/FindHIP.cmake
+  fi
+
   export LANG=C.UTF-8
   export LC_ALL=C.UTF-8
   export HCC_AMDGPU_TARGET=gfx900
diff --git a/caffe2/CMakeLists.txt b/caffe2/CMakeLists.txt
index a34aa8f1cecbc..fa224bb2bab54 100644
--- a/caffe2/CMakeLists.txt
+++ b/caffe2/CMakeLists.txt
@@ -251,32 +251,16 @@ endif()
 
 # ---[ Caffe2 HIP sources.
 if(USE_ROCM)
-  HIP_INCLUDE_DIRECTORIES(${Caffe2_HIP_INCLUDES})
+  set_source_files_properties(${Caffe2_HIP_SRCS} PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
+  hip_add_library(caffe2_hip ${Caffe2_HIP_SRCS})
 
-  IF(BUILD_ATEN)
-    # Set necessary HIPCC Flags
-    SET(HIP_HCC_FLAGS "-fPIC -DCUDA_HAS_FP16=1 -D__HIP_NO_HALF_OPERATORS__=1 -D__HIP_NO_HALF_CONVERSIONS__=1 -D__HIP_PLATFORM_HCC__=1 ${HIP_HCC_FLAGS}")
-    SET(Caffe2_HIP_CXX_FLAGS "-fPIC -DCUDA_HAS_FP16=1 -D__HIP_NO_HALF_OPERATORS__=1 -D__HIP_NO_HALF_CONVERSIONS__=1 -D__HIP_PLATFORM_HCC__=1 ${Caffe2_HIP_CXX_FLAGS}")
-  ENDIF()
-
-  # Since the HIP_ADD_LIBRARY is a MACRO, we need to set HIP_HCC_FLAGS prior to calling it.
-  # Also, Since HIP_INCLUDE_DIRECTORIES is a MACRO, we must call it before HIP_ADD_LIBRARY.
-  HIP_ADD_LIBRARY(caffe2_hip ${Caffe2_HIP_SRCS})
-
-  set_target_properties(caffe2_hip PROPERTIES COMPILE_FLAGS ${Caffe2_HIP_CXX_FLAGS})
-
-  target_include_directories(
-    caffe2_hip PRIVATE ${Caffe2_HIP_INCLUDES})
-  target_include_directories(
-    caffe2_hip INTERFACE $<INSTALL_INTERFACE:include>)
+  target_link_libraries(caffe2_hip PUBLIC caffe2)
+  target_link_libraries(caffe2_hip PUBLIC ${Caffe2_HIP_DEPENDENCY_LIBS})
 
   IF(BUILD_ATEN)
     aten_set_target_props(caffe2_hip)
   ENDIF()
 
-  target_link_libraries(caffe2_hip PUBLIC caffe2)
-  target_link_libraries(caffe2_hip PUBLIC ${Caffe2_HIP_DEPENDENCY_LIBS})
-
   # https://github.com/ROCm-Developer-Tools/HIP/blob/master/docs/markdown/hip_faq.md#what-if-hip-generates-error-of-symbol-multiply-defined-only-on-amd-machine
   # To avoid having to do above, keep this commented.
   set_target_properties(caffe2_hip PROPERTIES LINKER_LANGUAGE HIP)
@@ -301,9 +285,6 @@ if(BUILD_CAFFE2)
     if (USE_CUDA)
       list(APPEND Caffe2_ALL_TEST_SRCS ${Caffe2_GPU_TEST_SRCS})
     endif()
-    if(USE_ROCM)
-      list(APPEND Caffe2_ALL_TEST_SRCS ${Caffe2_HIP_TEST_SRCS})
-    endif()
 
     foreach(test_src ${Caffe2_ALL_TEST_SRCS})
       get_filename_component(test_name ${test_src} NAME_WE)
@@ -320,12 +301,17 @@ if(BUILD_CAFFE2)
 
     if(USE_ROCM)
       foreach(test_src ${Caffe2_HIP_TEST_SRCS})
+        set_source_files_properties(${test_src} PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
         get_filename_component(test_name ${test_src} NAME_WE)
-        set_target_properties(${test_name} PROPERTIES COMPILE_FLAGS ${Caffe2_HIP_CXX_FLAGS})
-        set_target_properties(${test_name} PROPERTIES LINKER_LANGUAGE HIP)
+        hip_add_executable(${test_name} "${test_src}")
+        target_link_libraries(${test_name} ${Caffe2_MAIN_LIBS} gtest_main)
         if (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 3.0)
           target_compile_features(${test_name} PRIVATE cxx_range_for)
         endif()
+        add_test(NAME ${test_name} COMMAND $<TARGET_FILE:${test_name}>)
+        if (INSTALL_TEST)
+          install(TARGETS ${test_name} DESTINATION test)
+        endif()
       endforeach()
     endif()
 
@@ -427,6 +413,26 @@ if(BUILD_CAFFE2)
       install(TARGETS caffe2_pybind11_state_gpu DESTINATION "${PYTHON_LIB_REL_PATH}/caffe2/python")
     endif()
 
+    if(USE_ROCM)
+      set_source_files_properties(${Caffe2_HIP_PYTHON_SRCS} PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
+      hip_add_library(caffe2_pybind11_state_hip MODULE ${Caffe2_HIP_PYTHON_SRCS})
+      set_target_properties(caffe2_pybind11_state_hip PROPERTIES COMPILE_FLAGS "-fvisibility=hidden")
+      set_target_properties(caffe2_pybind11_state_hip PROPERTIES PREFIX "")
+      set_target_properties(caffe2_pybind11_state_hip PROPERTIES SUFFIX ${PY_EXT_SUFFIX})
+      if (APPLE)
+        set_target_properties(caffe2_pybind11_state_hip PROPERTIES LINK_FLAGS "-undefined dynamic_lookup")
+      endif()
+      set_target_properties(
+          caffe2_pybind11_state_hip PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+          ${CMAKE_BINARY_DIR}/caffe2/python)
+      target_link_libraries(
+          caffe2_pybind11_state_hip caffe2_library caffe2_hip_library)
+      if (WIN32)
+        target_link_libraries(caffe2_pybind11_state_hip ${PYTHON_LIBRARIES})
+      endif(WIN32)
+      install(TARGETS caffe2_pybind11_state_hip DESTINATION "${PYTHON_LIB_REL_PATH}/caffe2/python")
+    endif()
+
     if (MSVC AND CMAKE_GENERATOR MATCHES "Visual Studio")
       # If we are building under windows, we will copy the file from
       # build/caffe2/python/{Debug,Release}/caffe2_pybind11_state.pyd
@@ -446,6 +452,14 @@ if(BUILD_CAFFE2)
             $<TARGET_FILE:caffe2_pybind11_state_gpu>
             ${CMAKE_BINARY_DIR}/caffe2/python)
       endif()
+      if (USE_ROCM)
+        add_dependencies(windows_python_copy_lib caffe2_pybind11_state_hip)
+        add_custom_command(
+            TARGET windows_python_copy_lib POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy
+            $<TARGET_FILE:caffe2_pybind11_state_hip>
+            ${CMAKE_BINARY_DIR}/caffe2/python)
+      endif()
     endif()
 
     # Finally, Copy all python files to build directory
diff --git a/caffe2/core/hip/common_hip.cc b/caffe2/core/hip/common_hip.cc
index 981dc9ec07cde..d94dba745ec44 100644
--- a/caffe2/core/hip/common_hip.cc
+++ b/caffe2/core/hip/common_hip.cc
@@ -299,7 +299,9 @@ namespace {
 class HipRuntimeFlagFlipper
 {
     public:
-    HipRuntimeFlagFlipper() { g_caffe2_has_hip_linked = true; }
+     HipRuntimeFlagFlipper() {
+       internal::SetHipRuntimeFlag();
+     }
 };
 static HipRuntimeFlagFlipper g_flipper;
 } // namespace
diff --git a/caffe2/core/hip/common_hip.h b/caffe2/core/hip/common_hip.h
index d32bfdbbf280d..5423f5b3d147d 100644
--- a/caffe2/core/hip/common_hip.h
+++ b/caffe2/core/hip/common_hip.h
@@ -3,14 +3,14 @@
 
 #define HIP_VERSION 1
 #include <assert.h>
-#include <hip/hip_runtime_api.h>
-#include <hip/hip_runtime.h>
 #include <hip/hip_fp16.h>
+#include <hip/hip_runtime.h>
+#include <hip/hip_runtime_api.h>
 #include <hiprand.h>
 #include <rocblas.h>
 
-#include "caffe2/core/logging.h"
 #include "caffe2/core/common.h"
+#include "caffe2/core/logging.h"
 
 /**
  * The maximum number of AMD HIP GPUs that caffe2 recognizes.
@@ -117,69 +117,73 @@ const char* hiprandGetErrorString(hiprandStatus_t error);
 const char* rocblasGetErrorString(rocblas_status error);
 
 // HIP: various checks for different function calls.
-#define HIP_ENFORCE(condition, ...)                \
-    do                                             \
-    {                                              \
-        hipError_t error = condition;              \
-        CAFFE_ENFORCE_EQ(error,                    \
-                         hipSuccess,               \
-                         "Error at: ",             \
-                         __FILE__,                 \
-                         ":",                      \
-                         __LINE__,                 \
-                         ": ",                     \
-                         hipGetErrorString(error), \
-                         ##__VA_ARGS__);           \
-    } while(0)
-#define HIP_CHECK(condition)                                    \
-    do                                                          \
-    {                                                           \
-        hipError_t error = condition;                           \
-        CHECK(error == hipSuccess) << hipGetErrorString(error); \
-    } while(0)
-
-#define ROCBLAS_ENFORCE(condition)                                 \
-    do                                                             \
-    {                                                              \
-        rocblas_status status = condition;                         \
-        CAFFE_ENFORCE_EQ(status,                                   \
-                         rocblas_status_success,                   \
-                         "Error at: ",                             \
-                         __FILE__,                                 \
-                         ":",                                      \
-                         __LINE__,                                 \
-                         ": ",                                     \
-                         ::caffe2::rocblasGetErrorString(status)); \
-    } while(0)
-
-#define ROCBLAS_CHECK(condition)                                                            \
-    do                                                                                      \
-    {                                                                                       \
-        rocblas_status status = condition;                                                  \
-        CHECK(status == rocblas_status_success) << ::caffe2::rocblasGetErrorString(status); \
-    } while(0)
-
-#define HIPRAND_ENFORCE(condition)                                 \
-    do                                                             \
-    {                                                              \
-        hiprandStatus_t status = condition;                        \
-        CAFFE_ENFORCE_EQ(status,                                   \
-                         HIPRAND_STATUS_SUCCESS,                   \
-                         "Error at: ",                             \
-                         __FILE__,                                 \
-                         ":",                                      \
-                         __LINE__,                                 \
-                         ": ",                                     \
-                         ::caffe2::hiprandGetErrorString(status)); \
-    } while(0)
-
-#define HIP_1D_KERNEL_LOOP(i, n)                                            \
-    for(size_t i = hipBlockIdx_x * hipBlockDim_x + hipThreadIdx_x; i < (n); \
-        i += hipBlockDim_x * hipGridDim_x)
-
-// CUDA_KERNEL_ASSERT is a macro that wraps an assert() call inside cuda
-// kernels. This is not supported by Apple platforms so we special case it.
-// See http://docs.nvidia.com/cuda/cuda-c-programming-guide/#assertion
+#define HIP_ENFORCE(condition, ...) \
+  do {                              \
+    hipError_t error = condition;   \
+    CAFFE_ENFORCE_EQ(               \
+        error,                      \
+        hipSuccess,                 \
+        "Error at: ",               \
+        __FILE__,                   \
+        ":",                        \
+        __LINE__,                   \
+        ": ",                       \
+        hipGetErrorString(error),   \
+        ##__VA_ARGS__);             \
+  } while (0)
+#define HIP_CHECK(condition)                                \
+  do {                                                      \
+    hipError_t error = condition;                           \
+    CHECK(error == hipSuccess) << hipGetErrorString(error); \
+  } while (0)
+
+#define ROCBLAS_ENFORCE(condition)                \
+  do {                                            \
+    rocblas_status status = condition;            \
+    CAFFE_ENFORCE_EQ(                             \
+        status,                                   \
+        rocblas_status_success,                   \
+        "Error at: ",                             \
+        __FILE__,                                 \
+        ":",                                      \
+        __LINE__,                                 \
+        ": ",                                     \
+        ::caffe2::rocblasGetErrorString(status)); \
+  } while (0)
+
+#define ROCBLAS_CHECK(condition)                    \
+  do {                                              \
+    rocblas_status status = condition;              \
+    CHECK(status == rocblas_status_success)         \
+        << ::caffe2::rocblasGetErrorString(status); \
+  } while (0)
+
+#define HIPRAND_ENFORCE(condition)                \
+  do {                                            \
+    hiprandStatus_t status = condition;           \
+    CAFFE_ENFORCE_EQ(                             \
+        status,                                   \
+        HIPRAND_STATUS_SUCCESS,                   \
+        "Error at: ",                             \
+        __FILE__,                                 \
+        ":",                                      \
+        __LINE__,                                 \
+        ": ",                                     \
+        ::caffe2::hiprandGetErrorString(status)); \
+  } while (0)
+#define HIPRAND_CHECK(condition)                    \
+  do {                                              \
+    hiprandStatus_t status = condition;             \
+    CHECK(status == HIPRAND_STATUS_SUCCESS)         \
+        << ::caffe2::hiprandGetErrorString(status); \
+  } while (0)
+
+#define HIP_1D_KERNEL_LOOP(i, n)                                           \
+  for (size_t i = hipBlockIdx_x * hipBlockDim_x + hipThreadIdx_x; i < (n); \
+       i += hipBlockDim_x * hipGridDim_x)
+
+// HIP_KERNEL_ASSERT is a macro that wraps an assert() call inside cuda
+// kernels.
 #define HIP_KERNEL_ASSERT(...)
 
 // The following helper functions are here so that you can write a kernel call
@@ -190,10 +194,8 @@ const char* rocblasGetErrorString(rocblas_status error);
 // A legacy note: this is derived from the old good Caffe days, when I simply
 // hard-coded the number of threads and wanted to keep backward compatibility
 // for different computation capabilities.
-// For more info on CUDA compute capabilities, visit the NVidia website at:
-//    http://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#compute-capabilities
 
-// The number of cuda threads to use. 512 is used for backward compatibility,
+// The number of HIP threads to use. 512 is used for backward compatibility,
 // and it is observed that setting it to 1024 usually does not bring much
 // performance gain (which makes sense, because warp size being 32 means that
 // blindly setting a huge block for a random kernel isn't optimal).
@@ -208,28 +210,155 @@ constexpr int CAFFE_MAXIMUM_NUM_BLOCKS = 4096;
 /**
  * @brief Compute the number of blocks needed to run N threads.
  */
-inline int CAFFE_GET_BLOCKS(const int N)
-{
-    return std::min((N + CAFFE_HIP_NUM_THREADS - 1) / CAFFE_HIP_NUM_THREADS,
-                    CAFFE_MAXIMUM_NUM_BLOCKS);
+inline int CAFFE_GET_BLOCKS(const int N) {
+  return std::min(
+      (N + CAFFE_HIP_NUM_THREADS - 1) / CAFFE_HIP_NUM_THREADS,
+      CAFFE_MAXIMUM_NUM_BLOCKS);
 }
 
-class DeviceGuard
-{
-    public:
-    explicit DeviceGuard(int newDevice) : previous_(CaffeHipGetDevice())
-    {
-        if(previous_ != newDevice)
-        {
-            CaffeHipSetDevice(newDevice);
-        }
+class DeviceGuard {
+ public:
+  explicit DeviceGuard(int newDevice) : previous_(CaffeHipGetDevice()) {
+    if (previous_ != newDevice) {
+      CaffeHipSetDevice(newDevice);
     }
+  }
 
-    ~DeviceGuard() noexcept { CaffeHipSetDevice(previous_); }
+  ~DeviceGuard() noexcept {
+    CaffeHipSetDevice(previous_);
+  }
 
-    private:
-    int previous_;
+ private:
+  int previous_;
 };
 
+template <typename T, int N>
+struct SimpleArray {
+  T data[N];
+};
+
+constexpr int kHIPTensorMaxDims = 8;
+
+#define DISPATCH_FUNCTION_BY_VALUE_WITH_TYPE_1(val, Func, T, ...) \
+  do {                                                            \
+    CAFFE_ENFORCE_LE(val, kHIPTensorMaxDims);                     \
+    switch (val) {                                                \
+      case 1: {                                                   \
+        Func<T, 1>(__VA_ARGS__);                                  \
+        break;                                                    \
+      }                                                           \
+      case 2: {                                                   \
+        Func<T, 2>(__VA_ARGS__);                                  \
+        break;                                                    \
+      }                                                           \
+      case 3: {                                                   \
+        Func<T, 3>(__VA_ARGS__);                                  \
+        break;                                                    \
+      }                                                           \
+      case 4: {                                                   \
+        Func<T, 4>(__VA_ARGS__);                                  \
+        break;                                                    \
+      }                                                           \
+      case 5: {                                                   \
+        Func<T, 5>(__VA_ARGS__);                                  \
+        break;                                                    \
+      }                                                           \
+      case 6: {                                                   \
+        Func<T, 6>(__VA_ARGS__);                                  \
+        break;                                                    \
+      }                                                           \
+      case 7: {                                                   \
+        Func<T, 7>(__VA_ARGS__);                                  \
+        break;                                                    \
+      }                                                           \
+      case 8: {                                                   \
+        Func<T, 8>(__VA_ARGS__);                                  \
+        break;                                                    \
+      }                                                           \
+      default: { break; }                                         \
+    }                                                             \
+  } while (false)
+
+#define DISPATCH_FUNCTION_BY_VALUE_WITH_TYPE_2(val, Func, T1, T2, ...) \
+  do {                                                                 \
+    CAFFE_ENFORCE_LE(val, kHIPTensorMaxDims);                          \
+    switch (val) {                                                     \
+      case 1: {                                                        \
+        Func<T1, T2, 1>(__VA_ARGS__);                                  \
+        break;                                                         \
+      }                                                                \
+      case 2: {                                                        \
+        Func<T1, T2, 2>(__VA_ARGS__);                                  \
+        break;                                                         \
+      }                                                                \
+      case 3: {                                                        \
+        Func<T1, T2, 3>(__VA_ARGS__);                                  \
+        break;                                                         \
+      }                                                                \
+      case 4: {                                                        \
+        Func<T1, T2, 4>(__VA_ARGS__);                                  \
+        break;                                                         \
+      }                                                                \
+      case 5: {                                                        \
+        Func<T1, T2, 5>(__VA_ARGS__);                                  \
+        break;                                                         \
+      }                                                                \
+      case 6: {                                                        \
+        Func<T1, T2, 6>(__VA_ARGS__);                                  \
+        break;                                                         \
+      }                                                                \
+      case 7: {                                                        \
+        Func<T1, T2, 7>(__VA_ARGS__);                                  \
+        break;                                                         \
+      }                                                                \
+      case 8: {                                                        \
+        Func<T1, T2, 8>(__VA_ARGS__);                                  \
+        break;                                                         \
+      }                                                                \
+      default: { break; }                                              \
+    }                                                                  \
+  } while (false)
+
+#define DISPATCH_FUNCTION_BY_VALUE_WITH_TYPE_3(val, Func, T1, T2, T3, ...) \
+  do {                                                                     \
+    CAFFE_ENFORCE_LE(val, kHIPTensorMaxDims);                              \
+    switch (val) {                                                         \
+      case 1: {                                                            \
+        Func<T1, T2, T3, 1>(__VA_ARGS__);                                  \
+        break;                                                             \
+      }                                                                    \
+      case 2: {                                                            \
+        Func<T1, T2, T3, 2>(__VA_ARGS__);                                  \
+        break;                                                             \
+      }                                                                    \
+      case 3: {                                                            \
+        Func<T1, T2, T3, 3>(__VA_ARGS__);                                  \
+        break;                                                             \
+      }                                                                    \
+      case 4: {                                                            \
+        Func<T1, T2, T3, 4>(__VA_ARGS__);                                  \
+        break;                                                             \
+      }                                                                    \
+      case 5: {                                                            \
+        Func<T1, T2, T3, 5>(__VA_ARGS__);                                  \
+        break;                                                             \
+      }                                                                    \
+      case 6: {                                                            \
+        Func<T1, T2, T3, 6>(__VA_ARGS__);                                  \
+        break;                                                             \
+      }                                                                    \
+      case 7: {                                                            \
+        Func<T1, T2, T3, 7>(__VA_ARGS__);                                  \
+        break;                                                             \
+      }                                                                    \
+      case 8: {                                                            \
+        Func<T1, T2, T3, 8>(__VA_ARGS__);                                  \
+        break;                                                             \
+      }                                                                    \
+      default: { break; }                                                  \
+    }                                                                      \
+  } while (false)
+
 } // namespace caffe2
+
 #endif // CAFFE2_CORE_COMMON_HIP_H_
diff --git a/caffe2/core/hip/context_hip.cc b/caffe2/core/hip/context_hip.cc
index 0d7e1a0f9321d..86a5fe6a376c4 100644
--- a/caffe2/core/hip/context_hip.cc
+++ b/caffe2/core/hip/context_hip.cc
@@ -247,18 +247,29 @@ struct Caffe2HipInitializerHelper
 };
 } // namespace
 
+/**
+ * A utility function to rectify the gpu id. If the context specifies the
+ * gpu id to be -1, it means that we will just use the current gpu id when
+ * the function is being called.
+ */
+static inline int RectifyGPUID(const int gpu_id) {
+  return gpu_id == -1 ? CaffeHipGetDevice() : gpu_id;
+}
+
 HIPContext::HIPContext(const int gpu_id)
-    : gpu_id_(gpu_id == -1 ? GetDefaultGPUID() : gpu_id), random_seed_(RandomNumberSeed())
-{
-    static Caffe2HipInitializerHelper g_hip_initializer_;
+    : gpu_id_(RectifyGPUID(gpu_id)), random_seed_(RandomNumberSeed()) {
+  static Caffe2HipInitializerHelper g_hip_initializer_;
 }
 
 HIPContext::HIPContext(const DeviceOption& option)
-    : gpu_id_(option.has_hip_gpu_id() ? option.hip_gpu_id() : GetDefaultGPUID()),
-      random_seed_(option.has_random_seed() ? option.random_seed() : RandomNumberSeed())
-{
-    static Caffe2HipInitializerHelper g_hip_initializer_;
-    DCHECK_EQ(option.device_type(), HIP);
+    : gpu_id_(
+          option.has_hip_gpu_id() ? RectifyGPUID(option.hip_gpu_id())
+                                  : CaffeHipGetDevice()),
+      random_seed_(
+          option.has_random_seed() ? option.random_seed()
+                                   : RandomNumberSeed()) {
+  static Caffe2HipInitializerHelper g_hip_initializer_;
+  DCHECK_EQ(option.device_type(), HIP);
 }
 
 // shared mutex to lock out alloc / free during NCCL launches
diff --git a/caffe2/core/hip/context_hip.h b/caffe2/core/hip/context_hip.h
index aa8afb1847e94..577ccd6792824 100644
--- a/caffe2/core/hip/context_hip.h
+++ b/caffe2/core/hip/context_hip.h
@@ -1,24 +1,24 @@
 #ifndef CAFFE2_CORE_CONTEXT_HIP_H_
 #define CAFFE2_CORE_CONTEXT_HIP_H_
 
+#include <hiprand.h>
 #include <ctime>
 #include <mutex>
-#include <hiprand.h>
 
-#include "caffe2/core/hip/common_miopen.h"
-#include "caffe2/core/hip/common_hip.h"
 #include "caffe2/core/context.h"
+#include "caffe2/core/hip/common_hip.h"
+#include "caffe2/core/hip/common_miopen.h"
 #include "caffe2/core/logging.h"
+#include "caffe2/core/numa.h"
 #include "caffe2/core/tensor.h"
 #include "caffe2/core/types.h"
 #include "caffe2/proto/caffe2.pb.h"
 
 namespace caffe2 {
 
-enum class HipMemoryPoolType
-{
-    NONE = 0,
-    CUB  = 1,
+enum class HipMemoryPoolType {
+  NONE = 0,
+  CUB = 1,
 };
 
 /**
@@ -37,230 +37,225 @@ HipMemoryPoolType GetHipMemoryPoolType();
  * and deallocating these objects at the thread scope. This class is solely
  * used inside CUDAContext and should not be used externally.
  */
-class ThreadLocalHIPObjects
-{
-    friend class HIPContext;
-
-    private:
-    ThreadLocalHIPObjects()
-    {
-        for(int i = 0; i < CAFFE2_COMPILE_TIME_MAX_HIP_GPUS; ++i)
-        {
-            hip_streams_[i]     = vector<hipStream_t>();
-            rocblas_handles_[i] = vector<rocblas_handle>();
-            miopen_handles_[i]  = vector<miopenHandle_t>();
-        }
-    }
-
-    hipStream_t GetStream(int gpu, int stream_id)
-    {
-        vector<hipStream_t>& gpu_streams = hip_streams_[gpu];
-        if(gpu_streams.size() <= stream_id)
-        {
-            gpu_streams.resize(stream_id + 1, nullptr);
-        }
-        if(!gpu_streams[stream_id])
-        {
-            DeviceGuard guard(gpu);
-            HIP_ENFORCE(hipStreamCreateWithFlags(&gpu_streams[stream_id], hipStreamNonBlocking));
-        }
-        return gpu_streams[stream_id];
+class ThreadLocalHIPObjects {
+  friend class HIPContext;
+
+ private:
+  ThreadLocalHIPObjects() {
+    for (int i = 0; i < CAFFE2_COMPILE_TIME_MAX_HIP_GPUS; ++i) {
+      hip_streams_[i] = vector<hipStream_t>();
+      rocblas_handles_[i] = vector<rocblas_handle>();
+      miopen_handles_[i] = vector<miopenHandle_t>();
     }
+  }
 
-    rocblas_handle GetHandle(int gpu, int stream_id)
-    {
-        DeviceGuard guard(gpu);
-        vector<rocblas_handle>& gpu_handles = rocblas_handles_[gpu];
-        if(gpu_handles.size() <= stream_id)
-        {
-            gpu_handles.resize(stream_id + 1, nullptr);
-        }
-        if(!gpu_handles[stream_id])
-        {
-            ROCBLAS_ENFORCE(rocblas_create_handle(&gpu_handles[stream_id]));
-            // The default is ROCBLAS_POINTER_MODE_HOST. You can override
-            // it after obtaining the rocblas handle, but do that with
-            // caution.
-            ROCBLAS_ENFORCE(
-                rocblas_set_pointer_mode(gpu_handles[stream_id], rocblas_pointer_mode_host));
-            ROCBLAS_ENFORCE(rocblas_set_stream(gpu_handles[stream_id], GetStream(gpu, stream_id)));
-        }
-        return gpu_handles[stream_id];
+  hipStream_t GetStream(int gpu, int stream_id) {
+    vector<hipStream_t>& gpu_streams = hip_streams_[gpu];
+    if (gpu_streams.size() <= stream_id) {
+      gpu_streams.resize(stream_id + 1, nullptr);
     }
-
-    miopenHandle_t GetMiopenHandle(int gpu, int stream_id)
-    {
-        DeviceGuard guard(gpu);
-        vector<miopenHandle_t>& gpu_handles = miopen_handles_[gpu];
-        if(gpu_handles.size() <= stream_id)
-        {
-            gpu_handles.resize(stream_id + 1, nullptr);
-        }
-        if(!gpu_handles[stream_id])
-        {
-            MIOPEN_ENFORCE(miopenCreate(&gpu_handles[stream_id]));
-            MIOPEN_ENFORCE(miopenSetStream(gpu_handles[stream_id], GetStream(gpu, stream_id)));
-        }
-        return gpu_handles[stream_id];
+    if (!gpu_streams[stream_id]) {
+      DeviceGuard guard(gpu);
+      HIP_ENFORCE(hipStreamCreateWithFlags(
+          &gpu_streams[stream_id], hipStreamNonBlocking));
     }
-
-    ~ThreadLocalHIPObjects() noexcept
-    {
-        for(int i = 0; i < CAFFE2_COMPILE_TIME_MAX_HIP_GPUS; ++i)
-        {
-            for(auto& handle : rocblas_handles_[i])
-            {
-                if(handle)
-                {
-                    ROCBLAS_CHECK(rocblas_destroy_handle(handle));
-                }
-            }
-            for(auto& stream : hip_streams_[i])
-            {
-                if(stream)
-                {
-                    HIP_CHECK(hipStreamDestroy(stream));
-                }
-            }
-            for(auto& handle : miopen_handles_[i])
-            {
-                if(handle)
-                {
-                    MIOPEN_CHECK(miopenDestroy(handle));
-                }
-            }
-        }
+    return gpu_streams[stream_id];
+  }
+
+  rocblas_handle GetHandle(int gpu, int stream_id) {
+    DeviceGuard guard(gpu);
+    vector<rocblas_handle>& gpu_handles = rocblas_handles_[gpu];
+    if (gpu_handles.size() <= stream_id) {
+      gpu_handles.resize(stream_id + 1, nullptr);
     }
-    vector<hipStream_t> hip_streams_[CAFFE2_COMPILE_TIME_MAX_HIP_GPUS];
-    vector<rocblas_handle> rocblas_handles_[CAFFE2_COMPILE_TIME_MAX_HIP_GPUS];
-    vector<miopenHandle_t> miopen_handles_[CAFFE2_COMPILE_TIME_MAX_HIP_GPUS];
-};
-
-class HIPContext final
-{
-    public:
-    // The default HIP context constructor.
-    explicit HIPContext(const int gpu_id = -1);
-    explicit HIPContext(const DeviceOption& option);
-
-    ~HIPContext()
-    {
-        if(hiprand_generator_)
-        {
-            HIPRAND_ENFORCE(hiprandDestroyGenerator(hiprand_generator_));
-        }
-        FinishDeviceComputation();
+    if (!gpu_handles[stream_id]) {
+      ROCBLAS_ENFORCE(rocblas_create_handle(&gpu_handles[stream_id]));
+      // The default is ROCBLAS_POINTER_MODE_HOST. You can override
+      // it after obtaining the rocblas handle, but do that with
+      // caution.
+      ROCBLAS_ENFORCE(rocblas_set_pointer_mode(
+          gpu_handles[stream_id], rocblas_pointer_mode_host));
+      ROCBLAS_ENFORCE(rocblas_set_stream(
+          gpu_handles[stream_id], GetStream(gpu, stream_id)));
     }
-
-    inline void SwitchToDevice(int stream_id)
-    {
-        set_stream_id(stream_id);
-        CaffeHipSetDevice(gpu_id_);
+    return gpu_handles[stream_id];
+  }
+
+  miopenHandle_t GetMiopenHandle(int gpu, int stream_id) {
+    DeviceGuard guard(gpu);
+    vector<miopenHandle_t>& gpu_handles = miopen_handles_[gpu];
+    if (gpu_handles.size() <= stream_id) {
+      gpu_handles.resize(stream_id + 1, nullptr);
     }
-    inline void SwitchToDevice() { SwitchToDevice(0); }
-
-    inline void WaitEvent(const Event& ev) { ev.Wait(HIP, this); }
-
-    inline void Record(Event* ev, const char* err_msg = nullptr) const
-    {
-        CAFFE_ENFORCE(ev, "Event must not be null.");
-        ev->Record(HIP, this, err_msg);
+    if (!gpu_handles[stream_id]) {
+      MIOPEN_ENFORCE(miopenCreate(&gpu_handles[stream_id]));
+      MIOPEN_ENFORCE(
+          miopenSetStream(gpu_handles[stream_id], GetStream(gpu, stream_id)));
     }
-
-    void FinishDeviceComputation()
-    {
-        hipStreamSynchronize(hip_objects_.GetStream(gpu_id_, stream_id_));
-        hipError_t error = hipGetLastError();
-        if(error != hipSuccess)
-        {
-            CAFFE_THROW("Encountered HIP error: ", hipGetErrorString(error));
+    return gpu_handles[stream_id];
+  }
+
+  ~ThreadLocalHIPObjects() noexcept {
+    for (int i = 0; i < CAFFE2_COMPILE_TIME_MAX_HIP_GPUS; ++i) {
+      for (auto& handle : rocblas_handles_[i]) {
+        if (handle) {
+          ROCBLAS_CHECK(rocblas_destroy_handle(handle));
         }
-    }
-
-    inline int hip_gpu_id() const { return gpu_id_; }
-
-    inline hipStream_t hip_stream() { return hip_stream(gpu_id_, stream_id_); }
-
-    inline hipStream_t hip_stream() const { return hip_stream(gpu_id_, stream_id_); }
-
-    static hipStream_t hip_stream(int gpu_id, int stream_id)
-    {
-        return hip_objects_.GetStream(gpu_id, stream_id);
-    }
-
-    rocblas_handle get_rocblas_handle() { return hip_objects_.GetHandle(gpu_id_, stream_id_); }
-
-    miopenHandle_t miopen_handle() { return hip_objects_.GetMiopenHandle(gpu_id_, stream_id_); }
-
-    hiprandGenerator_t& hiprand_generator()
-    {
-        if(!hiprand_generator_)
-        {
-            DeviceGuard guard(gpu_id_);
-            HIPRAND_ENFORCE(
-                hiprandCreateGenerator(&hiprand_generator_, HIPRAND_RNG_PSEUDO_DEFAULT));
-            HIPRAND_ENFORCE(hiprandSetPseudoRandomGeneratorSeed(hiprand_generator_, random_seed_));
-            CHECK_NOTNULL(hiprand_generator_);
+      }
+      for (auto& stream : hip_streams_[i]) {
+        if (stream) {
+          HIP_CHECK(hipStreamDestroy(stream));
+        }
+      }
+      for (auto& handle : miopen_handles_[i]) {
+        if (handle) {
+          MIOPEN_CHECK(miopenDestroy(handle));
         }
-        HIPRAND_ENFORCE(hiprandSetStream(hiprand_generator_, hip_stream()));
-        return hiprand_generator_;
+      }
     }
+  }
+  vector<hipStream_t> hip_streams_[CAFFE2_COMPILE_TIME_MAX_HIP_GPUS];
+  vector<rocblas_handle> rocblas_handles_[CAFFE2_COMPILE_TIME_MAX_HIP_GPUS];
+  vector<miopenHandle_t> miopen_handles_[CAFFE2_COMPILE_TIME_MAX_HIP_GPUS];
+};
 
-    static std::pair<void*, MemoryDeleter> New(size_t nbytes);
-
-    // Get a mutex to lock out hipMalloc / hipFree calls when
-    // NCCL kernels are being launched. Should remove threat of
-    // deadlocks
-    static std::mutex& mutex();
-
-    // Functions to query memory stats. Only available if flag
-    // --caffe2_gpu_memory_tracking is enabled.
-    static std::vector<long> TotalMemoryByGpu();
-    static std::vector<long> MaxMemoryByGpu();
-
-    template <class SrcContext, class DstContext>
-    inline void CopyBytes(size_t nbytes, const void* src, void* dst)
-    {
-        if(nbytes == 0)
-            return;
-        HIP_ENFORCE(hipMemcpyAsync(
-            dst, src, nbytes, hipMemcpyDefault, hip_objects_.GetStream(gpu_id_, stream_id_)));
-    }
+class HIPContext final {
+ public:
+  // The default HIP context constructor.
+  explicit HIPContext(const int gpu_id = -1);
+  explicit HIPContext(const DeviceOption& option);
 
-    template <typename T, class SrcContext, class DstContext>
-    inline void Copy(int n, const T* src, T* dst)
-    {
-        CopyBytes<SrcContext, DstContext>(
-            n * sizeof(T), static_cast<const void*>(src), static_cast<void*>(dst));
+  ~HIPContext() {
+    if (hiprand_generator_) {
+      HIPRAND_CHECK(hiprandDestroyGenerator(hiprand_generator_));
     }
-
-    template <class SrcContext, class DstContext>
-    inline void CopyItems(const TypeMeta& meta, size_t n, const void* src, void* dst)
-    {
-        CAFFE_ENFORCE(!meta.copy(), "HIPContext requires fundamental types.");
-        CopyBytes<SrcContext, DstContext>(n * meta.itemsize(), src, dst);
+    FinishDeviceComputation();
+  }
+
+  inline void SwitchToDevice(int stream_id) {
+    set_stream_id(stream_id);
+    CaffeHipSetDevice(gpu_id_);
+  }
+  inline void SwitchToDevice() {
+    SwitchToDevice(0);
+  }
+
+  inline void WaitEvent(const Event& ev) {
+    ev.Wait(HIP, this);
+  }
+
+  inline void Record(Event* ev, const char* err_msg = nullptr) const {
+    CAFFE_ENFORCE(ev, "Event must not be null.");
+    ev->Record(HIP, this, err_msg);
+  }
+
+  void FinishDeviceComputation() {
+    hipStreamSynchronize(hip_objects_.GetStream(gpu_id_, stream_id_));
+    hipError_t error = hipGetLastError();
+    if (error != hipSuccess) {
+      CAFFE_THROW("Encountered HIP error: ", hipGetErrorString(error));
     }
-
-    // By default HIP operators have async device parts
-    static bool HasAsyncPartDefault() { return true; }
-
-    static bool SupportsAsyncScheduling() { return true; }
-
-    static bool IsStreamFree(const DeviceOption& option, int stream_id)
-    {
-        auto stream = HIPContext::hip_stream(option.hip_gpu_id(), stream_id);
-        return hipStreamQuery(stream) == hipSuccess;
+  }
+
+  inline int hip_gpu_id() const {
+    return gpu_id_;
+  }
+
+  inline hipStream_t hip_stream() {
+    return hip_stream(gpu_id_, stream_id_);
+  }
+
+  inline hipStream_t hip_stream() const {
+    return hip_stream(gpu_id_, stream_id_);
+  }
+
+  static hipStream_t hip_stream(int gpu_id, int stream_id) {
+    return hip_objects_.GetStream(gpu_id, stream_id);
+  }
+
+  rocblas_handle rocblas_handle() {
+    return hip_objects_.GetHandle(gpu_id_, stream_id_);
+  }
+
+  miopenHandle_t miopen_handle() {
+    return hip_objects_.GetMiopenHandle(gpu_id_, stream_id_);
+  }
+
+  hiprandGenerator_t& hiprand_generator() {
+    if (!hiprand_generator_) {
+      DeviceGuard guard(gpu_id_);
+      HIPRAND_ENFORCE(hiprandCreateGenerator(
+          &hiprand_generator_, HIPRAND_RNG_PSEUDO_DEFAULT));
+      HIPRAND_ENFORCE(hiprandSetPseudoRandomGeneratorSeed(
+          hiprand_generator_, random_seed_));
+      CHECK_NOTNULL(hiprand_generator_);
     }
-
-    protected:
-    static void Delete(void* data);
-    void set_stream_id(int stream_id) { stream_id_ = stream_id; }
-
-    int gpu_id_;
-    int stream_id_ = 0;
-    int random_seed_;
-    hiprandGenerator_t hiprand_generator_{nullptr};
-    static thread_local ThreadLocalHIPObjects hip_objects_;
+    HIPRAND_ENFORCE(hiprandSetStream(hiprand_generator_, hip_stream()));
+    return hiprand_generator_;
+  }
+
+  static std::pair<void*, MemoryDeleter> New(size_t nbytes);
+
+  // Get a mutex to lock out hipMalloc / hipFree calls when
+  // NCCL kernels are being launched. Should remove threat of
+  // deadlocks
+  static std::mutex& mutex();
+
+  // Functions to query memory stats. Only available if flag
+  // --caffe2_gpu_memory_tracking is enabled.
+  static std::vector<long> TotalMemoryByGpu();
+  static std::vector<long> MaxMemoryByGpu();
+
+  template <class SrcContext, class DstContext>
+  inline void CopyBytes(size_t nbytes, const void* src, void* dst) {
+    if (nbytes == 0)
+      return;
+    HIP_ENFORCE(hipMemcpyAsync(
+        dst,
+        src,
+        nbytes,
+        hipMemcpyDefault,
+        hip_objects_.GetStream(gpu_id_, stream_id_)));
+  }
+
+  template <typename T, class SrcContext, class DstContext>
+  inline void Copy(int n, const T* src, T* dst) {
+    CopyBytes<SrcContext, DstContext>(
+        n * sizeof(T), static_cast<const void*>(src), static_cast<void*>(dst));
+  }
+
+  template <class SrcContext, class DstContext>
+  inline void
+  CopyItems(const TypeMeta& meta, size_t n, const void* src, void* dst) {
+    CAFFE_ENFORCE(!meta.copy(), "HIPContext requires fundamental types.");
+    CopyBytes<SrcContext, DstContext>(n * meta.itemsize(), src, dst);
+  }
+
+  // By default HIP operators have async device parts
+  static bool HasAsyncPartDefault() {
+    return true;
+  }
+
+  static bool SupportsAsyncScheduling() {
+    return true;
+  }
+
+  static bool IsStreamFree(const DeviceOption& option, int stream_id) {
+    auto stream = HIPContext::hip_stream(option.hip_gpu_id(), stream_id);
+    return hipStreamQuery(stream) == hipSuccess;
+  }
+
+ protected:
+  static void Delete(void* data);
+  void set_stream_id(int stream_id) {
+    stream_id_ = stream_id;
+  }
+
+  int gpu_id_;
+  int stream_id_ = 0;
+  int random_seed_;
+  hiprandGenerator_t hiprand_generator_{nullptr};
+  static thread_local ThreadLocalHIPObjects hip_objects_;
 };
 
 // For the CPU context, we also allow a (probably expensive) function
@@ -269,16 +264,20 @@ class HIPContext final
 // side, these functions are synchronous with respect to the host, similar
 // to a normal CPUContext::CopyBytes<CPUContext, CPUContext> call.
 template <>
-inline void CPUContext::CopyBytes<HIPContext, CPUContext>(size_t nbytes, const void* src, void* dst)
-{
-    HIPContext context(GetGPUIDForPointer(src));
-    context.CopyBytes<HIPContext, CPUContext>(nbytes, src, dst);
+inline void CPUContext::CopyBytes<HIPContext, CPUContext>(
+    size_t nbytes,
+    const void* src,
+    void* dst) {
+  HIPContext context(GetGPUIDForPointer(src));
+  context.CopyBytes<HIPContext, CPUContext>(nbytes, src, dst);
 }
 template <>
-inline void CPUContext::CopyBytes<CPUContext, HIPContext>(size_t nbytes, const void* src, void* dst)
-{
-    HIPContext context(GetGPUIDForPointer(dst));
-    context.CopyBytes<CPUContext, HIPContext>(nbytes, src, dst);
+inline void CPUContext::CopyBytes<CPUContext, HIPContext>(
+    size_t nbytes,
+    const void* src,
+    void* dst) {
+  HIPContext context(GetGPUIDForPointer(dst));
+  context.CopyBytes<CPUContext, HIPContext>(nbytes, src, dst);
 }
 
 /**
@@ -290,43 +289,53 @@ inline void CPUContext::CopyBytes<CPUContext, HIPContext>(size_t nbytes, const v
  * GPU present during runtime, at global initialization time we will set
  * the CPU memory allocator to allocate pinned memory.
  */
-struct PinnedCPUAllocator final : CPUAllocator
-{
-    PinnedCPUAllocator() {}
-    ~PinnedCPUAllocator() override {}
-    std::pair<void*, MemoryDeleter> New(size_t nbytes) override
-    {
-        void* data;
-        std::lock_guard<std::mutex> lock(HIPContext::mutex());
-        HIP_ENFORCE(hipHostMalloc(&data, nbytes));
-        memset(data, 0, nbytes);
-        return {data, Delete};
+struct PinnedCPUAllocator final : CPUAllocator {
+  PinnedCPUAllocator() {}
+  ~PinnedCPUAllocator() override {}
+  std::pair<void*, MemoryDeleter> New(size_t nbytes) override {
+    void* data;
+    std::lock_guard<std::mutex> lock(HIPContext::mutex());
+    if (IsNUMAEnabled()) {
+      auto ptr_and_deleter = baseAllocator_.New(nbytes);
+      data = ptr_and_deleter.first;
+      CAFFE_ENFORCE(data);
+      HIP_ENFORCE(hipHostRegister(data, nbytes, hipHostRegisterDefault));
+    } else {
+      HIP_ENFORCE(hipHostMalloc(&data, nbytes));
     }
-
-    MemoryDeleter GetDeleter() override { return Delete; }
-
-    private:
-    static void Delete(void* data)
-    {
-        // Caffe2 uses a lazy way to figure out if one is actually going to use GPUs
-        // or not. If a HIPContext::New() call is made, inside the CUDAContext
-        // function we will switch the cpu side allocator to a PinnedCPUAllocator.
-        // But, if one calls CPUContext::New() before any HIP allocations,
-        // PinnedCPUAllocator can still delete the corresponding memory.
-        std::lock_guard<std::mutex> lock(HIPContext::mutex());
-        hipError_t err = hipHostFree(data);
-        if(err == hipErrorInvalidValue)
-        {
-            free(data);
-            // Calling hipGetLastError will reset the HIP error.
-            hipGetLastError();
-        }
-        else
-        {
-            // For all other errors, still do a HIP check.
-            HIP_ENFORCE(err);
-        }
+    memset(data, 0, nbytes);
+    return {data, Delete};
+  }
+
+  MemoryDeleter GetDeleter() override {
+    return Delete;
+  }
+
+ private:
+  static void Delete(void* data) {
+    // Caffe2 uses a lazy way to figure out if one is actually going to use GPUs
+    // or not. If a HIPContext::New() call is made, inside the CUDAContext
+    // function we will switch the cpu side allocator to a PinnedCPUAllocator.
+    // But, if one calls CPUContext::New() before any HIP allocations,
+    // PinnedCPUAllocator can still delete the corresponding memory.
+    std::lock_guard<std::mutex> lock(HIPContext::mutex());
+    if (IsNUMAEnabled()) {
+      HIP_ENFORCE(hipHostUnregister(data));
+      DefaultCPUAllocator::Delete(data);
+    } else {
+      hipError_t err = hipHostFree(data);
+      if (err == hipErrorInvalidValue) {
+        free(data);
+        // Calling hipGetLastError will reset the cuda error.
+        hipGetLastError();
+      } else {
+        // For all other errors, still do a hip check.
+        HIP_ENFORCE(err);
+      }
     }
+  }
+
+  DefaultCPUAllocator baseAllocator_;
 };
 
 // For simplicity, we will typedef Tensor<CPUContext> to TensorCPU.
diff --git a/caffe2/core/hip/context_hip_test.cc b/caffe2/core/hip/context_hip_test.cc
index 3f02751c174ee..fe86afb65023c 100644
--- a/caffe2/core/hip/context_hip_test.cc
+++ b/caffe2/core/hip/context_hip_test.cc
@@ -110,8 +110,9 @@ TEST(HIPContextTest, TestSameThreadSameObject)
     HIPContext context_a(0);
     HIPContext context_b(0);
     EXPECT_EQ(context_a.hip_stream(), context_b.hip_stream());
-    EXPECT_EQ(context_a.get_rocblas_handle(), context_b.get_rocblas_handle());
-    EXPECT_EQ(context_a.hip_stream(), getStreamForHandle(context_b.get_rocblas_handle()));
+    EXPECT_EQ(context_a.rocblas_handle(), context_b.rocblas_handle());
+    EXPECT_EQ(
+        context_a.hip_stream(), getStreamForHandle(context_b.rocblas_handle()));
     // hipRAND generators are context-local.
     EXPECT_NE(context_a.hiprand_generator(), context_b.hiprand_generator());
 }
@@ -123,14 +124,16 @@ TEST(HIPContextTest, TestSameThreadDifferntObjectIfDifferentDevices)
         HIPContext context_a(0);
         HIPContext context_b(1);
         EXPECT_NE(context_a.hip_stream(), context_b.hip_stream());
-        EXPECT_NE(context_a.get_rocblas_handle(), context_b.get_rocblas_handle());
-        EXPECT_NE(context_a.hip_stream(), getStreamForHandle(context_b.get_rocblas_handle()));
+        EXPECT_NE(context_a.rocblas_handle(), context_b.rocblas_handle());
+        EXPECT_NE(
+            context_a.hip_stream(),
+            getStreamForHandle(context_b.rocblas_handle()));
         EXPECT_NE(context_a.hiprand_generator(), context_b.hiprand_generator());
     }
 }
 
 namespace {
-// A test function to return a stream address from a temp CUDA context. You
+// A test function to return a stream address from a temp HIP context. You
 // should not use that stream though, because the actual stream is destroyed
 // after thread exit.
 void TEST_GetStreamAddress(hipStream_t* ptr)
diff --git a/caffe2/core/hip/net_async_dag_hip.cc b/caffe2/core/hip/net_async_dag_hip.cc
index 1c4c0f5481cfd..4a9a847313855 100644
--- a/caffe2/core/hip/net_async_dag_hip.cc
+++ b/caffe2/core/hip/net_async_dag_hip.cc
@@ -149,7 +149,16 @@ bool AsyncDAGNet::RunAt(int chain_id, const std::vector<int>& chain)
     for(auto idx : chain)
     {
         ProfiledRange r(operator_nodes_[idx].operator_->debug_def(), kRunColor);
-        success &= operator_nodes_[idx].operator_->RunAsync(stream_id);
+        {
+          TRACE_EVENT(
+              tracing::TRACE_OP,
+              idx,
+              tracing::TRACE_TASK,
+              chain_id,
+              tracing::TRACE_STREAM,
+              stream_id);
+          success &= operator_nodes_[idx].operator_->RunAsync(stream_id);
+        }
     }
 
     const auto& sink_idx = chain.back();
diff --git a/caffe2/core/hip/operator_hip_test.cc b/caffe2/core/hip/operator_hip_test.cc
index b12c118dc352c..14b0188452fe2 100644
--- a/caffe2/core/hip/operator_hip_test.cc
+++ b/caffe2/core/hip/operator_hip_test.cc
@@ -22,8 +22,20 @@ class JustTestHIP : public JustTest
     std::string type() override { return "HIP"; }
 };
 
+class JustTestMIOPEN : public JustTest {
+ public:
+  using JustTest::JustTest;
+  bool Run(int /* unused */ /*stream_id*/) override {
+    return true;
+  }
+  std::string type() override {
+    return "MIOPEN";
+  }
+};
+
 OPERATOR_SCHEMA(JustTest).NumInputs(0, 1).NumOutputs(0, 1);
 REGISTER_HIP_OPERATOR(JustTest, JustTestHIP);
+REGISTER_MIOPEN_OPERATOR(JustTest, JustTestMIOPEN);
 
 TEST(EnginePrefTest, GPUDeviceDefaultPreferredEngines)
 {
@@ -33,6 +45,12 @@ TEST(EnginePrefTest, GPUDeviceDefaultPreferredEngines)
     Workspace ws;
     op_def.mutable_device_option()->set_device_type(HIP);
     op_def.set_type("JustTest");
+
+    {
+      const auto op = CreateOperator(op_def, &ws);
+      EXPECT_NE(nullptr, op.get());
+      EXPECT_EQ(static_cast<JustTest*>(op.get())->type(), "HIP");
+    }
 }
 
 } // namespace caffe2
diff --git a/caffe2/operators/CMakeLists.txt b/caffe2/operators/CMakeLists.txt
index ab486cc7b959a..1be16dfdf6842 100644
--- a/caffe2/operators/CMakeLists.txt
+++ b/caffe2/operators/CMakeLists.txt
@@ -19,6 +19,16 @@ set(Caffe2_GPU_SRCS ${Caffe2_GPU_SRCS} ${tmp})
 file(GLOB tmp *_test.cc)
 exclude(Caffe2_GPU_SRCS "${Caffe2_GPU_SRCS}" ${tmp})
 
+# ------[ HIP sources
+file(GLOB_RECURSE tmp *_hip.cc)
+set(Caffe2_HIP_SRCS ${Caffe2_HIP_SRCS} ${tmp})
+# ------[ HIP device sources
+file(GLOB_RECURSE tmp *_hipdev.cc)
+set(Caffe2_HIP_SRCS ${Caffe2_HIP_SRCS} ${tmp})
+# ---[ MIOPEN files
+file(GLOB_RECURSE tmp *_miopen.cc)
+set(Caffe2_HIP_SRCS ${Caffe2_HIP_SRCS} ${tmp})
+
 # ---[ CPU files.
 file(GLOB tmp *.cc)
 # Manually remove the cudnn files since we might be using USE_CUDNN=OFF
@@ -29,7 +39,7 @@ set(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS} ${tmp})
 # exclude test files and gpu files
 file(GLOB tmp *_test.cc)
 exclude(Caffe2_CPU_SRCS "${Caffe2_CPU_SRCS}" ${tmp})
-exclude(Caffe2_CPU_SRCS "${Caffe2_CPU_SRCS}" ${Caffe2_GPU_SRCS})
+exclude(Caffe2_CPU_SRCS "${Caffe2_CPU_SRCS}" ${Caffe2_GPU_SRCS} ${Caffe2_HIP_SRCS})
 
 # ---[ GPU test files
 # ------[ cuDNN
@@ -41,6 +51,13 @@ endif()
 file(GLOB tmp *_gpu_test.cc)
 set(Caffe2_GPU_TEST_SRCS ${Caffe2_GPU_TEST_SRCS} ${tmp})
 
+# ---[ HIP test files
+file(GLOB_RECURSE tmp *_hip_test.cc)
+set(Caffe2_HIP_TEST_SRCS ${Caffe2_HIP_TEST_SRCS} ${tmp})
+# ---[ MIOPEN test files
+file(GLOB_RECURSE tmp *_miopen_test.cc)
+set(Caffe2_HIP_TEST_SRCS ${Caffe2_HIP_TEST_SRCS} ${tmp})
+
 # ---[ CPU test files
 file(GLOB tmp *_test.cc)
 # Manually remove the cudnn files since we might be using USE_CUDNN=OFF
@@ -48,10 +65,12 @@ file(GLOB tmp *_test.cc)
 file(GLOB tmp_cudnn *_cudnn_test.cc)
 exclude(tmp "${tmp}" ${tmp_cudnn})
 set(Caffe2_CPU_TEST_SRCS ${Caffe2_CPU_TEST_SRCS} ${tmp})
-exclude(Caffe2_CPU_TEST_SRCS "${Caffe2_CPU_TEST_SRCS}" ${Caffe2_GPU_TEST_SRCS})
+exclude(Caffe2_CPU_TEST_SRCS "${Caffe2_CPU_TEST_SRCS}" ${Caffe2_GPU_TEST_SRCS} ${Caffe2_HIP_TEST_SRCS})
 
 # ---[ Send the lists to the parent scope.
 set(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS} PARENT_SCOPE)
 set(Caffe2_GPU_SRCS ${Caffe2_GPU_SRCS} PARENT_SCOPE)
+set(Caffe2_HIP_SRCS ${Caffe2_HIP_SRCS} PARENT_SCOPE)
 set(Caffe2_CPU_TEST_SRCS ${Caffe2_CPU_TEST_SRCS} PARENT_SCOPE)
 set(Caffe2_GPU_TEST_SRCS ${Caffe2_GPU_TEST_SRCS} PARENT_SCOPE)
+set(Caffe2_HIP_TEST_SRCS ${Caffe2_HIP_TEST_SRCS} PARENT_SCOPE)
diff --git a/caffe2/operators/hip/conv_op_miopen.cc b/caffe2/operators/hip/conv_op_miopen.cc
new file mode 100644
index 0000000000000..84d9a75cfac7c
--- /dev/null
+++ b/caffe2/operators/hip/conv_op_miopen.cc
@@ -0,0 +1,859 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "caffe2/core/hip/context_hip.h"
+#include "caffe2/core/hip/miopen_wrapper.h"
+#include "caffe2/operators/conv_op.h"
+#include "caffe2/operators/conv_pool_op_base.h"
+
+namespace caffe2 {
+
+// Earlier in the days Caffe sets the default miopen workspace to 8MB. We bump
+// it up to 64MB in Caffe2, as this enables the use of Winograd in many cases,
+// something very beneficial to more recent CNN models.
+static constexpr size_t kCONV_MIOPEN_WORKSPACE_LIMIT_BYTES = 64 * 1024 * 1024;
+
+class MIOPENConvOpBase : public ConvPoolOpBase<HIPContext> {
+ public:
+  MIOPENConvOpBase(const OperatorDef& operator_def, Workspace* ws)
+      : ConvPoolOpBase<HIPContext>(operator_def, ws),
+        miopen_wrapper_(&context_),
+        miopen_ws_nbytes_limit_(OperatorBase::GetSingleArgument<size_t>(
+            "ws_nbytes_limit",
+            kCONV_MIOPEN_WORKSPACE_LIMIT_BYTES)),
+        alpha_(OperatorBase::GetSingleArgument<float>("alpha", 1.0)),
+        beta_(OperatorBase::GetSingleArgument<float>("beta", 0.0)),
+        exhaustive_search_(
+            OperatorBase::GetSingleArgument<bool>("exhaustive_search", false)) {
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&bottom_desc_));
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&bias_desc_));
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&weight_desc_));
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&top_desc_));
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&top_desc_for_bias_));
+    MIOPEN_ENFORCE(miopenCreateConvolutionDescriptor(&conv_desc_));
+
+    if ((operator_def.type().substr(0, 6) == "Conv") ||
+        (operator_def.type().substr(0, 14) == "ConvGradient")) {
+      mode_ = miopenConvolution;
+    } else if (
+        (operator_def.type().substr(0, 7) == "Trans") ||
+        (operator_def.type().substr(0, 15) == "TransGradient")) {
+      mode_ = miopenTranspose;
+    } else {
+      LOG(FATAL) << "Unsupported convolution method: " << operator_def.type();
+    }
+
+    MIOPEN_ENFORCE(miopenInitConvolutionDescriptor(
+        conv_desc_,
+        mode_,
+        pad_t(),
+        pad_l(),
+        stride_h(),
+        stride_w(),
+        dilation_h(),
+        dilation_w()));
+  }
+
+  ~MIOPENConvOpBase() {
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(bottom_desc_));
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(bias_desc_));
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(weight_desc_));
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(top_desc_));
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(top_desc_for_bias_));
+    MIOPEN_ENFORCE(miopenDestroyConvolutionDescriptor(conv_desc_));
+  }
+
+ protected:
+  MIOPENWrapper miopen_wrapper_;
+  miopenTensorDescriptor_t bottom_desc_;
+  miopenTensorDescriptor_t bias_desc_;
+  miopenTensorDescriptor_t weight_desc_;
+  miopenTensorDescriptor_t top_desc_;
+  miopenTensorDescriptor_t top_desc_for_bias_;
+  miopenConvolutionDescriptor_t conv_desc_;
+  miopenConvolutionMode_t mode_;
+  const size_t miopen_ws_nbytes_limit_;
+  bool exhaustive_search_;
+  const float alpha_;
+  const float beta_;
+};
+
+class MIOPENConvOp final : public MIOPENConvOpBase {
+ public:
+  MIOPENConvOp(const OperatorDef& operator_def, Workspace* ws)
+      : MIOPENConvOpBase(operator_def, ws),
+        requestAlgoCount_(
+            OperatorBase::GetSingleArgument<int>("requestAlgoCount_", 1)),
+        returnedAlgoCount_(
+            OperatorBase::GetSingleArgument<int>("returnedAlgoCount_", 1)),
+        bestAlgoFound_(
+            OperatorBase::GetSingleArgument<bool>("bestAlgoFound_", false)),
+        fwdConvWs_(nullptr),
+        fwdConvWsSize_(0),
+        fwdAlgo_(miopenConvolutionFwdAlgoGEMM) {}
+
+  ~MIOPENConvOp() {
+    if (fwdConvWs_) {
+      hipFree(fwdConvWs_);
+      fwdConvWs_ = nullptr;
+      fwdConvWsSize_ = 0;
+    }
+  }
+
+  template <
+      typename T_X,
+      typename T_W,
+      typename T_B,
+      typename MATH,
+      typename T_Y>
+  bool DoRunWithType();
+  bool RunOnDevice() override;
+
+ private:
+  const int requestAlgoCount_;
+  int returnedAlgoCount_;
+  bool bestAlgoFound_;
+  char* fwdConvWs_;
+  size_t fwdConvWsSize_;
+  miopenConvFwdAlgorithm_t fwdAlgo_;
+  // Input: X, W, b
+  // Output: Y
+  INPUT_TAGS(INPUT, FILTER, BIAS);
+};
+
+class MIOPENConvGradientOp final : public MIOPENConvOpBase {
+ public:
+  MIOPENConvGradientOp(const OperatorDef& operator_def, Workspace* ws)
+      : MIOPENConvOpBase(operator_def, ws),
+        no_bias_(OperatorBase::GetSingleArgument<int>("no_bias", 0)),
+        requestAlgoCount_(
+            OperatorBase::GetSingleArgument<int>("requestAlgoCount_", 1)),
+        returnedAlgoCount_(
+            OperatorBase::GetSingleArgument<int>("returnedAlgoCount_", 1)),
+        bestDataAlgoFound_(
+            OperatorBase::GetSingleArgument<bool>("bestAlgoFound", false)),
+        bestWeightAlgoFound_(
+            OperatorBase::GetSingleArgument<bool>("bestAlgoFound", false)),
+        bwdWeightWs_(nullptr),
+        bwdWeightWsSize_(0),
+        bwdDataWs_(nullptr),
+        bwdDataWsSize_(0),
+        bwdWeiAlgo_(miopenConvolutionBwdWeightsAlgoGEMM),
+        bwdDataAlgo_(miopenConvolutionBwdDataAlgoGEMM) {
+    OPERATOR_NEEDS_FEATURE(
+        group_ == 1,
+        "Group convolution not supported yet for MIOpen ConvGradient.");
+    CAFFE_ENFORCE(
+        !(no_bias_ && OutputSize() == 3),
+        "If bias is not present, you should not have 3 grad output.");
+  }
+
+  ~MIOPENConvGradientOp() {
+    if (bwdWeightWs_) {
+      hipFree(bwdWeightWs_);
+      bwdWeightWs_ = nullptr;
+      bwdWeightWsSize_ = 0;
+    }
+    if (bwdDataWs_) {
+      hipFree(bwdDataWs_);
+      bwdDataWs_ = nullptr;
+      bwdDataWsSize_ = 0;
+    }
+  }
+
+  template <
+      typename T_X,
+      typename T_DY,
+      typename T_W,
+      typename T_B,
+      typename MATH,
+      typename T_DX,
+      typename T_DW,
+      typename T_DB>
+  bool DoRunWithType();
+  bool RunOnDevice() override;
+
+ private:
+  bool no_bias_;
+  const int requestAlgoCount_;
+  int returnedAlgoCount_;
+  bool bestDataAlgoFound_;
+  bool bestWeightAlgoFound_;
+  miopenConvBwdWeightsAlgorithm_t bwdWeiAlgo_;
+  miopenConvBwdDataAlgorithm_t bwdDataAlgo_;
+  size_t bwdWeightWsSize_;
+  size_t bwdDataWsSize_;
+  char* bwdWeightWs_;
+  char* bwdDataWs_;
+  // input: X, W, dY
+  // output: dW, db, and optionally dX
+  INPUT_TAGS(INPUT, FILTER, OUTPUT_GRAD);
+  OUTPUT_TAGS(FILTER_GRAD, BIAS_OR_INPUT_GRAD, INPUT_GRAD);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Implementations
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename T_X, typename T_W, typename T_B, typename MATH, typename T_Y>
+bool MIOPENConvOp::DoRunWithType() {
+  auto& X = Input(INPUT);
+  auto& Weight = Input(FILTER);
+  auto* Y = Output(0);
+
+  // Figure out the output shape
+  CAFFE_ENFORCE(X.ndim() >= 3 && X.ndim() <= 5);
+  CAFFE_ENFORCE(
+      Weight.ndim() == 4,
+      "Conv/Trans op with MIOpen engine is supported only for 2D convolutions");
+
+  const int M = Weight.dim32(0);
+  ConvPoolOpBase<HIPContext>::SetOutputSize(X, Y, M);
+
+  int N = X.dim32(0);
+  int C = X.dim32(1);
+  int H = X.dim32(2);
+  int W = X.ndim() > 3 ? X.dim32(3) : 1;
+  int D = X.ndim() > 4 ? X.dim32(4) : 1;
+
+  int N_out = Y->dim32(0);
+  int C_out = Y->dim32(1);
+  int H_out = Y->dim32(2);
+  int W_out = Y->ndim() > 3 ? Y->dim32(3) : 1;
+  int D_out = Y->ndim() > 4 ? Y->dim32(4) : 1;
+  CAFFE_ENFORCE_EQ(Weight.dim32(1), C / group_);
+
+  CAFFE_ENFORCE(
+      C % group_ == 0,
+      "If you set group, the number of input channels should be divisible "
+      "by group.");
+  CAFFE_ENFORCE(
+      M % group_ == 0,
+      "If you set group, the number of output channels should be divisible "
+      "by group.");
+
+  if (group_ > 1) {
+    int group_offset_filter = Weight.size() / group_;
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        weight_desc_,
+        miopenTypeWrapper<T_W>::type,
+        M / group_,
+        C / group_,
+        kernel_h(),
+        kernel_w()));
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        bottom_desc_, miopenTypeWrapper<T_X>::type, 1, C / group_, H, W));
+
+    MIOPEN_ENFORCE(miopenGetConvolutionForwardOutputDim(
+        conv_desc_,
+        bottom_desc_,
+        weight_desc_,
+        &N_out,
+        &C_out,
+        &H_out,
+        &W_out));
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        top_desc_, miopenTypeWrapper<T_X>::type, N_out, C_out, H_out, W_out));
+
+    if (InputSize() == 3) {
+      MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+          bias_desc_, miopenTypeWrapper<T_B>::type, 1, Y->dim32(1), 1, 1));
+      MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+          top_desc_for_bias_,
+          miopenTypeWrapper<T_X>::type,
+          Y->dim32(0),
+          Y->dim32(1),
+          H_out,
+          W_out));
+    }
+
+    MIOPEN_ENFORCE(miopenConvolutionForwardGetWorkSpaceSize(
+        miopen_wrapper_.inline_miopen_handle(),
+        weight_desc_,
+        bottom_desc_,
+        conv_desc_,
+        top_desc_,
+        &fwdConvWsSize_));
+
+    int group_offset_X = C / group_ * H * W * D;
+    int batch_offset_X = group_offset_X * group_;
+    int group_offset_Y = M / group_ * H_out * W_out * D_out;
+    int batch_offset_Y = group_offset_Y * group_;
+
+    if ((fwdConvWsSize_ > 0) && (fwdConvWs_ == nullptr)) {
+      HIP_CHECK(hipMalloc(&fwdConvWs_, fwdConvWsSize_));
+    }
+
+    while (!bestAlgoFound_) {
+      miopenConvAlgoPerf_t perf;
+      MIOPEN_ENFORCE(miopenFindConvolutionForwardAlgorithm(
+          miopen_wrapper_.inline_miopen_handle(),
+          bottom_desc_,
+          X.template data<T_X>(),
+          weight_desc_,
+          Weight.template data<T_W>(),
+          conv_desc_,
+          top_desc_,
+          Y->template mutable_data<T_Y>(),
+          requestAlgoCount_,
+          &returnedAlgoCount_,
+          &perf,
+          fwdConvWs_,
+          fwdConvWsSize_,
+          false));
+      bestAlgoFound_ = true;
+      fwdAlgo_ = perf.fwd_algo;
+    }
+
+    for (int b = 0; b < N; b++) {
+      for (int g = 0; g < group_; g++) {
+        MIOPEN_ENFORCE(miopenConvolutionForward(
+            miopen_wrapper_.inline_miopen_handle(),
+            &alpha_,
+            bottom_desc_,
+            X.template data<T_X>() + (b * batch_offset_X) +
+                (g * group_offset_X),
+            weight_desc_,
+            Weight.template data<T_W>() + g * group_offset_filter,
+            conv_desc_,
+            fwdAlgo_,
+            &beta_,
+            top_desc_,
+            Y->template mutable_data<T_Y>() + (b * batch_offset_Y) +
+                (g * group_offset_Y),
+            fwdConvWs_,
+            fwdConvWsSize_));
+      }
+    }
+    hipDeviceSynchronize();
+
+    // BIAS
+    if (InputSize() == 3) {
+      auto& bias = Input(BIAS);
+
+      CAFFE_ENFORCE_EQ(bias.ndim(), 1);
+      CAFFE_ENFORCE_EQ(bias.dim32(0), M);
+      MIOPEN_ENFORCE(miopenConvolutionForwardBias(
+          miopen_wrapper_.inline_miopen_handle(),
+          &alpha_,
+          bias_desc_,
+          bias.template data<T_B>(),
+          &beta_,
+          top_desc_for_bias_,
+          Y->template mutable_data<T_Y>()));
+    }
+
+    hipDeviceSynchronize();
+  } else {
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        weight_desc_,
+        miopenTypeWrapper<T_W>::type,
+        M,
+        C,
+        kernel_h(),
+        kernel_w()));
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        bottom_desc_, miopenTypeWrapper<T_X>::type, N, C, H, W));
+
+    MIOPEN_ENFORCE(miopenGetConvolutionForwardOutputDim(
+        conv_desc_,
+        bottom_desc_,
+        weight_desc_,
+        &N_out,
+        &C_out,
+        &H_out,
+        &W_out));
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        top_desc_, miopenTypeWrapper<T_X>::type, N_out, C_out, H_out, W_out));
+
+    if (InputSize() == 3) {
+      MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+          bias_desc_, miopenTypeWrapper<T_B>::type, 1, C_out, 1, 1));
+    }
+
+    MIOPEN_ENFORCE(miopenConvolutionForwardGetWorkSpaceSize(
+        miopen_wrapper_.inline_miopen_handle(),
+        weight_desc_,
+        bottom_desc_,
+        conv_desc_,
+        top_desc_,
+        &fwdConvWsSize_));
+
+    if ((fwdConvWsSize_ > 0) && (fwdConvWs_ == nullptr)) {
+      HIP_CHECK(hipMalloc(&fwdConvWs_, fwdConvWsSize_));
+    }
+
+    while (!bestAlgoFound_) {
+      miopenConvAlgoPerf_t perf;
+      MIOPEN_ENFORCE(miopenFindConvolutionForwardAlgorithm(
+          miopen_wrapper_.inline_miopen_handle(),
+          bottom_desc_,
+          X.template data<T_X>(),
+          weight_desc_,
+          Weight.template data<T_W>(),
+          conv_desc_,
+          top_desc_,
+          Y->template mutable_data<T_Y>(),
+          requestAlgoCount_,
+          &returnedAlgoCount_,
+          &perf,
+          fwdConvWs_,
+          fwdConvWsSize_,
+          false));
+      bestAlgoFound_ = true;
+      fwdAlgo_ = perf.fwd_algo;
+    }
+    MIOPEN_ENFORCE(miopenConvolutionForward(
+        miopen_wrapper_.inline_miopen_handle(),
+        &alpha_,
+        bottom_desc_,
+        X.template data<T_X>(),
+        weight_desc_,
+        Weight.template data<T_W>(),
+        conv_desc_,
+        fwdAlgo_,
+        &beta_,
+        top_desc_,
+        Y->template mutable_data<T_Y>(),
+        fwdConvWs_,
+        fwdConvWsSize_));
+
+    // BIAS
+    if (InputSize() == 3) {
+      auto& bias = Input(BIAS);
+
+      CAFFE_ENFORCE_EQ(bias.ndim(), 1);
+      CAFFE_ENFORCE_EQ(bias.dim32(0), M);
+      MIOPEN_ENFORCE(miopenConvolutionForwardBias(
+          miopen_wrapper_.inline_miopen_handle(),
+          &alpha_,
+          bias_desc_,
+          bias.template data<T_B>(),
+          &beta_,
+          top_desc_,
+          Y->template mutable_data<T_Y>()));
+    }
+
+    hipDeviceSynchronize();
+  }
+
+  return true;
+}
+// TODO : enable fp16 support.
+bool MIOPENConvOp::RunOnDevice() {
+  if (Input(0).IsType<float>()) {
+    return DoRunWithType<
+        float, // X
+        float, // W
+        float, // B
+        float, // Math
+        float>(); // Y
+  } else {
+    LOG(FATAL) << "Only float (32bit) is supported by "
+               << "miopen convolution, but input " << debug_def().input(0)
+               << " has [" << Input(0).meta().name() << "]";
+  }
+  return true;
+}
+
+template <
+    typename T_X,
+    typename T_DY,
+    typename T_W,
+    typename T_B,
+    typename MATH,
+    typename T_DX,
+    typename T_DW,
+    typename T_DB>
+bool MIOPENConvGradientOp::DoRunWithType() {
+  auto& X = Input(INPUT);
+  auto& Weight = Input(FILTER);
+  auto& dY = Input(OUTPUT_GRAD);
+  auto* dW = Output(FILTER_GRAD);
+  auto* dX = Output(no_bias_ ? BIAS_OR_INPUT_GRAD : INPUT_GRAD);
+  dX->ResizeLike(X);
+  dW->ResizeLike(Weight);
+
+  CAFFE_ENFORCE(X.ndim() >= 3 && X.ndim() <= 5);
+  CAFFE_ENFORCE(
+      Weight.ndim() == 4,
+      "ConvGradient/TransGradient op with MIOpen engine is supported only for 2D convolutions");
+
+  const int M = Weight.dim32(0);
+  int N = 0, C = 0, H = 0, W = 0, D = 0, N_out = 0, C_out = 0, H_out = 0,
+      W_out = 0, D_out = 0;
+
+  N = X.dim32(0);
+  C = X.dim32(1);
+  H = X.dim32(2);
+  W = X.ndim() > 3 ? X.dim32(3) : 1;
+  D = X.ndim() > 4 ? X.dim32(4) : 1;
+
+  N_out = dY.dim32(0);
+  C_out = dY.dim32(1);
+  H_out = dY.dim32(2);
+  W_out = dY.ndim() > 3 ? dY.dim32(3) : 1;
+  D_out = dY.ndim() > 4 ? dY.dim32(4) : 1;
+
+  CAFFE_ENFORCE_EQ(Weight.dim32(1), C / group_);
+
+  CAFFE_ENFORCE(
+      C % group_ == 0,
+      "If you set group, the number of input channels should be divisible "
+      "by group.");
+  CAFFE_ENFORCE(
+      M % group_ == 0,
+      "If you set group, the number of output channels should be divisible "
+      "by group.");
+
+  if (group_ > 1) {
+    int group_offset_filter = Weight.size() / group_;
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        weight_desc_,
+        miopenTypeWrapper<T_X>::type,
+        M / group_,
+        C / group_,
+        kernel_h(),
+        kernel_w()));
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        bottom_desc_, miopenTypeWrapper<T_X>::type, 1, C / group_, H, W));
+
+    MIOPEN_ENFORCE(miopenGetConvolutionForwardOutputDim(
+        conv_desc_,
+        bottom_desc_,
+        weight_desc_,
+        &N_out,
+        &C_out,
+        &H_out,
+        &W_out));
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        top_desc_, miopenTypeWrapper<T_X>::type, N_out, C_out, H_out, W_out));
+
+    if (!no_bias_) {
+      MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+          bias_desc_, miopenTypeWrapper<T_B>::type, 1, M, 1, 1));
+      MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+          top_desc_for_bias_,
+          miopenTypeWrapper<T_X>::type,
+          dY.dim32(0),
+          M,
+          H_out,
+          W_out));
+    }
+
+    MIOPEN_ENFORCE(miopenConvolutionBackwardDataGetWorkSpaceSize(
+        miopen_wrapper_.inline_miopen_handle(),
+        top_desc_,
+        weight_desc_,
+        conv_desc_,
+        bottom_desc_,
+        &bwdDataWsSize_));
+
+    int group_offset_X = C / group_ * H * W * D;
+    int batch_offset_X = group_offset_X * group_;
+    int group_offset_Y = M / group_ * H_out * W_out * D_out;
+    int batch_offset_Y = group_offset_Y * group_;
+
+    if ((bwdDataWsSize_ > 0) && (bwdDataWs_ == nullptr)) {
+      HIP_CHECK(hipMalloc(&bwdDataWs_, bwdDataWsSize_));
+    }
+
+    MIOPEN_ENFORCE(miopenConvolutionBackwardWeightsGetWorkSpaceSize(
+        miopen_wrapper_.inline_miopen_handle(),
+        top_desc_,
+        bottom_desc_,
+        conv_desc_,
+        weight_desc_,
+        &bwdWeightWsSize_));
+
+    if ((bwdWeightWsSize_ > 0) && (bwdWeightWs_ == nullptr)) {
+      HIP_CHECK(hipMalloc(&bwdWeightWs_, bwdWeightWsSize_));
+    }
+
+    while (!bestDataAlgoFound_) {
+      miopenConvAlgoPerf_t perf;
+      MIOPEN_ENFORCE(miopenFindConvolutionBackwardDataAlgorithm(
+          miopen_wrapper_.inline_miopen_handle(),
+          top_desc_,
+          dY.template data<T_DY>(),
+          weight_desc_,
+          Weight.template data<T_W>(),
+          conv_desc_,
+          bottom_desc_,
+          dX->template mutable_data<T_DX>(),
+          requestAlgoCount_,
+          &returnedAlgoCount_,
+          &perf,
+          bwdDataWs_,
+          bwdDataWsSize_,
+          false));
+
+      bestDataAlgoFound_ = true;
+      bwdDataAlgo_ = perf.bwd_data_algo;
+    }
+
+    while (!bestWeightAlgoFound_) {
+      miopenConvAlgoPerf_t perf;
+      MIOPEN_ENFORCE(miopenFindConvolutionBackwardWeightsAlgorithm(
+          miopen_wrapper_.inline_miopen_handle(),
+          top_desc_,
+          dY.template data<T_DY>(),
+          bottom_desc_,
+          X.template data<T_X>(),
+          conv_desc_,
+          weight_desc_,
+          dW->template mutable_data<T_DW>(),
+          requestAlgoCount_,
+          &returnedAlgoCount_,
+          &perf,
+          bwdWeightWs_,
+          bwdWeightWsSize_,
+          false));
+      bestWeightAlgoFound_ = true;
+      bwdWeiAlgo_ = perf.bwd_weights_algo;
+    }
+
+    for (int b = 0; b < N; b++) {
+      for (int g = 0; g < group_; g++) {
+        MIOPEN_ENFORCE(miopenConvolutionBackwardData(
+            miopen_wrapper_.inline_miopen_handle(),
+            &alpha_,
+            top_desc_,
+            dY.template data<T_DY>() + (b * batch_offset_Y) +
+                (g * group_offset_Y),
+            weight_desc_,
+            Weight.template data<T_W>() + g * group_offset_filter,
+            conv_desc_,
+            bwdDataAlgo_,
+            &beta_,
+            bottom_desc_,
+            dX->template mutable_data<T_DX>() + (b * batch_offset_X) +
+                (g * group_offset_X),
+            bwdDataWs_,
+            bwdDataWsSize_));
+
+        MIOPEN_ENFORCE(miopenConvolutionBackwardWeights(
+            miopen_wrapper_.inline_miopen_handle(),
+            &alpha_,
+            top_desc_,
+            dY.template data<T_DY>() + (b * batch_offset_Y) +
+                (g * group_offset_Y),
+            bottom_desc_,
+            X.template data<T_X>() + (b * batch_offset_X) +
+                (g * group_offset_X),
+            conv_desc_,
+            bwdWeiAlgo_,
+            &beta_,
+            weight_desc_,
+            dW->template mutable_data<T_DW>() + g * group_offset_filter,
+            bwdWeightWs_,
+            bwdWeightWsSize_));
+      }
+    }
+
+    // Synchronize the work across groups.
+    hipDeviceSynchronize();
+
+    ////////////////////////////////////// BIAS ///////////////////////////
+    if (!no_bias_) {
+      auto* dbias = Output(BIAS_OR_INPUT_GRAD);
+      dbias->Resize(M);
+      MIOPEN_ENFORCE(miopenConvolutionBackwardBias(
+          miopen_wrapper_.inline_miopen_handle(),
+          &alpha_,
+          top_desc_for_bias_,
+          dY.template data<T_DY>(),
+          &beta_,
+          bias_desc_,
+          dbias->template mutable_data<T_DB>()));
+    }
+  } else // No group
+  {
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        weight_desc_,
+        miopenTypeWrapper<T_X>::type,
+        M,
+        C,
+        kernel_h(),
+        kernel_w()));
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        bottom_desc_, miopenTypeWrapper<T_X>::type, N, C, H, W));
+
+    MIOPEN_ENFORCE(miopenGetConvolutionForwardOutputDim(
+        conv_desc_,
+        bottom_desc_,
+        weight_desc_,
+        &N_out,
+        &C_out,
+        &H_out,
+        &W_out));
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        top_desc_, miopenTypeWrapper<T_X>::type, N_out, C_out, H_out, W_out));
+
+    if (!no_bias_) {
+      MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+          bias_desc_, miopenTypeWrapper<T_B>::type, 1, M, 1, 1));
+    }
+
+    MIOPEN_ENFORCE(miopenConvolutionBackwardDataGetWorkSpaceSize(
+        miopen_wrapper_.inline_miopen_handle(),
+        top_desc_,
+        weight_desc_,
+        conv_desc_,
+        bottom_desc_,
+        &bwdDataWsSize_));
+
+    if ((bwdDataWsSize_ > 0) && (bwdDataWs_ == nullptr)) {
+      HIP_CHECK(hipMalloc(&bwdDataWs_, bwdDataWsSize_));
+    }
+
+    MIOPEN_ENFORCE(miopenConvolutionBackwardWeightsGetWorkSpaceSize(
+        miopen_wrapper_.inline_miopen_handle(),
+        top_desc_,
+        bottom_desc_,
+        conv_desc_,
+        weight_desc_,
+        &bwdWeightWsSize_));
+
+    if ((bwdWeightWsSize_ > 0) && (bwdWeightWs_ == nullptr)) {
+      HIP_CHECK(hipMalloc(&bwdWeightWs_, bwdWeightWsSize_));
+    }
+
+    while (!bestDataAlgoFound_) {
+      miopenConvAlgoPerf_t perf;
+      MIOPEN_ENFORCE(miopenFindConvolutionBackwardDataAlgorithm(
+          miopen_wrapper_.inline_miopen_handle(),
+          top_desc_,
+          dY.template data<T_DY>(),
+          weight_desc_,
+          Weight.template data<T_W>(),
+          conv_desc_,
+          bottom_desc_,
+          dX->template mutable_data<T_DX>(),
+          requestAlgoCount_,
+          &returnedAlgoCount_,
+          &perf,
+          bwdDataWs_,
+          bwdDataWsSize_,
+          false));
+
+      bestDataAlgoFound_ = true;
+      bwdDataAlgo_ = perf.bwd_data_algo;
+    }
+
+    while (!bestWeightAlgoFound_) {
+      miopenConvAlgoPerf_t perf;
+      MIOPEN_ENFORCE(miopenFindConvolutionBackwardWeightsAlgorithm(
+          miopen_wrapper_.inline_miopen_handle(),
+          top_desc_,
+          dY.template data<T_DY>(),
+          bottom_desc_,
+          X.template data<T_X>(),
+          conv_desc_,
+          weight_desc_,
+          dW->template mutable_data<T_DW>(),
+          requestAlgoCount_,
+          &returnedAlgoCount_,
+          &perf,
+          bwdWeightWs_,
+          bwdWeightWsSize_,
+          false));
+      bestWeightAlgoFound_ = true;
+      bwdWeiAlgo_ = perf.bwd_weights_algo;
+    }
+
+    MIOPEN_ENFORCE(miopenConvolutionBackwardData(
+        miopen_wrapper_.inline_miopen_handle(),
+        &alpha_,
+        top_desc_,
+        dY.template data<T_DY>(),
+        weight_desc_,
+        Weight.template data<T_W>(),
+        conv_desc_,
+        bwdDataAlgo_,
+        &beta_,
+        bottom_desc_,
+        dX->template mutable_data<T_DX>(),
+        bwdDataWs_,
+        bwdDataWsSize_));
+
+    MIOPEN_ENFORCE(miopenConvolutionBackwardWeights(
+        miopen_wrapper_.inline_miopen_handle(),
+        &alpha_,
+        top_desc_,
+        dY.template data<T_DY>(),
+        bottom_desc_,
+        X.template data<T_X>(),
+        conv_desc_,
+        bwdWeiAlgo_,
+        &beta_,
+        weight_desc_,
+        dW->template mutable_data<T_DW>(),
+        bwdWeightWs_,
+        bwdWeightWsSize_));
+
+    // Synchronize the work across groups.
+    hipDeviceSynchronize();
+
+    ////////////////////////////////////// BIAS ///////////////////////////
+    if (!no_bias_) {
+      auto* dbias = Output(BIAS_OR_INPUT_GRAD);
+      dbias->Resize(M);
+      MIOPEN_ENFORCE(miopenConvolutionBackwardBias(
+          miopen_wrapper_.inline_miopen_handle(),
+          &alpha_,
+          top_desc_,
+          dY.template data<T_DY>(),
+          &beta_,
+          bias_desc_,
+          dbias->template mutable_data<T_DB>()));
+    }
+  }
+
+  return true;
+}
+
+bool MIOPENConvGradientOp::RunOnDevice() {
+  if (Input(0).IsType<float>()) {
+    return DoRunWithType<
+        float, //  X
+        float, // dY
+        float, //  W
+        float, //  b
+        float, // Math
+        float, // dX
+        float, // dW
+        float>(); // db
+  } else {
+    LOG(FATAL) << "Unsupported input types";
+  }
+  return true;
+}
+
+REGISTER_MIOPEN_OPERATOR(Conv, MIOPENConvOp);
+REGISTER_MIOPEN_OPERATOR(ConvGradient, MIOPENConvGradientOp);
+REGISTER_MIOPEN_OPERATOR(Trans, MIOPENConvOp);
+REGISTER_MIOPEN_OPERATOR(TransGradient, MIOPENConvGradientOp);
+} // namespace caffe2
diff --git a/caffe2/operators/hip/local_response_normalization_op_miopen.cc b/caffe2/operators/hip/local_response_normalization_op_miopen.cc
new file mode 100644
index 0000000000000..26da9bf5b8742
--- /dev/null
+++ b/caffe2/operators/hip/local_response_normalization_op_miopen.cc
@@ -0,0 +1,248 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "caffe2/core/hip/context_hip.h"
+#include "caffe2/core/hip/miopen_wrapper.h"
+#include "caffe2/core/operator.h"
+#include "caffe2/core/types.h"
+
+namespace caffe2 {
+
+class MIOPEN_LRNOP final : public Operator<HIPContext> {
+ public:
+  USE_OPERATOR_FUNCTIONS(HIPContext);
+
+  MIOPEN_LRNOP(const OperatorDef& operator_def, Workspace* ws)
+      : Operator<HIPContext>(operator_def, ws),
+        miopen_wrapper_(&context_),
+        mode_(miopenLRNCrossChannel),
+        size_(OperatorBase::GetSingleArgument<int>("size", 0)),
+        alpha_(OperatorBase::GetSingleArgument<float>("alpha", 0)),
+        beta_(OperatorBase::GetSingleArgument<float>("beta", 0)),
+        bias_(OperatorBase::GetSingleArgument<float>("bias", 1)) {
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&data_desc_));
+    MIOPEN_ENFORCE(miopenCreateLRNDescriptor(&norm_desc_));
+    MIOPEN_ENFORCE(
+        miopenSetLRNDescriptor(norm_desc_, mode_, size_, alpha_, beta_, bias_));
+  }
+
+  ~MIOPEN_LRNOP() {
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(data_desc_));
+    MIOPEN_ENFORCE(miopenDestroyLRNDescriptor(norm_desc_));
+  }
+
+  template <typename T, typename M>
+  bool DoRunWithType();
+  bool RunOnDevice() override;
+
+ protected:
+  MIOPENWrapper miopen_wrapper_;
+  miopenTensorDescriptor_t data_desc_;
+  miopenLRNDescriptor_t norm_desc_;
+  vector<TIndex> miopen_input_dims_;
+  const miopenLRNMode_t mode_;
+  const int size_;
+  const float alpha_;
+  const float beta_;
+  const float bias_;
+  // Input: X, Output: Y
+};
+
+class MIOPENLRNGradientOp final : public Operator<HIPContext> {
+ public:
+  USE_OPERATOR_FUNCTIONS(HIPContext);
+  MIOPENLRNGradientOp(const OperatorDef& operator_def, Workspace* ws)
+      : Operator<HIPContext>(operator_def, ws),
+        miopen_wrapper_(&context_),
+        mode_(miopenLRNCrossChannel),
+        size_(OperatorBase::GetSingleArgument<int>("size", 0)),
+        alpha_(OperatorBase::GetSingleArgument<float>("alpha", 0)),
+        beta_(OperatorBase::GetSingleArgument<float>("beta", 0)),
+        bias_(OperatorBase::GetSingleArgument<float>("bias", 1)),
+        do_backward_(
+            OperatorBase::GetSingleArgument<bool>("do_backward", false)),
+        bwdLRNWs_(nullptr),
+        bwdLRNScratch_(nullptr) {
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&data_desc_));
+    MIOPEN_ENFORCE(miopenCreateLRNDescriptor(&norm_desc_));
+    MIOPEN_ENFORCE(
+        miopenSetLRNDescriptor(norm_desc_, mode_, size_, alpha_, beta_, bias_));
+  }
+
+  ~MIOPENLRNGradientOp() {
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(data_desc_));
+    MIOPEN_ENFORCE(miopenDestroyLRNDescriptor(norm_desc_));
+
+    if (bwdLRNWs_) {
+      hipFree(bwdLRNWs_);
+      bwdLRNWs_ = nullptr;
+    }
+    if (bwdLRNScratch_) {
+      hipFree(bwdLRNScratch_);
+      bwdLRNScratch_ = nullptr;
+    }
+  }
+
+  template <typename T, typename M>
+  bool DoRunWithType();
+  bool RunOnDevice() override;
+
+ protected:
+  MIOPENWrapper miopen_wrapper_;
+  miopenTensorDescriptor_t data_desc_;
+  miopenLRNDescriptor_t norm_desc_;
+  vector<TIndex> miopen_input_dims_;
+  const miopenLRNMode_t mode_;
+  const int size_;
+  const float alpha_;
+  const float beta_;
+  const float bias_;
+  const bool do_backward_;
+  float* bwdLRNWs_;
+  float* bwdLRNScratch_;
+  // Input: X, Y, dY
+  // Output: dX
+};
+
+template <typename T, typename M>
+bool MIOPEN_LRNOP::DoRunWithType() {
+  const auto& X = Input(0);
+  auto* Y = Output(0);
+
+  // Reshape tensor descriptors if necessary
+  if (X.dims() != miopen_input_dims_) {
+    VLOG(1) << "Setting descriptors";
+    miopen_input_dims_ = X.dims();
+    int C = 1, H = 1, W = 1;
+    // Normal 4-dimensional tensors for images.
+    C = X.dim32(1);
+    H = X.dim32(2);
+    W = X.dim32(3);
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        data_desc_, miopenTypeWrapper<T>::type, X.dim32(0), C, H, W));
+  }
+
+  // now actually run the computation
+  MIOPEN_ENFORCE(miopenLRNForward(
+      miopen_wrapper_.inline_miopen_handle(),
+      norm_desc_,
+      &alpha_,
+      data_desc_,
+      X.template data<T>(),
+      &beta_,
+      data_desc_,
+      Y->template mutable_data<T>(),
+      false,
+      nullptr));
+
+  return true;
+}
+
+bool MIOPEN_LRNOP::RunOnDevice() {
+  // dispatch based on contents of tensor(s)
+  const auto& X = Input(0);
+  auto* Y = Output(0);
+  Y->ResizeLike(X);
+
+  if (X.IsType<float>()) {
+    return DoRunWithType<float, float>();
+  } else {
+    CAFFE_THROW("Unsupported input type");
+  }
+  return false;
+}
+
+template <typename T, typename M>
+bool MIOPENLRNGradientOp::DoRunWithType() {
+  const auto& X = Input(0);
+  const auto& Y = Input(1);
+  const auto& dY = Input(2);
+  auto* dX = Output(0);
+
+  if (dY.dims() != miopen_input_dims_) {
+    VLOG(1) << "Setting descriptors";
+    miopen_input_dims_ = dY.dims();
+    int C = 1, H = 1, W = 1;
+    // Normal 4-dimensional tensors for images.
+    C = dY.dim32(1);
+    H = dY.dim32(2);
+    W = dY.dim32(3);
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        data_desc_, miopenTypeWrapper<T>::type, dY.dim32(0), C, H, W));
+  }
+
+  size_t ws_size = 0;
+  MIOPEN_ENFORCE(miopenLRNGetWorkSpaceSize(data_desc_, &ws_size));
+  if (bwdLRNWs_ == nullptr) {
+    HIP_CHECK(hipMalloc(&bwdLRNWs_, ws_size));
+  }
+
+  // Run fwd pass to populate workspace
+  if (bwdLRNScratch_ == nullptr) {
+    HIP_CHECK(hipMalloc(&bwdLRNScratch_, X.size() * sizeof(float)));
+  }
+  MIOPEN_ENFORCE(miopenLRNForward(
+      miopen_wrapper_.inline_miopen_handle(),
+      norm_desc_,
+      &alpha_,
+      data_desc_,
+      X.template data<T>(),
+      &beta_,
+      data_desc_,
+      bwdLRNScratch_,
+      true,
+      bwdLRNWs_));
+
+  // Run the bwd computation
+  MIOPEN_ENFORCE(miopenLRNBackward(
+      miopen_wrapper_.inline_miopen_handle(),
+      norm_desc_,
+      &alpha_,
+      data_desc_,
+      Y.template data<T>(),
+      data_desc_,
+      dY.template data<T>(),
+      data_desc_,
+      X.template data<T>(),
+      &beta_,
+      data_desc_,
+      dX->template mutable_data<T>(),
+      bwdLRNWs_));
+  return true;
+}
+
+bool MIOPENLRNGradientOp::RunOnDevice() {
+  // dispatch based on contents of tensor(s)
+  const auto& X = Input(0);
+  const auto& Y = Input(1);
+  const auto& dY = Input(2);
+  auto* dX = Output(0);
+
+  dX->ResizeLike(dY);
+
+  if (dY.IsType<float>()) {
+    return DoRunWithType<float, float>();
+  } else {
+    CAFFE_THROW("Unsupported input type");
+  }
+  return false;
+}
+
+namespace {
+REGISTER_MIOPEN_OPERATOR(LRN, MIOPEN_LRNOP);
+REGISTER_MIOPEN_OPERATOR(LRNGradient, MIOPENLRNGradientOp);
+} // namespace
+
+}; // namespace caffe2
diff --git a/caffe2/operators/hip/operator_fallback_hip.h b/caffe2/operators/hip/operator_fallback_hip.h
new file mode 100644
index 0000000000000..62e5fe8f01e5d
--- /dev/null
+++ b/caffe2/operators/hip/operator_fallback_hip.h
@@ -0,0 +1,114 @@
+#ifndef CAFFE2_OPERATORS_OPERATOR_FALLBACK_H_
+#define CAFFE2_OPERATORS_OPERATOR_FALLBACK_H_
+
+#include "caffe2/core/common.h"
+#include "caffe2/core/context.h"
+#include "caffe2/core/hip/context_hip.h"
+#include "caffe2/core/operator.h"
+#include "caffe2/proto/caffe2.pb.h"
+
+namespace caffe2 {
+
+/**
+ * @brief A templated class to allow one to wrap a CPU operator as a CUDA
+ * operator.
+ *
+ * This class can be used when one does not have the CUDA implementation ready
+ * yet for an operator. Essentially, what this op does is to automatically
+ * deal with data copy for you. Plausibly, this causes a lot of overhead and
+ * is not optimal, so you should use this operator mostly for quick prototyping
+ * purpose.
+ *
+ * All the input and output of the original operator should be TensorCPU.
+ *
+ * Example usage: if you have a class MyMagicOp that is CPU based, and you use
+ * the registration code
+ *     REGISTER_CPU_OPERATOR(MyMagic, MyMagicOp);
+ * to register the CPU side, you can create its corresponding GPU operator
+ * (with performance hits of course) via
+ *     REGISTER_HIP_OPERATOR(MyMagic,
+ *                            GPUFallbackOp<MyMagicOp>);
+ *
+ * Advanced usage: if you want to have some specific outputs never copied, you
+ * can use the SkipOutputCopy template argument to do that. For example, if
+ * MyMagic produces two outputs and the first output is always going to live on
+ * the CPU, you can do
+ *     REGISTER_HIP_OPERATOR(MyMagic,
+ *                            GPUFallbackOp<MyMagicOp, SkipIndices<0>>);
+ */
+template <class CPUOp, typename SkipOutputCopy = SkipIndices<>>
+class GPUFallbackOp final : public Operator<HIPContext> {
+ public:
+  USE_OPERATOR_FUNCTIONS(HIPContext);
+  GPUFallbackOp(const OperatorDef& def, Workspace* ws)
+      : Operator<HIPContext>(def, ws) {
+    CAFFE_ENFORCE_EQ(def.device_option().device_type(), HIP);
+    OperatorDef base_def_(def);
+    // base_def_ runs on CPU, so we will set its device option to CPU.
+    base_def_.clear_device_option();
+    base_def_.mutable_device_option()->set_device_type(CPU);
+    // Set up the symbols for the local workspace.
+    for (const string& name : def.input()) {
+      local_input_blobs_.push_back(local_ws_.CreateBlob(name));
+      CHECK_NOTNULL(local_input_blobs_.back());
+    }
+    base_op_.reset(new CPUOp(base_def_, &local_ws_));
+    for (const string& name : def.output()) {
+      local_output_blobs_.push_back(local_ws_.GetBlob(name));
+      CHECK_NOTNULL(local_output_blobs_.back());
+    }
+  }
+
+  bool RunOnDevice() override {
+    bool need_sync = false;
+    for (int i = 0; i < InputSize(); ++i) {
+      if (OperatorBase::InputIsType<TensorHIP>(i)) {
+        local_input_blobs_[i]->template GetMutable<TensorCPU>()->CopyFrom(
+            Input(i), &context_);
+        need_sync = true;
+      } else {
+        VLOG(1) << "Input " << i << " is not TensorHIP. Skipping copy.";
+        // Note(jiayq): This removes a const but conceptually
+        // local_input_blobs will only be used as const blob input for the
+        // base op so we are still fine.
+        local_input_blobs_[i]->ShareExternal(
+            const_cast<void*>(OperatorBase::Inputs()[i]->GetRaw()),
+            OperatorBase::Inputs()[i]->meta());
+      }
+    }
+
+    // Sync to make sure copies are done.
+    if (need_sync) {
+      context_.FinishDeviceComputation();
+    }
+
+    if (!base_op_->Run()) {
+      LOG(ERROR) << "Base op run failed in GPUFallbackOp. Def: "
+                 << ProtoDebugString(this->debug_def());
+      return false;
+    }
+    for (int i = 0; i < OutputSize(); ++i) {
+      if (SkipOutputCopy::Contains(i)) {
+        VLOG(1) << "Copy output: index " << i << " skipped.";
+        continue;
+      }
+      CAFFE_ENFORCE(
+          local_output_blobs_[i]->template IsType<TensorCPU>(),
+          "GPU fallback op currently does not support non-TensorCPU "
+          "output type who needs copying.");
+      Output(i)->CopyFrom(
+          local_output_blobs_[i]->template Get<TensorCPU>(), &context_);
+    }
+    return true;
+  }
+
+ protected:
+  Workspace local_ws_;
+  vector<Blob*> local_input_blobs_;
+  vector<Blob*> local_output_blobs_;
+  std::unique_ptr<CPUOp> base_op_;
+};
+
+} // namespace caffe2
+
+#endif // CAFFE2_OPERATORS_OPERATOR_FALLBACK_H_
diff --git a/caffe2/operators/hip/operator_fallback_hip_test.cc b/caffe2/operators/hip/operator_fallback_hip_test.cc
new file mode 100644
index 0000000000000..4a074c35f8a18
--- /dev/null
+++ b/caffe2/operators/hip/operator_fallback_hip_test.cc
@@ -0,0 +1,80 @@
+#include <iostream>
+
+#include <gtest/gtest.h>
+#include "caffe2/core/operator.h"
+#include "caffe2/operators/hip/operator_fallback_hip.h"
+
+namespace caffe2 {
+
+class IncrementByOneOp final : public Operator<CPUContext> {
+ public:
+  IncrementByOneOp(const OperatorDef& def, Workspace* ws)
+      : Operator<CPUContext>(def, ws) {}
+  bool RunOnDevice() {
+    const auto& in = Input(0);
+    auto* out = Output(0);
+    out->ResizeLike(in);
+    const float* in_data = in.template data<float>();
+    float* out_data = out->template mutable_data<float>();
+    for (int i = 0; i < in.size(); ++i) {
+      out_data[i] = in_data[i] + 1.f;
+    }
+    return true;
+  }
+};
+
+OPERATOR_SCHEMA(IncrementByOne)
+    .NumInputs(1)
+    .NumOutputs(1)
+    .AllowInplace({{0, 0}});
+
+REGISTER_CPU_OPERATOR(IncrementByOne, IncrementByOneOp);
+REGISTER_HIP_OPERATOR(IncrementByOne, GPUFallbackOp<IncrementByOneOp>);
+
+TEST(OperatorFallbackTest, IncrementByOneOp) {
+  OperatorDef op_def = CreateOperatorDef(
+      "IncrementByOne", "", vector<string>{"X"}, vector<string>{"X"});
+  Workspace ws;
+  TensorCPU source_tensor(vector<TIndex>{2, 3});
+  for (int i = 0; i < 6; ++i) {
+    source_tensor.mutable_data<float>()[i] = i;
+  }
+  ws.CreateBlob("X")->GetMutable<TensorCPU>()->CopyFrom(source_tensor);
+  unique_ptr<OperatorBase> op(CreateOperator(op_def, &ws));
+  EXPECT_TRUE(op.get() != nullptr);
+  EXPECT_TRUE(op->Run());
+  const TensorCPU& output = ws.GetBlob("X")->Get<TensorCPU>();
+  EXPECT_EQ(output.ndim(), 2);
+  EXPECT_EQ(output.dim(0), 2);
+  EXPECT_EQ(output.dim(1), 3);
+  for (int i = 0; i < 6; ++i) {
+    EXPECT_EQ(output.data<float>()[i], i + 1);
+  }
+}
+
+TEST(OperatorFallbackTest, GPUIncrementByOneOp) {
+  if (!HasHipGPU())
+    return;
+  OperatorDef op_def = CreateOperatorDef(
+      "IncrementByOne", "", vector<string>{"X"}, vector<string>{"X"});
+  op_def.mutable_device_option()->set_device_type(HIP);
+  Workspace ws;
+  TensorCPU source_tensor(vector<TIndex>{2, 3});
+  for (int i = 0; i < 6; ++i) {
+    source_tensor.mutable_data<float>()[i] = i;
+  }
+  ws.CreateBlob("X")->GetMutable<TensorHIP>()->CopyFrom(source_tensor);
+  unique_ptr<OperatorBase> op(CreateOperator(op_def, &ws));
+  EXPECT_TRUE(op.get() != nullptr);
+  EXPECT_TRUE(op->Run());
+  const TensorHIP& output = ws.GetBlob("X")->Get<TensorHIP>();
+  TensorCPU output_cpu(output);
+  EXPECT_EQ(output.ndim(), 2);
+  EXPECT_EQ(output.dim(0), 2);
+  EXPECT_EQ(output.dim(1), 3);
+  for (int i = 0; i < 6; ++i) {
+    EXPECT_EQ(output_cpu.data<float>()[i], i + 1);
+  }
+}
+
+} // namespace caffe2
diff --git a/caffe2/operators/hip/pool_op_miopen.cc b/caffe2/operators/hip/pool_op_miopen.cc
new file mode 100644
index 0000000000000..9f9e7f930e758
--- /dev/null
+++ b/caffe2/operators/hip/pool_op_miopen.cc
@@ -0,0 +1,310 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "caffe2/core/hip/context_hip.h"
+#include "caffe2/core/hip/miopen_wrapper.h"
+#include "caffe2/operators/conv_pool_op_base.h"
+
+namespace caffe2 {
+class MIOPENPoolOp : public ConvPoolOpBase<HIPContext> {
+ public:
+  MIOPENPoolOp(const OperatorDef& operator_def, Workspace* ws)
+      : ConvPoolOpBase<HIPContext>(operator_def, ws),
+        miopen_wrapper_(&context_),
+        alpha_(OperatorBase::GetSingleArgument<float>("alpha", 1.0)),
+        beta_(OperatorBase::GetSingleArgument<float>("beta", 0.0)),
+        do_backward_(
+            OperatorBase::GetSingleArgument<bool>("do_backward", true)),
+        poolWs_(nullptr),
+        poolWsSize_(0)
+
+  {
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&bottom_desc_));
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&top_desc_));
+    MIOPEN_ENFORCE(miopenCreatePoolingDescriptor(&pooling_desc_));
+
+    if ((operator_def.type().substr(0, 9) == "MaxPool") ||
+        (operator_def.type().substr(0, 17) == "MaxPoolGradient")) {
+      mode_ = miopenPoolingMax;
+    } else if (
+        (operator_def.type().substr(0, 13) == "AveragePool") ||
+        (operator_def.type().substr(0, 21) == "AveragePoolGradient")) {
+      mode_ = miopenPoolingAverage;
+    } else {
+      LOG(FATAL) << "Unsupported pooling method: " << operator_def.type();
+    }
+  }
+
+  ~MIOPENPoolOp() {
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(bottom_desc_));
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(top_desc_));
+    MIOPEN_ENFORCE(miopenDestroyPoolingDescriptor(pooling_desc_));
+    poolWsSize_ = 0;
+
+    if (poolWs_ != nullptr) {
+      hipFree(poolWs_);
+      poolWs_ = nullptr;
+    }
+  }
+
+  template <typename T, typename M>
+  bool DoRunWithType() {
+    auto& X = Input(0);
+    auto* Y = Output(0);
+    int N = 0, C = 0, H = 0, W = 0, D = 0;
+    int N_out = 0, C_out = 0, H_out = 0, W_out = 0;
+    CAFFE_ENFORCE(X.ndim() >= 4 && X.ndim() <= 5);
+    N = X.dim32(0);
+    C = X.dim32(1);
+    H = X.dim32(2);
+    W = X.ndim() > 3 ? X.dim32(3) : 1;
+    ConvPoolOpBase::SetOutputSize(X, Y, C);
+
+    N_out = Y->dim32(0);
+    C_out = Y->dim32(1);
+    H_out = Y->dim32(2);
+    W_out = Y->ndim() > 3 ? Y->dim32(3) : 1;
+
+    CAFFE_ENFORCE(kernel_.size() == 2, "MIOpen supports only 2D pooling");
+    MIOPEN_ENFORCE(miopenSet2dPoolingDescriptor(
+        pooling_desc_,
+        mode_,
+        kernel_h(),
+        kernel_w(),
+        pad_t(),
+        pad_l(),
+        stride_h(),
+        stride_w()));
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        bottom_desc_, miopenTypeWrapper<T>::type, N, C, H, W));
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        top_desc_, miopenTypeWrapper<T>::type, N_out, C_out, H_out, W_out));
+
+    MIOPEN_ENFORCE(miopenPoolingGetWorkSpaceSize(top_desc_, &poolWsSize_));
+
+    if ((poolWsSize_ > 0) && (poolWs_ == nullptr)) {
+      HIP_CHECK(hipMalloc(&poolWs_, poolWsSize_));
+    }
+
+    const T* Xdata = X.template data<T>();
+    T* Ydata = Y->template mutable_data<T>();
+    MIOPEN_ENFORCE(miopenPoolingForward(
+        miopen_wrapper_.inline_miopen_handle(),
+        pooling_desc_,
+        &alpha_,
+        bottom_desc_,
+        Xdata,
+        &beta_,
+        top_desc_,
+        Ydata,
+        do_backward_,
+        poolWs_,
+        poolWsSize_));
+
+    return true;
+  }
+
+  bool RunOnDevice() final {
+    auto& X = Input(0);
+    auto* Y = Output(0);
+    // TODO enable fp16
+    if (X.IsType<float>()) {
+      return DoRunWithType<float, float>();
+    } else {
+      LOG(FATAL) << "Unsupported input types";
+    }
+    return true;
+  }
+
+ protected:
+  size_t poolWsSize_;
+  char* poolWs_;
+  MIOPENWrapper miopen_wrapper_;
+  miopenTensorDescriptor_t bottom_desc_;
+  miopenTensorDescriptor_t top_desc_;
+  miopenPoolingDescriptor_t pooling_desc_;
+  miopenPoolingMode_t mode_;
+  bool do_backward_;
+  const float alpha_;
+  const float beta_;
+};
+
+class MIOPENPoolGradientOp : public ConvPoolOpBase<HIPContext> {
+ public:
+  MIOPENPoolGradientOp(const OperatorDef& operator_def, Workspace* ws)
+      : ConvPoolOpBase<HIPContext>(operator_def, ws),
+        miopen_wrapper_(&context_),
+        alpha_(OperatorBase::GetSingleArgument<float>("alpha", 1.0)),
+        beta_(OperatorBase::GetSingleArgument<float>("beta", 0.0)),
+        poolWs_(nullptr),
+        poolWsSize_(0),
+        bwdPoolScratch_(nullptr) {
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&bottom_desc_));
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&top_desc_));
+    MIOPEN_ENFORCE(miopenCreatePoolingDescriptor(&pooling_desc_));
+
+    if (operator_def.type().substr(0, 7) == "MaxPool") {
+      mode_ = miopenPoolingMax;
+    } else if (operator_def.type().substr(0, 11) == "AveragePool") {
+      mode_ = miopenPoolingAverage;
+    } else {
+      LOG(FATAL) << "Unsupported pooling method: " << operator_def.type();
+    }
+  }
+
+  ~MIOPENPoolGradientOp() {
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(bottom_desc_));
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(top_desc_));
+    MIOPEN_ENFORCE(miopenDestroyPoolingDescriptor(pooling_desc_));
+    poolWsSize_ = 0;
+
+    if (poolWs_ != nullptr) {
+      hipFree(poolWs_);
+      poolWs_ = nullptr;
+    }
+
+    if (bwdPoolScratch_) {
+      hipFree(bwdPoolScratch_);
+      bwdPoolScratch_ = nullptr;
+    }
+  }
+
+  template <typename T, typename M>
+  bool DoRunWithType() {
+    auto& X = Input(0);
+    auto& Y = Input(1);
+    auto& dY = Input(2);
+    auto* dX = Output(0);
+
+    // cuDNN pooling support only 2 and 3 spatial dimensions.
+    CAFFE_ENFORCE(X.ndim() >= 4 && X.ndim() <= 5);
+
+    dX->ResizeLike(X);
+    int N = 0, C = 0, H = 0, W = 0, D = 0;
+    int N_out = 0, C_out = 0, H_out = 0, W_out = 0, D_out = 0;
+    N = X.dim32(0);
+    C = X.dim32(1);
+    H = X.dim32(2);
+    W = X.ndim() > 3 ? X.dim32(3) : 1;
+    D = X.ndim() > 4 ? X.dim32(4) : 1;
+    N_out = Y.dim32(0);
+    C_out = Y.dim32(1);
+    H_out = Y.dim32(2);
+    W_out = Y.ndim() > 3 ? Y.dim32(3) : 1;
+    D_out = Y.ndim() > 4 ? Y.dim32(4) : 1;
+
+    CAFFE_ENFORCE(kernel_.size() == 2, "MIOpen supports only 2D pooling");
+    MIOPEN_ENFORCE(miopenSet2dPoolingDescriptor(
+        pooling_desc_,
+        mode_,
+        kernel_h(),
+        kernel_w(),
+        pad_t(),
+        pad_l(),
+        stride_h(),
+        stride_w()));
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        bottom_desc_, miopenTypeWrapper<T>::type, N, C, H, W));
+
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        top_desc_, miopenTypeWrapper<T>::type, N_out, C_out, H_out, W_out));
+
+    MIOPEN_ENFORCE(miopenPoolingGetWorkSpaceSize(top_desc_, &poolWsSize_));
+
+    if ((poolWsSize_ > 0) && (poolWs_ == nullptr)) {
+      HIP_CHECK(hipMalloc(&poolWs_, poolWsSize_));
+    }
+
+    if (bwdPoolScratch_ == nullptr) {
+      HIP_CHECK(hipMalloc(&bwdPoolScratch_, Y.size() * sizeof(float)));
+    }
+
+    // Carry out the pooling computation.
+    const T* Xdata = X.template data<T>();
+    const T* Ydata = Y.template data<T>();
+    const T* dYdata = dY.template data<T>();
+    T* dXdata = dX->template mutable_data<T>();
+
+    MIOPEN_ENFORCE(miopenPoolingForward(
+        miopen_wrapper_.inline_miopen_handle(),
+        pooling_desc_,
+        &alpha_,
+        bottom_desc_,
+        Xdata,
+        &beta_,
+        top_desc_,
+        bwdPoolScratch_,
+        true,
+        poolWs_,
+        poolWsSize_));
+
+    MIOPEN_ENFORCE(miopenPoolingBackward(
+        miopen_wrapper_.inline_miopen_handle(),
+        pooling_desc_,
+        &alpha_,
+        top_desc_,
+        Ydata,
+        top_desc_,
+        dYdata,
+        bottom_desc_,
+        Xdata,
+        &beta_,
+        bottom_desc_,
+        dXdata,
+        poolWs_));
+
+    return true;
+  }
+
+  bool RunOnDevice() final {
+    auto& X = Input(0);
+    auto& Y = Input(1);
+    auto& dY = Input(2);
+    auto* dX = Output(0);
+    dX->ResizeLike(X);
+
+    if (X.IsType<float>()) {
+      return DoRunWithType<float, float>();
+    } else {
+      LOG(FATAL) << "Unsupported input types";
+    }
+    return true;
+  }
+
+ protected:
+  size_t poolWsSize_;
+  char* poolWs_;
+  MIOPENWrapper miopen_wrapper_;
+  miopenTensorDescriptor_t bottom_desc_;
+  miopenTensorDescriptor_t top_desc_;
+  miopenPoolingDescriptor_t pooling_desc_;
+  miopenPoolingMode_t mode_;
+  const float alpha_;
+  const float beta_;
+  float* bwdPoolScratch_;
+};
+
+namespace {
+REGISTER_MIOPEN_OPERATOR(AveragePool, MIOPENPoolOp);
+REGISTER_MIOPEN_OPERATOR(AveragePoolGradient, MIOPENPoolGradientOp);
+
+REGISTER_MIOPEN_OPERATOR(MaxPool, MIOPENPoolOp);
+REGISTER_MIOPEN_OPERATOR(MaxPoolGradient, MIOPENPoolGradientOp);
+} // namespace
+} // namespace caffe2
diff --git a/caffe2/operators/hip/relu_op_miopen.cc b/caffe2/operators/hip/relu_op_miopen.cc
new file mode 100644
index 0000000000000..5a8a147ff2a89
--- /dev/null
+++ b/caffe2/operators/hip/relu_op_miopen.cc
@@ -0,0 +1,205 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "caffe2/core/hip/context_hip.h"
+#include "caffe2/core/hip/miopen_wrapper.h"
+#include "caffe2/core/operator.h"
+#include "caffe2/core/types.h"
+
+namespace caffe2 {
+
+class MIOPENReluOp final : public Operator<HIPContext> {
+ public:
+  MIOPENReluOp(const OperatorDef& operator_def, Workspace* ws)
+      : Operator<HIPContext>(operator_def, ws),
+        miopen_wrapper_(&context_),
+        alpha_(OperatorBase::GetSingleArgument<float>("alpha", 1.0)),
+        beta_(OperatorBase::GetSingleArgument<float>("beta", 0.0)),
+        power_(OperatorBase::GetSingleArgument<double>("power", 1.0)) {
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&data_desc_));
+    MIOPEN_ENFORCE(miopenCreateActivationDescriptor(&activ_desc_));
+    MIOPEN_ENFORCE(miopenSetActivationDescriptor(
+        activ_desc_, miopenActivationRELU, alpha_, beta_, power_));
+  }
+
+  ~MIOPENReluOp() {
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(data_desc_));
+    MIOPEN_ENFORCE(miopenDestroyActivationDescriptor(activ_desc_));
+  }
+
+  template <typename T>
+  bool DoRunWithType() {
+    const auto& X = Input(0);
+    auto* Y = Output(0);
+
+    // Return if X is empty
+    if (X.size() == 0) {
+      Y->mutable_data<T>();
+      return true;
+    }
+
+    // See if we need to reshape.
+    if (X.dims() != miopen_input_dims_) {
+      VLOG(1) << "Setting descriptors.";
+      miopen_input_dims_ = X.dims();
+      int C = 1, H = 1, W = 1;
+      if (X.ndim() == 4) {
+        // Normal 4-dimensional tensors for images.
+        C = X.dim32(1);
+        H = X.dim32(2);
+        W = X.dim32(3);
+      } else {
+        // If X is not 4-dimensional, we will simply use H = 1 and W = 1
+        // and wrap everything into C.
+        C = X.size() / X.dim32(0);
+      }
+      MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+          data_desc_, miopenTypeWrapper<T>::type, X.dim32(0), C, H, W));
+    }
+    MIOPEN_ENFORCE(miopenActivationForward(
+        miopen_wrapper_.inline_miopen_handle(),
+        activ_desc_,
+        &alpha_,
+        data_desc_,
+        X.template data<T>(),
+        &beta_,
+        data_desc_,
+        Y->template mutable_data<T>()));
+    return true;
+  }
+
+  bool RunOnDevice() override {
+    // dispatch based on contents of tensor(s)
+    const auto& X = Input(0);
+    auto* Y = Output(0);
+    Y->ResizeLike(X);
+    if (X.IsType<float>()) {
+      return DoRunWithType<float>();
+    } else {
+      LOG(FATAL) << "Unsupported input types";
+    }
+    return true;
+  }
+
+ protected:
+  MIOPENWrapper miopen_wrapper_;
+  miopenTensorDescriptor_t data_desc_;
+  miopenActivationDescriptor_t activ_desc_;
+  vector<TIndex> miopen_input_dims_;
+  const float alpha_;
+  const float beta_;
+  const double power_;
+};
+
+// Note: You can see that in MIOPENReluGradientOp, we abused the miopen
+// interface by passing in the output tensor for both bottom and top. This is
+// dependent on the assumption that the Relu gradient actually does not rely on
+// the bottom data, or it treats input=0 the same way as input<0. This is of
+// course not very safe, but we have been running in this way in Caffe for a
+// while so it *might* be safe to assume so.
+class MIOPENReluGradientOp final : public Operator<HIPContext> {
+ public:
+  MIOPENReluGradientOp(const OperatorDef& operator_def, Workspace* ws)
+      : Operator<HIPContext>(operator_def, ws),
+        miopen_wrapper_(&context_),
+        alpha_(OperatorBase::GetSingleArgument<float>("alpha", 1.0)),
+        beta_(OperatorBase::GetSingleArgument<float>("beta", 0.0)),
+        power_(OperatorBase::GetSingleArgument<double>("power", 1.0)) {
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&data_desc_));
+    MIOPEN_ENFORCE(miopenCreateActivationDescriptor(&activ_desc_));
+    MIOPEN_ENFORCE(miopenSetActivationDescriptor(
+        activ_desc_, miopenActivationRELU, alpha_, beta_, power_));
+  }
+
+  ~MIOPENReluGradientOp() {
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(data_desc_));
+    MIOPEN_ENFORCE(miopenDestroyActivationDescriptor(activ_desc_));
+  }
+
+  template <typename T>
+  bool DoRunWithType() {
+    const auto& Y = Input(0);
+    const auto& dY = Input(1);
+    auto* dX = Output(0);
+
+    // Return if Y is empty
+    if (Y.size() == 0) {
+      dX->mutable_data<T>();
+      return true;
+    }
+
+    // See if we need to reshape.
+    if (Y.dims() != miopen_input_dims_) {
+      VLOG(1) << "Setting descriptors.";
+      miopen_input_dims_ = Y.dims();
+      int C = 1, H = 1, W = 1;
+      if (Y.ndim() == 4) {
+        // Normal 4-dimensional tensors for images.
+        C = Y.dim32(1);
+        H = Y.dim32(2);
+        W = Y.dim32(3);
+      } else {
+        // If Y is not 4-dimensional, we will simply use H = 1 and W = 1
+        // and wrap everything into C.
+        C = Y.size() / Y.dim32(0);
+      }
+      MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+          data_desc_, miopenTypeWrapper<T>::type, Y.dim32(0), C, H, W));
+    }
+    MIOPEN_ENFORCE(miopenActivationBackward(
+        miopen_wrapper_.inline_miopen_handle(),
+        activ_desc_,
+        &alpha_,
+        data_desc_,
+        Y.template data<T>(),
+        data_desc_,
+        dY.template data<T>(),
+        data_desc_,
+        Y.template data<T>(),
+        &beta_,
+        data_desc_,
+        dX->template mutable_data<T>()));
+    return true;
+  }
+
+  bool RunOnDevice() override {
+    const auto& Y = Input(0);
+    auto* dX = Output(0);
+    dX->ResizeLike(Y);
+    if (Y.IsType<float>()) {
+      return DoRunWithType<float>();
+    } else {
+      LOG(FATAL) << "Unsupported input types";
+    }
+    return true;
+  }
+
+ protected:
+  MIOPENWrapper miopen_wrapper_;
+  miopenTensorDescriptor_t data_desc_;
+  miopenActivationDescriptor_t activ_desc_;
+  vector<TIndex> miopen_input_dims_;
+  const float alpha_;
+  const float beta_;
+  const double power_;
+  // Input: Y, dY; Output: dX
+};
+
+namespace {
+REGISTER_MIOPEN_OPERATOR(Relu, MIOPENReluOp);
+REGISTER_MIOPEN_OPERATOR(ReluGradient, MIOPENReluGradientOp);
+} // namespace
+} // namespace caffe2
diff --git a/caffe2/operators/hip/softmax_op_miopen.cc b/caffe2/operators/hip/softmax_op_miopen.cc
new file mode 100644
index 0000000000000..08c43a8aa2981
--- /dev/null
+++ b/caffe2/operators/hip/softmax_op_miopen.cc
@@ -0,0 +1,138 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "caffe2/core/hip/context_hip.h"
+#include "caffe2/core/hip/miopen_wrapper.h"
+#include "caffe2/core/types.h"
+#include "caffe2/operators/softmax_op.h"
+
+namespace caffe2 {
+class MIOpenSoftmaxOp final : public Operator<HIPContext> {
+ public:
+  explicit MIOpenSoftmaxOp(const OperatorDef& def, Workspace* ws)
+      : Operator<HIPContext>(def, ws),
+        miopen_wrapper_(&context_),
+        axis_(OperatorBase::GetSingleArgument<int>("axis", 1)),
+        alpha_(OperatorBase::GetSingleArgument<float>("alpha", 1.0)),
+        beta_(OperatorBase::GetSingleArgument<float>("beta", 0.0)) {
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&desc_));
+  }
+
+  ~MIOpenSoftmaxOp() {
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(desc_));
+  }
+
+  template <typename T>
+  bool DoRunWithType() {
+    auto& X = Input(0);
+    auto* Y = Output(0);
+    const auto canonical_axis = X.canonical_axis_index(axis_);
+    const int N = X.size_to_dim(canonical_axis);
+    const int D = X.size_from_dim(canonical_axis);
+
+    Y->ResizeLike(X);
+    if (dims_ != X.dims()) {
+      MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+          desc_, miopenTypeWrapper<T>::type, N, D, 1, 1));
+      dims_ = X.dims();
+    }
+    MIOPEN_ENFORCE(miopenSoftmaxForward(
+        miopen_wrapper_.inline_miopen_handle(),
+        &alpha_,
+        desc_,
+        X.template data<T>(),
+        &beta_,
+        desc_,
+        Y->template mutable_data<T>()));
+    return true;
+  }
+
+  bool RunOnDevice() override {
+    return DispatchHelper<TensorTypes<float, float16>>::call(this, Input(0));
+  }
+
+ protected:
+  MIOPENWrapper miopen_wrapper_;
+  miopenTensorDescriptor_t desc_;
+  vector<TIndex> dims_;
+  const int axis_;
+  const float alpha_;
+  const float beta_;
+};
+
+class MIOpenSoftmaxGradientOp final : public Operator<HIPContext> {
+ public:
+  explicit MIOpenSoftmaxGradientOp(const OperatorDef& def, Workspace* ws)
+      : Operator<HIPContext>(def, ws),
+        miopen_wrapper_(&context_),
+        axis_(OperatorBase::GetSingleArgument<int>("axis", 1)),
+        alpha_(OperatorBase::GetSingleArgument<float>("alpha", 1.0)),
+        beta_(OperatorBase::GetSingleArgument<float>("beta", 0.0)) {
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&desc_));
+  }
+
+  ~MIOpenSoftmaxGradientOp() {
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(desc_));
+  }
+
+  template <typename T>
+  bool DoRunWithType() {
+    auto& Y = Input(0);
+    auto& dY = Input(1);
+    auto* dX = Output(0);
+    const auto canonical_axis = Y.canonical_axis_index(axis_);
+    const int N = Y.size_to_dim(canonical_axis);
+    const int D = Y.size_from_dim(canonical_axis);
+
+    CHECK_EQ(Y.dims(), dY.dims());
+    dX->ResizeLike(Y);
+    if (dims_ != Y.dims()) {
+      MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+          desc_, miopenTypeWrapper<T>::type, N, D, 1, 1));
+      dims_ = Y.dims();
+    }
+    MIOPEN_ENFORCE(miopenSoftmaxBackward(
+        miopen_wrapper_.inline_miopen_handle(),
+        &alpha_,
+        desc_,
+        Y.template data<T>(),
+        desc_,
+        dY.template data<T>(),
+        &beta_,
+        desc_,
+        dX->template mutable_data<T>()));
+    return true;
+  }
+
+  bool RunOnDevice() override {
+    return DispatchHelper<TensorTypes<float, float16>>::call(this, Input(0));
+  }
+
+ protected:
+  MIOPENWrapper miopen_wrapper_;
+  const int axis_;
+  const float alpha_;
+  const float beta_;
+  miopenTensorDescriptor_t desc_;
+  vector<TIndex> dims_;
+};
+
+namespace {
+REGISTER_MIOPEN_OPERATOR(Softmax, MIOpenSoftmaxOp);
+REGISTER_MIOPEN_OPERATOR(SoftmaxGradient, MIOpenSoftmaxGradientOp);
+} // namespace
+
+} // namespace caffe2
diff --git a/caffe2/operators/hip/spatial_batch_norm_op_miopen.cc b/caffe2/operators/hip/spatial_batch_norm_op_miopen.cc
new file mode 100644
index 0000000000000..77f35b1334b66
--- /dev/null
+++ b/caffe2/operators/hip/spatial_batch_norm_op_miopen.cc
@@ -0,0 +1,318 @@
+/**
+ * Copyright (c) 2016-present, Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cfloat>
+#include "caffe2/core/hip/context_hip.h"
+#include "caffe2/core/hip/miopen_wrapper.h"
+#include "caffe2/operators/spatial_batch_norm_op.h"
+#include "caffe2/utils/math.h"
+
+const double MIOPEN_BN_MIN_EPSILON = 1e-6;
+
+namespace caffe2 {
+
+class MIOpenSpatialBNOp final : public SpatialBNOp<HIPContext> {
+ public:
+  USE_OPERATOR_FUNCTIONS(HIPContext);
+  MIOpenSpatialBNOp(const OperatorDef& operator_def, Workspace* ws)
+      : SpatialBNOp<HIPContext>(operator_def, ws),
+        miopen_wrapper_(&context_),
+        alpha_(OperatorBase::GetSingleArgument<float>("alpha", 1.0)),
+        beta_(OperatorBase::GetSingleArgument<float>("beta", 0.0)),
+        mode_(miopenBNSpatial) {
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&data_desc_));
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&bn_param_desc_));
+    if (epsilon_ <= MIOPEN_BN_MIN_EPSILON) {
+      LOG(ERROR) << "Provided epsilon is smaller than "
+                 << "MIOPEN_BN_MIN_EPSILON. Setting it to "
+                 << "MIOPEN_BN_MIN_EPSILON instead.";
+    }
+    epsilon_ = std::max(epsilon_, MIOPEN_BN_MIN_EPSILON);
+  }
+
+  ~MIOpenSpatialBNOp() {
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(data_desc_));
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(bn_param_desc_));
+  }
+
+  template <typename T, typename M>
+  bool DoRunWithType();
+  bool RunOnDevice() override;
+
+ protected:
+  MIOPENWrapper miopen_wrapper_;
+  miopenTensorDescriptor_t data_desc_;
+  miopenTensorDescriptor_t bn_param_desc_;
+  vector<TIndex> miopen_input_dims_;
+  float alpha_;
+  float beta_;
+  miopenBatchNormMode_t mode_;
+};
+
+class MIOpenSpatialBNGradientOp final : public SpatialBNGradientOp<HIPContext> {
+ public:
+  USE_OPERATOR_FUNCTIONS(HIPContext);
+  MIOpenSpatialBNGradientOp(const OperatorDef& operator_def, Workspace* ws)
+      : SpatialBNGradientOp<HIPContext>(operator_def, ws),
+        miopen_wrapper_(&context_),
+        alpha_(OperatorBase::GetSingleArgument<float>("alpha", 1.0)),
+        beta_(OperatorBase::GetSingleArgument<float>("beta", 0.0)),
+        mode_(miopenBNSpatial) {
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&data_desc_));
+    MIOPEN_ENFORCE(miopenCreateTensorDescriptor(&bn_param_desc_));
+    if (epsilon_ <= MIOPEN_BN_MIN_EPSILON) {
+      LOG(ERROR) << "Provided epsilon is smaller than "
+                 << "MIOPEN_BN_MIN_EPSILON. Setting it to "
+                 << "MIOPEN_BN_MIN_EPSILON instead.";
+    }
+    epsilon_ = std::max(epsilon_, MIOPEN_BN_MIN_EPSILON);
+  }
+
+  ~MIOpenSpatialBNGradientOp() {
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(data_desc_));
+    MIOPEN_ENFORCE(miopenDestroyTensorDescriptor(bn_param_desc_));
+  }
+
+  template <typename T, typename M>
+  bool DoRunWithType();
+
+  bool RunOnDevice() override;
+
+ protected:
+  MIOPENWrapper miopen_wrapper_;
+  miopenTensorDescriptor_t data_desc_;
+  miopenTensorDescriptor_t bn_param_desc_;
+  vector<TIndex> miopen_input_dims_;
+  float alpha_;
+  float beta_;
+  miopenBatchNormMode_t mode_;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Implementations
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename T, typename M>
+bool MIOpenSpatialBNOp::DoRunWithType() {
+  // QoL
+  typedef typename miopenTypeWrapper<T>::BNParamType BNParamType;
+
+  auto& X = Input(INPUT);
+  auto& scale = Input(SCALE);
+  auto& bias = Input(BIAS);
+
+  CAFFE_ENFORCE_GE(X.ndim(), 3);
+  const int N = X.dim32(0);
+  const int C = X.dim32(1);
+  const int H = X.dim32(2);
+  const int W = X.ndim() > 3 ? X.dim32(3) : 1;
+  const int D = X.ndim() > 4 ? X.dim32(4) : 1;
+  CAFFE_ENFORCE_EQ(scale.ndim(), 1);
+  CAFFE_ENFORCE_EQ(bias.ndim(), 1);
+  CAFFE_ENFORCE_EQ(scale.dim32(0), C);
+  CAFFE_ENFORCE_EQ(bias.dim32(0), C);
+  // See if we need to reshape.
+  if (X.dims() != miopen_input_dims_) {
+    VLOG(1) << "Setting descriptors.";
+    miopen_input_dims_ = X.dims();
+    vector<int> dims = {N, C, H, W, D};
+    vector<int> strides = {C * H * W * D, H * W * D, W * D, D, 1};
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        data_desc_, miopenTypeWrapper<T>::type, N, C, H, W));
+
+    MIOPEN_ENFORCE(
+        miopenDeriveBNTensorDescriptor(bn_param_desc_, data_desc_, mode_));
+  }
+
+  // Now, depending on whether we are running test or not, we have two paths.
+  if (is_test_) {
+    // Run inference mode.
+    auto& est_mean = Input(EST_MEAN);
+    auto& est_var = Input(EST_VAR);
+    CAFFE_ENFORCE_EQ(est_mean.ndim(), 1);
+    CAFFE_ENFORCE_EQ(est_var.ndim(), 1);
+    CAFFE_ENFORCE_EQ(est_mean.dim32(0), C);
+    CAFFE_ENFORCE_EQ(est_var.dim32(0), C);
+
+    auto* Y = Output(OUTPUT);
+    Y->ResizeLike(X);
+    MIOPEN_ENFORCE(miopenBatchNormalizationForwardInference(
+        miopen_wrapper_.inline_miopen_handle(),
+        // Note: PERSISTENT not implemented for inference
+        mode_,
+        &alpha_,
+        &beta_,
+        data_desc_,
+        X.template data<T>(),
+        data_desc_,
+        Y->template mutable_data<T>(),
+        bn_param_desc_,
+        const_cast<float*>(scale.template data<BNParamType>()),
+        const_cast<float*>(bias.template data<BNParamType>()),
+        const_cast<float*>(est_mean.template data<BNParamType>()),
+        const_cast<float*>(est_var.template data<BNParamType>()),
+        epsilon_));
+  } else {
+    // Run training mode.
+    auto* Y = Output(OUTPUT);
+    Y->ResizeLike(X);
+    // obtain running mean and running inv var, and see if we need to
+    // initialize them.
+    auto* running_mean = Output(RUNNING_MEAN);
+    auto* running_var = Output(RUNNING_VAR);
+    double this_factor = 1. - momentum_;
+    BNParamType* running_mean_data = nullptr;
+    BNParamType* running_var_data = nullptr;
+    if (!running_mean->size()) {
+      // If the input mean and var are not initialized yet, this is the first
+      // run and we will initialize the storage.
+      VLOG(1) << "Initializing running mean and var.";
+      // Need to do initialization
+      running_mean->Resize(C);
+      running_var->Resize(C);
+      running_mean_data = running_mean->template mutable_data<BNParamType>();
+      running_var_data = running_var->template mutable_data<BNParamType>();
+      // In principle, setting this_momentum to 1 will wipe existing data.
+      // This has a caveat that if miopen does not deal with 0*NaN cases we
+      // will be having an issue. Thus we choose a safe path by explicitly
+      // setting zero.
+      math::Set<BNParamType, HIPContext>(C, 0, running_mean_data, &context_);
+      math::Set<BNParamType, HIPContext>(C, 0, running_var_data, &context_);
+    } else {
+      // Does not need to do initialization.
+      CAFFE_ENFORCE_EQ(running_mean->ndim(), 1);
+      CAFFE_ENFORCE_EQ(running_var->ndim(), 1);
+      CAFFE_ENFORCE_EQ(running_mean->dim32(0), C);
+      CAFFE_ENFORCE_EQ(running_var->dim32(0), C);
+      running_mean_data = running_mean->template mutable_data<BNParamType>();
+      running_var_data = running_var->template mutable_data<BNParamType>();
+    }
+    // Save the mean and inv var results.
+    auto* save_mean = Output(SAVED_MEAN);
+    auto* save_var = Output(SAVED_INV_VAR);
+    save_mean->Resize(C);
+    save_var->Resize(C);
+    void* save_mean_data = save_mean->template mutable_data<BNParamType>();
+    void* save_var_data = save_var->template mutable_data<BNParamType>();
+
+    MIOPEN_ENFORCE(miopenBatchNormalizationForwardTraining(
+        miopen_wrapper_.inline_miopen_handle(),
+        mode_,
+        &alpha_,
+        &beta_,
+        data_desc_,
+        X.template data<T>(),
+        data_desc_,
+        Y->template mutable_data<T>(),
+        bn_param_desc_,
+        const_cast<float*>(scale.template data<BNParamType>()),
+        const_cast<float*>(bias.template data<BNParamType>()),
+        this_factor,
+        const_cast<float*>(running_mean_data),
+        const_cast<float*>(running_var_data),
+        epsilon_,
+        save_mean_data,
+        save_var_data));
+  }
+  return true;
+}
+bool MIOpenSpatialBNOp::RunOnDevice() {
+  if (Input(0).IsType<float>()) {
+    return DoRunWithType<float, float>();
+  } else {
+    LOG(FATAL) << "Unsupported input types";
+  }
+  return true;
+}
+
+template <typename T, typename M>
+bool MIOpenSpatialBNGradientOp::DoRunWithType() {
+  typedef typename miopenTypeWrapper<T>::BNParamType BNParamType;
+
+  auto& X = Input(INPUT);
+  auto& scale = Input(SCALE);
+  auto& dY = Input(OUTPUT_GRAD);
+
+  CAFFE_ENFORCE_GE(X.ndim(), 3);
+  const int N = X.dim32(0);
+  const int C = X.dim32(1);
+  const int H = X.dim32(2);
+  const int W = X.ndim() > 3 ? X.dim32(3) : 1;
+  const int D = X.ndim() > 4 ? X.dim32(4) : 1;
+  CAFFE_ENFORCE_EQ(scale.ndim(), 1);
+  CAFFE_ENFORCE_EQ(scale.dim32(0), C);
+  // See if we need to reshape.
+  if (X.dims() != miopen_input_dims_) {
+    vector<int> dims = {N, C, H, W, D};
+    vector<int> strides = {C * H * W * D, H * W * D, W * D, D, 1};
+    MIOPEN_ENFORCE(miopenSet4dTensorDescriptor(
+        data_desc_, miopenTypeWrapper<T>::type, N, C, H, W));
+
+    MIOPEN_ENFORCE(
+        miopenDeriveBNTensorDescriptor(bn_param_desc_, data_desc_, mode_));
+  }
+
+  auto* dX = Output(INPUT_GRAD);
+  auto* dScale = Output(SCALE_GRAD);
+  auto* dBias = Output(BIAS_GRAD);
+  dX->ResizeLike(X);
+  dScale->ResizeLike(scale);
+  dBias->ResizeLike(scale);
+
+  const auto& saved_mean = Input(SAVED_MEAN);
+  const auto& saved_var = Input(SAVED_INV_VAR);
+  const void* saved_mean_data = saved_mean.template data<BNParamType>();
+  const void* saved_var_data = saved_var.template data<BNParamType>();
+
+  MIOPEN_ENFORCE(miopenBatchNormalizationBackward(
+      miopen_wrapper_.inline_miopen_handle(),
+      mode_,
+      &alpha_,
+      &beta_,
+      &alpha_,
+      &beta_,
+      data_desc_,
+      X.template data<T>(),
+      data_desc_,
+      dY.template data<T>(),
+      data_desc_,
+      dX->template mutable_data<T>(),
+      bn_param_desc_,
+      scale.template data<BNParamType>(),
+      dScale->template mutable_data<BNParamType>(),
+      dBias->template mutable_data<BNParamType>(),
+      epsilon_,
+      saved_mean_data,
+      saved_var_data));
+  return true;
+}
+bool MIOpenSpatialBNGradientOp::RunOnDevice() {
+  if (Input(0).IsType<float>()) {
+    return DoRunWithType<float, float>();
+  } else {
+    LOG(FATAL) << "Unsupported input types";
+  }
+  return true;
+}
+
+// Since there is no default implementation for spatial batch normalization,
+// we will register the miopen version as the default as well.
+REGISTER_HIP_OPERATOR(SpatialBN, MIOpenSpatialBNOp);
+REGISTER_HIP_OPERATOR(SpatialBNGradient, MIOpenSpatialBNGradientOp);
+
+REGISTER_MIOPEN_OPERATOR(SpatialBN, MIOpenSpatialBNOp);
+REGISTER_MIOPEN_OPERATOR(SpatialBNGradient, MIOpenSpatialBNGradientOp);
+} // namespace caffe2
diff --git a/caffe2/python/CMakeLists.txt b/caffe2/python/CMakeLists.txt
index 1250ecd77cfb9..2165afac61fba 100644
--- a/caffe2/python/CMakeLists.txt
+++ b/caffe2/python/CMakeLists.txt
@@ -18,8 +18,16 @@ set(Caffe2_GPU_PYTHON_SRCS
     "/pybind_state_gpu.cc"
 )
 
+# ---[ HIP files
+set(Caffe2_HIP_PYTHON_SRCS
+    ${Caffe2_HIP_PYTHON_SRCS}
+    "/pybind_state_hip.cc"
+)
+
 prepend(Caffe2_CPU_PYTHON_SRCS ${CMAKE_CURRENT_SOURCE_DIR} ${Caffe2_CPU_PYTHON_SRCS})
 prepend(Caffe2_GPU_PYTHON_SRCS ${CMAKE_CURRENT_SOURCE_DIR} ${Caffe2_GPU_PYTHON_SRCS})
+prepend(Caffe2_HIP_PYTHON_SRCS ${CMAKE_CURRENT_SOURCE_DIR} ${Caffe2_HIP_PYTHON_SRCS})
+
 
 # --[ Some special handling for ideep binding as we need to build with "-mavx2"
 if(USE_MKL AND USE_IDEEP AND CAFFE2_COMPILER_SUPPORTS_AVX2_EXTENSIONS)
@@ -35,3 +43,5 @@ endif()
 
 set(Caffe2_CPU_PYTHON_SRCS ${Caffe2_CPU_PYTHON_SRCS} PARENT_SCOPE)
 set(Caffe2_GPU_PYTHON_SRCS ${Caffe2_GPU_PYTHON_SRCS} PARENT_SCOPE)
+set(Caffe2_HIP_PYTHON_SRCS ${Caffe2_HIP_PYTHON_SRCS} PARENT_SCOPE)
+
diff --git a/caffe2/python/pybind_state_hip.cc b/caffe2/python/pybind_state_hip.cc
new file mode 100644
index 0000000000000..b770ea00001e3
--- /dev/null
+++ b/caffe2/python/pybind_state_hip.cc
@@ -0,0 +1,91 @@
+#define NO_IMPORT_ARRAY
+
+#include "pybind_state.h"
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "caffe2/core/hip/common_miopen.h"
+#include "caffe2/core/hip/context_hip.h"
+#include "caffe2/operators/hip/operator_fallback_hip.h"
+
+namespace caffe2 {
+namespace python {
+
+REGISTER_HIP_OPERATOR(Python, GPUFallbackOp<PythonOp<CPUContext, false>>);
+REGISTER_HIP_OPERATOR(
+    PythonGradient,
+    GPUFallbackOp<PythonGradientOp<CPUContext, false>>);
+
+REGISTER_HIP_OPERATOR(PythonDLPack, PythonOp<HIPContext, true>);
+REGISTER_HIP_OPERATOR(PythonDLPackGradient, PythonGradientOp<HIPContext, true>);
+
+REGISTER_BLOB_FETCHER((TypeMeta::Id<TensorHIP>()), TensorFetcher<HIPContext>);
+REGISTER_BLOB_FEEDER(HIP, TensorFeeder<HIPContext>);
+
+namespace py = pybind11;
+
+void addHIPGlobalMethods(py::module& m) {
+  m.def("num_hip_devices", &NumHipDevices);
+  m.def("set_default_gpu_id", &SetDefaultGPUID);
+  m.def("get_default_gpu_id", &GetDefaultGPUID);
+  m.def("get_hip_version", &HipVersion);
+  m.def("get_miopen_version", &miopenCompiledVersion);
+  m.def("get_hip_peer_access_pattern", []() {
+    std::vector<std::vector<bool>> pattern;
+    CAFFE_ENFORCE(caffe2::GetHipPeerAccessPattern(&pattern));
+    return pattern;
+  });
+  m.def("get_device_properties", [](int deviceid) {
+    auto& prop = GetDeviceProperty(deviceid);
+    std::map<std::string, py::object> obj;
+    obj["name"] = py::cast(prop.name);
+    obj["major"] = py::cast(prop.major);
+    obj["minor"] = py::cast(prop.minor);
+    return obj;
+  });
+};
+
+void addHIPObjectMethods(py::module& m) {
+  py::class_<DLPackWrapper<HIPContext>>(m, "DLPackTensorHIP")
+      .def_property_readonly(
+          "data",
+          [](DLPackWrapper<HIPContext>* t) -> py::object {
+            CAFFE_ENFORCE_EQ(
+                t->device_option.device_type(),
+                HIP,
+                "Expected HIP device option for HIP tensor");
+
+            return t->data();
+          },
+          "Return DLPack tensor with tensor's data.")
+      .def(
+          "feed",
+          [](DLPackWrapper<HIPContext>* t, py::object obj) {
+            CAFFE_ENFORCE_EQ(
+                t->device_option.device_type(),
+                HIP,
+                "Expected HIP device option for HIP tensor");
+            t->feed(obj);
+          },
+          "Copy data from given DLPack tensor into this tensor.")
+      .def_property_readonly(
+          "_shape",
+          [](const DLPackWrapper<HIPContext>& t) { return t.tensor->dims(); })
+      .def(
+          "_reshape",
+          [](DLPackWrapper<HIPContext>* t, std::vector<TIndex> dims) {
+            t->tensor->Resize(dims);
+          });
+}
+
+PYBIND11_MODULE(caffe2_pybind11_state_hip, m) {
+  m.doc() = "pybind11 stateful interface to Caffe2 workspaces - GPU edition";
+
+  addGlobalMethods(m);
+  addHIPGlobalMethods(m);
+  addObjectMethods(m);
+  addHIPObjectMethods(m);
+}
+} // namespace python
+} // namespace caffe2
diff --git a/caffe2/utils/CMakeLists.txt b/caffe2/utils/CMakeLists.txt
index d774caceb4e19..93e12839e9231 100644
--- a/caffe2/utils/CMakeLists.txt
+++ b/caffe2/utils/CMakeLists.txt
@@ -26,6 +26,10 @@ set(Caffe2_GPU_SRCS ${Caffe2_GPU_SRCS}
         utils/math_gpu.cu
         )
 
+set(Caffe2_HIP_SRCS ${Caffe2_HIP_SRCS}
+        utils/math_hip.cc
+        )
+
 set(Caffe2_CPU_TEST_SRCS ${Caffe2_CPU_TEST_SRCS}
         utils/fixed_divisor_test.cc
         utils/math_test.cc
@@ -41,6 +45,11 @@ set(Caffe2_GPU_TEST_SRCS ${Caffe2_GPU_TEST_SRCS}
         utils/math_gpu_test.cc
         )
 
+set(Caffe2_HIP_TEST_SRCS ${Caffe2_HIP_TEST_SRCS}
+        utils/math_hip_test.cc
+        utils/math_blas_hip_test.cc
+        )
+
 # TODO Remove the CMake_xxx variables above and add them to the variables for the local library target below instead
 
 set(LIB_SOURCES_CPU
@@ -55,6 +64,10 @@ set(LIB_SOURCES_GPU
         dummy.cpp
         )
 
+set(LIB_SOURCES_HIP
+        dummy.cpp
+        )
+
 set(TEST_SOURCES_CPU
         Array_test.cpp
         Metaprogramming_test.cpp
@@ -66,6 +79,9 @@ set(LIB_SOURCES_GPU
         dummy.cpp
         )
 
+set(TEST_SOURCES_HIP
+        dummy.cpp
+        )
 
 add_library(c10_utils_cpu OBJECT ${LIB_SOURCES_CPU})
 target_enable_style_warnings("c10_utils_cpu")
@@ -73,6 +89,9 @@ target_enable_style_warnings("c10_utils_cpu")
 add_library(c10_utils_gpu OBJECT ${LIB_SOURCES_GPU})
 target_enable_style_warnings("c10_utils_gpu")
 
+add_library(c10_utils_hip OBJECT ${LIB_SOURCES_HIP})
+target_enable_style_warnings("c10_utils_hip")
+
 if(BUILD_TEST)
   add_executable(c10_utils_cpu_test ${TEST_SOURCES_CPU} $<TARGET_OBJECTS:c10_utils_cpu>)
   add_test(NAME c10_utils_cpu_test COMMAND $<TARGET_FILE:c10_utils_cpu_test>)
@@ -89,13 +108,23 @@ if(BUILD_TEST)
   if(INSTALL_TEST)
     install(TARGETS c10_utils_gpu_test DESTINATION test)
   endif()
+
+  add_executable(c10_utils_hip_test ${TEST_SOURCES_HIP} $<TARGET_OBJECTS:c10_utils_hip>)
+  add_test(NAME c10_utils_hip_test COMMAND $<TARGET_FILE:c10_utils_hip_test>)
+  target_enable_style_warnings(c10_utils_hip_test)
+  target_link_libraries(c10_utils_hip_test gtest_main)
+  if(INSTALL_TEST)
+    install(TARGETS c10_utils_hip_test DESTINATION test)
+  endif()
 endif()
 
 
 # TODO Once all source files are defined inside the local c10_utils_xxx targets,
 # it should be the job of the parent CMakeLists.txt to decide what to do with the target (i.e. link it to caffe2)
 # instead of us locally adding it to Caffe2_xxx variables.
-set(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS} $<TARGET_OBJECTS:c10_utils_cpu> PARENT_SCOPE)
-set(Caffe2_GPU_SRCS ${Caffe2_GPU_SRCS} $<TARGET_OBJECTS:c10_utils_gpu> PARENT_SCOPE)
+set(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS} PARENT_SCOPE)
+set(Caffe2_GPU_SRCS ${Caffe2_GPU_SRCS} PARENT_SCOPE)
+set(Caffe2_HIP_SRCS ${Caffe2_HIP_SRCS} PARENT_SCOPE)
 set(Caffe2_CPU_TEST_SRCS ${Caffe2_CPU_TEST_SRCS} PARENT_SCOPE)
 set(Caffe2_GPU_TEST_SRCS ${Caffe2_GPU_TEST_SRCS} PARENT_SCOPE)
+set(Caffe2_HIP_TEST_SRCS ${Caffe2_HIP_TEST_SRCS} PARENT_SCOPE)
diff --git a/caffe2/utils/conversions.h b/caffe2/utils/conversions.h
index c3b5f564265d0..fbe30fbadac90 100644
--- a/caffe2/utils/conversions.h
+++ b/caffe2/utils/conversions.h
@@ -7,8 +7,11 @@
 // has necessary diagnostic guards.
 #include <caffe2/core/common_gpu.h>
 #endif
+#if __HIP_DEVICE_COMPILE__
+#include <caffe2/core/hip/common_hip.h>
+#endif
 
-#ifdef __CUDA_ARCH__
+#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__)
 #define CONVERSIONS_DECL __host__ __device__ inline
 #else
 #define CONVERSIONS_DECL inline
@@ -175,13 +178,17 @@ CONVERSIONS_DECL float16 To(const float in) {
 #if __CUDA_ARCH__
   // hacky interface between C2 fp16 and CUDA
 #if CUDA_VERSION >= 9000
-  half rh = __float2half(in); 
+  half rh = __float2half(in);
   return halfToFloat16(rh);
 #else
   float16 ret;
   ret.x = __float2half(in).x;
   return ret;
 #endif // CUDA_VERSION >= 9000
+#elif __HIP_DEVICE_COMPILE__
+  float16 ret;
+  ret.x = __float2half(in);
+  return ret;
 #else
   return cpu_float2half_rn(in);
 #endif
@@ -197,6 +204,10 @@ CONVERSIONS_DECL float To(const float16 in) {
 #endif
   tmp.x = in.x;
   return __half2float(tmp);
+#elif __HIP_DEVICE_COMPILE__
+  __half tmp;
+  tmp = in.x;
+  return __half2float(tmp);
 #else
   return cpu_half2float(in);
 #endif
diff --git a/caffe2/utils/math_blas_hip_test.cc b/caffe2/utils/math_blas_hip_test.cc
new file mode 100644
index 0000000000000..ae54faa4e628f
--- /dev/null
+++ b/caffe2/utils/math_blas_hip_test.cc
@@ -0,0 +1,391 @@
+#include <gtest/gtest.h>
+#include "caffe2/core/blob.h"
+#include "caffe2/core/context.h"
+#include "caffe2/core/hip/context_hip.h"
+#include "caffe2/core/tensor.h"
+#include "caffe2/operators/utility_ops.h"
+#include "caffe2/proto/caffe2.pb.h"
+#include "caffe2/utils/conversions.h"
+#include "caffe2/utils/math.h"
+
+namespace caffe2 {
+
+TEST(MathROCBLASTest, GemmNoTransNoTrans) {
+  if (!HasHipGPU())
+    return;
+  Workspace ws;
+  DeviceOption option;
+  option.set_device_type(HIP);
+  HIPContext context(option);
+
+  Blob* blobX = ws.CreateBlob("X");
+  Blob* blobW = ws.CreateBlob("W");
+  Blob* blobY = ws.CreateBlob("Y");
+  Blob* blobY_host = ws.CreateBlob("Y_host");
+
+  vector<int> shapeX{5, 10};
+  vector<int> shapeW{10, 6};
+  vector<int> shapeY{5, 6};
+  auto* tensorX = blobX->GetMutable<Tensor<HIPContext>>();
+  tensorX->Resize(shapeX);
+  auto* tensorW = blobW->GetMutable<Tensor<HIPContext>>();
+  tensorW->Resize(shapeW);
+  auto* tensorY = blobY->GetMutable<Tensor<HIPContext>>();
+  tensorY->Resize(shapeY);
+  auto* tensorY_host = blobY_host->GetMutable<Tensor<CPUContext>>();
+  tensorY_host->Resize(shapeY);
+
+  EXPECT_EQ(tensorX->size(), 50);
+  EXPECT_EQ(tensorW->size(), 60);
+  EXPECT_EQ(tensorY->size(), 30);
+
+  math::Set<float, HIPContext>(
+      tensorX->size(), 1, tensorX->mutable_data<float>(), &context);
+  math::Set<float, HIPContext>(
+      tensorW->size(), 1, tensorW->mutable_data<float>(), &context);
+
+  const float kOne = 1.0;
+  const float kPointFive = 0.5;
+  const float kZero = 0.0;
+  math::Gemm<float, HIPContext>(
+      CblasNoTrans,
+      CblasNoTrans,
+      5,
+      6,
+      10,
+      kOne,
+      tensorX->template data<float>(),
+      tensorW->template data<float>(),
+      kZero,
+      tensorY->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+  tensorY_host->CopyFrom<HIPContext, HIPContext>(*tensorY, &context);
+  context.FinishDeviceComputation();
+  EXPECT_EQ(tensorY_host->size(), 30);
+  for (int i = 0; i < tensorY_host->size(); ++i) {
+    CHECK_EQ(tensorY_host->data<float>()[i], 10) << i;
+  }
+
+  // Test Accumulate
+  math::Gemm<float, HIPContext>(
+      CblasNoTrans,
+      CblasNoTrans,
+      5,
+      6,
+      10,
+      kOne,
+      tensorX->template data<float>(),
+      tensorW->template data<float>(),
+      kPointFive,
+      tensorY->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+  tensorY_host->CopyFrom<HIPContext, HIPContext>(*tensorY, &context);
+  context.FinishDeviceComputation();
+  EXPECT_EQ(tensorY_host->size(), 30);
+  for (int i = 0; i < tensorY_host->size(); ++i) {
+    CHECK_EQ(tensorY_host->data<float>()[i], 15) << i;
+  }
+
+  // Test Accumulate
+  math::Gemm<float, HIPContext>(
+      CblasNoTrans,
+      CblasNoTrans,
+      5,
+      6,
+      10,
+      kPointFive,
+      tensorX->template data<float>(),
+      tensorW->template data<float>(),
+      kOne,
+      tensorY->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+  tensorY_host->CopyFrom<HIPContext, HIPContext>(*tensorY, &context);
+  context.FinishDeviceComputation();
+  EXPECT_EQ(tensorY_host->size(), 30);
+  for (int i = 0; i < tensorY_host->size(); ++i) {
+    CHECK_EQ(tensorY_host->data<float>()[i], 20) << i;
+  }
+}
+
+TEST(MathROCBLASTest, GemmNoTransTrans) {
+  if (!HasHipGPU())
+    return;
+  Workspace ws;
+  DeviceOption option;
+  option.set_device_type(HIP);
+  HIPContext context(option);
+
+  Blob* blobX = ws.CreateBlob("X");
+  Blob* blobW = ws.CreateBlob("W");
+  Blob* blobY = ws.CreateBlob("Y");
+  Blob* blobY_host = ws.CreateBlob("Y_host");
+
+  vector<int> shapeX{5, 10};
+  vector<int> shapeW{6, 10};
+  vector<int> shapeY{5, 6};
+  auto* tensorX = blobX->GetMutable<Tensor<HIPContext>>();
+  tensorX->Resize(shapeX);
+  auto* tensorW = blobW->GetMutable<Tensor<HIPContext>>();
+  tensorW->Resize(shapeW);
+  auto* tensorY = blobY->GetMutable<Tensor<HIPContext>>();
+  tensorY->Resize(shapeY);
+  auto* tensorY_host = blobY_host->GetMutable<Tensor<CPUContext>>();
+  tensorY_host->Resize(shapeY);
+
+  EXPECT_EQ(tensorX->size(), 50);
+  EXPECT_EQ(tensorW->size(), 60);
+  EXPECT_EQ(tensorY->size(), 30);
+
+  math::Set<float, HIPContext>(
+      tensorX->size(), 1, tensorX->mutable_data<float>(), &context);
+  math::Set<float, HIPContext>(
+      tensorW->size(), 1, tensorW->mutable_data<float>(), &context);
+
+  const float kOne = 1.0;
+  const float kPointFive = 0.5;
+  const float kZero = 0.0;
+  math::Gemm<float, HIPContext>(
+      CblasNoTrans,
+      CblasTrans,
+      5,
+      6,
+      10,
+      kOne,
+      tensorX->template data<float>(),
+      tensorW->template data<float>(),
+      kZero,
+      tensorY->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+  tensorY_host->CopyFrom<HIPContext, HIPContext>(*tensorY, &context);
+  context.FinishDeviceComputation();
+  EXPECT_EQ(tensorY_host->size(), 30);
+  for (int i = 0; i < tensorY_host->size(); ++i) {
+    CHECK_EQ(tensorY_host->data<float>()[i], 10) << i;
+  }
+
+  // Test Accumulate
+  math::Gemm<float, HIPContext>(
+      CblasNoTrans,
+      CblasTrans,
+      5,
+      6,
+      10,
+      kOne,
+      tensorX->template data<float>(),
+      tensorW->template data<float>(),
+      kPointFive,
+      tensorY->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+  tensorY_host->CopyFrom<HIPContext, HIPContext>(*tensorY, &context);
+  context.FinishDeviceComputation();
+  EXPECT_EQ(tensorY_host->size(), 30);
+  for (int i = 0; i < tensorY_host->size(); ++i) {
+    CHECK_EQ(tensorY_host->data<float>()[i], 15) << i;
+  }
+
+  math::Gemm<float, HIPContext>(
+      CblasNoTrans,
+      CblasTrans,
+      5,
+      6,
+      10,
+      kPointFive,
+      tensorX->template data<float>(),
+      tensorW->template data<float>(),
+      kOne,
+      tensorY->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+  tensorY_host->CopyFrom<HIPContext, HIPContext>(*tensorY, &context);
+  context.FinishDeviceComputation();
+  EXPECT_EQ(tensorY_host->size(), 30);
+  for (int i = 0; i < tensorY_host->size(); ++i) {
+    CHECK_EQ(tensorY_host->data<float>()[i], 20) << i;
+  }
+}
+
+TEST(MathROCBLASTest, GemvNoTrans) {
+  if (!HasHipGPU())
+    return;
+  Workspace ws;
+  DeviceOption option;
+  option.set_device_type(HIP);
+  HIPContext context(option);
+
+  Blob* blobA = ws.CreateBlob("A");
+  Blob* blobX = ws.CreateBlob("X");
+  Blob* blobY = ws.CreateBlob("Y");
+  Blob* blobY_host = ws.CreateBlob("Y_host");
+
+  vector<int> shapeA{5, 10};
+  vector<int> shapeX{10};
+  vector<int> shapeY{5};
+  auto* tensorA = blobA->GetMutable<Tensor<HIPContext>>();
+  tensorA->Resize(shapeA);
+  auto* tensorX = blobX->GetMutable<Tensor<HIPContext>>();
+  tensorX->Resize(shapeX);
+  auto* tensorY = blobY->GetMutable<Tensor<HIPContext>>();
+  tensorY->Resize(shapeY);
+  auto* tensorY_host = blobY_host->GetMutable<Tensor<CPUContext>>();
+  tensorY_host->Resize(shapeY);
+
+  EXPECT_EQ(tensorA->size(), 50);
+  EXPECT_EQ(tensorX->size(), 10);
+  EXPECT_EQ(tensorY->size(), 5);
+  math::Set<float, HIPContext>(
+      tensorA->size(), 1, tensorA->mutable_data<float>(), &context);
+  math::Set<float, HIPContext>(
+      tensorX->size(), 1, tensorX->mutable_data<float>(), &context);
+
+  const float kOne = 1.0;
+  const float kPointFive = 0.5;
+  const float kZero = 0.0;
+  math::Gemv<float, HIPContext>(
+      CblasNoTrans,
+      5,
+      10,
+      kOne,
+      tensorA->data<float>(),
+      tensorX->data<float>(),
+      kZero,
+      tensorY->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+  tensorY_host->CopyFrom<HIPContext, HIPContext>(*tensorY, &context);
+  context.FinishDeviceComputation();
+  for (int i = 0; i < tensorY_host->size(); ++i) {
+    CHECK_EQ(tensorY_host->data<float>()[i], 10) << i;
+  }
+
+  // Test Accumulate
+  math::Gemv<float, HIPContext>(
+      CblasNoTrans,
+      5,
+      10,
+      kOne,
+      tensorA->data<float>(),
+      tensorX->data<float>(),
+      kPointFive,
+      tensorY->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+  tensorY_host->CopyFrom<HIPContext, HIPContext>(*tensorY, &context);
+  context.FinishDeviceComputation();
+  for (int i = 0; i < tensorY_host->size(); ++i) {
+    CHECK_EQ(tensorY_host->data<float>()[i], 15) << i;
+  }
+
+  // Test Accumulate
+  math::Gemv<float, HIPContext>(
+      CblasNoTrans,
+      5,
+      10,
+      kPointFive,
+      tensorA->data<float>(),
+      tensorX->data<float>(),
+      kOne,
+      tensorY->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+  tensorY_host->CopyFrom<HIPContext, HIPContext>(*tensorY, &context);
+  context.FinishDeviceComputation();
+  for (int i = 0; i < tensorY_host->size(); ++i) {
+    CHECK_EQ(tensorY_host->data<float>()[i], 20) << i;
+  }
+}
+
+TEST(MathROCBLASTest, GemvTrans) {
+  if (!HasHipGPU())
+    return;
+  Workspace ws;
+  DeviceOption option;
+  option.set_device_type(HIP);
+  HIPContext context(option);
+
+  Blob* blobA = ws.CreateBlob("A");
+  Blob* blobX = ws.CreateBlob("X");
+  Blob* blobY = ws.CreateBlob("Y");
+  Blob* blobY_host = ws.CreateBlob("Y_host");
+
+  vector<int> shapeA{6, 10};
+  vector<int> shapeX{6};
+  vector<int> shapeY{10};
+  auto* tensorA = blobA->GetMutable<Tensor<HIPContext>>();
+  tensorA->Resize(shapeA);
+  auto* tensorX = blobX->GetMutable<Tensor<HIPContext>>();
+  tensorX->Resize(shapeX);
+  auto* tensorY = blobY->GetMutable<Tensor<HIPContext>>();
+  tensorY->Resize(shapeY);
+  auto* tensorY_host = blobY_host->GetMutable<Tensor<CPUContext>>();
+  tensorY_host->Resize(shapeY);
+
+  EXPECT_EQ(tensorA->size(), 60);
+  EXPECT_EQ(tensorX->size(), 6);
+  EXPECT_EQ(tensorY->size(), 10);
+  math::Set<float, HIPContext>(
+      tensorA->size(), 1, tensorA->mutable_data<float>(), &context);
+  math::Set<float, HIPContext>(
+      tensorX->size(), 1, tensorX->mutable_data<float>(), &context);
+
+  const float kOne = 1.0;
+  const float kPointFive = 0.5;
+  const float kZero = 0.0;
+  math::Gemv<float, HIPContext>(
+      CblasTrans,
+      6,
+      10,
+      kOne,
+      tensorA->data<float>(),
+      tensorX->data<float>(),
+      kZero,
+      tensorY->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+  tensorY_host->CopyFrom<HIPContext, HIPContext>(*tensorY, &context);
+  context.FinishDeviceComputation();
+  for (int i = 0; i < tensorY_host->size(); ++i) {
+    CHECK_EQ(tensorY_host->data<float>()[i], 6) << i;
+  }
+
+  // Test Accumulate
+  math::Gemv<float, HIPContext>(
+      CblasTrans,
+      6,
+      10,
+      kOne,
+      tensorA->data<float>(),
+      tensorX->data<float>(),
+      kPointFive,
+      tensorY->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+  tensorY_host->CopyFrom<HIPContext, HIPContext>(*tensorY, &context);
+  context.FinishDeviceComputation();
+  for (int i = 0; i < tensorY_host->size(); ++i) {
+    CHECK_EQ(tensorY_host->data<float>()[i], 9) << i;
+  }
+
+  // Test Accumulate
+  math::Gemv<float, HIPContext>(
+      CblasTrans,
+      6,
+      10,
+      kPointFive,
+      tensorA->data<float>(),
+      tensorX->data<float>(),
+      kOne,
+      tensorY->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+  tensorY_host->CopyFrom<HIPContext, HIPContext>(*tensorY, &context);
+  context.FinishDeviceComputation();
+  for (int i = 0; i < tensorY_host->size(); ++i) {
+    CHECK_EQ(tensorY_host->data<float>()[i], 12) << i;
+  }
+}
+} // namespace caffe2
diff --git a/caffe2/utils/math_hip.cc b/caffe2/utils/math_hip.cc
new file mode 100644
index 0000000000000..05de45a4a46ad
--- /dev/null
+++ b/caffe2/utils/math_hip.cc
@@ -0,0 +1,3319 @@
+#include "hip/hip_runtime.h"
+// Implements the math functions for GPU.
+
+#include "caffe2/utils/math.h"
+
+#include <limits>
+#include <numeric>
+#include <vector>
+
+#include <cub/block/block_reduce.cuh>
+#include <cub/cub.cuh>
+
+#include <thrust/functional.h>
+
+#include "caffe2/core/hip/context_hip.h"
+#include "caffe2/utils/conversions.h"
+
+#if THRUST_VERSION >= 100800
+#define THRUST_SUPPORTS_PER_THREAD
+#endif // THRUST_VERSION >= 100800
+
+#define ROCBLAS_FP16 0
+
+namespace caffe2 {
+namespace math {
+
+namespace {
+
+inline __host__ __device__ bool Not(const bool x) {
+  return !x;
+}
+
+template <typename T>
+inline __host__ __device__ T Negate(const T& x) {
+  return -x;
+}
+
+template <typename T>
+inline __host__ __device__ T Square(const T& x) {
+  return x * x;
+}
+
+template <typename T>
+inline __host__ __device__ T Sign(const T& x) {
+  return x > 0 ? T(1) : (x < 0 ? T(-1) : T(0));
+}
+
+#define DELEGATE_SIMPLE_HOST_DEVICE_BINARY_FUNCTOR(Func, expr)        \
+  template <typename T>                                               \
+  struct Func##Functor {                                              \
+    inline __host__ __device__ T                                      \
+    operator()(const T& lhs, const T& rhs) const {                    \
+      return lhs expr rhs;                                            \
+    }                                                                 \
+  };                                                                  \
+  template <>                                                         \
+  struct Func##Functor<float16> {                                     \
+    inline __host__ __device__ float16                                \
+    operator()(const float16& lhs, const float16& rhs) const {        \
+      return convert::To<float, float16>(convert::To<float16, float>( \
+          lhs) expr convert::To<float16, float>(rhs));                \
+    }                                                                 \
+  };
+DELEGATE_SIMPLE_HOST_DEVICE_BINARY_FUNCTOR(Add, +)
+DELEGATE_SIMPLE_HOST_DEVICE_BINARY_FUNCTOR(Sub, -)
+DELEGATE_SIMPLE_HOST_DEVICE_BINARY_FUNCTOR(Mul, *)
+DELEGATE_SIMPLE_HOST_DEVICE_BINARY_FUNCTOR(Div, /)
+#undef DELEGATE_SIMPLE_HOST_DEVICE_BINARY_FUNCTOR
+
+template <typename TIn, typename TOut, class BinaryOperator>
+__global__ void SimpleBinaryOpHIPKernel(
+    const int N,
+    const BinaryOperator op,
+    const TIn* A,
+    const TIn* B,
+    TOut* C) {
+  HIP_1D_KERNEL_LOOP(i, N) {
+    C[i] = op(A[i], B[i]);
+  }
+}
+
+template <typename TIn, typename TOut, class BinaryOperator, bool broadcast_1st>
+__global__ void RowwiseBinaryOpHIPKenel(
+    const int rows,
+    const int cols,
+    const BinaryOperator op,
+    const TIn* A,
+    const TIn* B,
+    TOut* C) {
+  const int size = rows * cols;
+  HIP_1D_KERNEL_LOOP(C_index, size) {
+    const int j = C_index % cols;
+    const int A_index = broadcast_1st ? j : C_index;
+    const int B_index = broadcast_1st ? C_index : j;
+    C[C_index] = op(A[A_index], B[B_index]);
+  }
+}
+
+template <typename TIn, typename TOut, class BinaryOperator, bool broadcast_1st>
+__global__ void ColwiseBinaryOpHIPKenel(
+    const int rows,
+    const int cols,
+    const BinaryOperator op,
+    const TIn* A,
+    const TIn* B,
+    TOut* C) {
+  const int size = rows * cols;
+  HIP_1D_KERNEL_LOOP(C_index, size) {
+    const int i = C_index / cols;
+    const int A_index = broadcast_1st ? i : C_index;
+    const int B_index = broadcast_1st ? C_index : i;
+    C[C_index] = op(A[A_index], B[B_index]);
+  }
+}
+
+template <typename TIn, typename TOut, class BinaryOperator, int D>
+__global__ void BroadcastBinaryOpHIPKernel(
+    const int size,
+    const SimpleArray<int, D> A_strides,
+    const SimpleArray<int, D> B_strides,
+    const SimpleArray<int, D> C_dims,
+    const BinaryOperator op,
+    const TIn* A,
+    const TIn* B,
+    TOut* C) {
+  HIP_1D_KERNEL_LOOP(C_index, size) {
+    int A_index = 0;
+    int B_index = 0;
+    int C_index_val = C_index;
+#pragma unroll
+    for (int i = D - 1; i >= 0; --i) {
+      const int d = C_index_val % C_dims.data[i];
+      A_index += A_strides.data[i] == 0 ? 0 : d * A_strides.data[i];
+      B_index += B_strides.data[i] == 0 ? 0 : d * B_strides.data[i];
+      C_index_val /= C_dims.data[i];
+    }
+    C[C_index] = op(A[A_index], B[B_index]);
+  }
+}
+
+template <typename TIn, typename TOut, class BinaryOperator>
+void BinaryOpWith2DBroadcasting(
+    const int ndim,
+    const int* dims,
+    const int pivot,
+    const bool rowwise_broadcast,
+    const bool broadcast_1st,
+    const BinaryOperator& op,
+    const TIn* A,
+    const TIn* B,
+    TOut* C,
+    HIPContext* context) {
+  const int rows =
+      std::accumulate(dims, dims + pivot, 1, std::multiplies<int>());
+  const int cols =
+      std::accumulate(dims + pivot, dims + ndim, 1, std::multiplies<int>());
+  const int size = rows * cols;
+  if (rowwise_broadcast) {
+    if (broadcast_1st) {
+      hipLaunchKernelGGL(
+          (RowwiseBinaryOpHIPKenel<TIn, TOut, BinaryOperator, true>),
+          dim3(CAFFE_GET_BLOCKS(size)),
+          dim3(CAFFE_HIP_NUM_THREADS),
+          0,
+          context->hip_stream(),
+          rows,
+          cols,
+          op,
+          A,
+          B,
+          C);
+    } else {
+      hipLaunchKernelGGL(
+          (RowwiseBinaryOpHIPKenel<TIn, TOut, BinaryOperator, false>),
+          dim3(CAFFE_GET_BLOCKS(size)),
+          dim3(CAFFE_HIP_NUM_THREADS),
+          0,
+          context->hip_stream(),
+          rows,
+          cols,
+          op,
+          A,
+          B,
+          C);
+    }
+  } else {
+    if (broadcast_1st) {
+      hipLaunchKernelGGL(
+          (ColwiseBinaryOpHIPKenel<TIn, TOut, BinaryOperator, true>),
+          dim3(CAFFE_GET_BLOCKS(size)),
+          dim3(CAFFE_HIP_NUM_THREADS),
+          0,
+          context->hip_stream(),
+          rows,
+          cols,
+          op,
+          A,
+          B,
+          C);
+    } else {
+      hipLaunchKernelGGL(
+          (ColwiseBinaryOpHIPKenel<TIn, TOut, BinaryOperator, false>),
+          dim3(CAFFE_GET_BLOCKS(size)),
+          dim3(CAFFE_HIP_NUM_THREADS),
+          0,
+          context->hip_stream(),
+          rows,
+          cols,
+          op,
+          A,
+          B,
+          C);
+    }
+  }
+}
+
+template <typename TIn, typename TOut, class BinaryOperator, int D>
+void BroadcastBinaryOpImpl(
+    const int* A_dims,
+    const int* B_dims,
+    const int* C_dims,
+    const BinaryOperator& op,
+    const TIn* A,
+    const TIn* B,
+    TOut* C,
+    HIPContext* context) {
+  SimpleArray<int, D> A_strides_array;
+  SimpleArray<int, D> B_strides_array;
+  SimpleArray<int, D> C_dims_array;
+  int A_stride = 1;
+  int B_stride = 1;
+  for (int i = D - 1; i >= 0; --i) {
+    A_strides_array.data[i] = A_dims[i] == 1 ? 0 : A_stride;
+    B_strides_array.data[i] = B_dims[i] == 1 ? 0 : B_stride;
+    A_stride *= A_dims[i];
+    B_stride *= B_dims[i];
+  }
+  std::copy(C_dims, C_dims + D, C_dims_array.data);
+  const int size =
+      std::accumulate(C_dims, C_dims + D, 1, std::multiplies<int>());
+  hipLaunchKernelGGL(
+      (BroadcastBinaryOpHIPKernel<TIn, TOut, BinaryOperator, D>),
+      dim3(CAFFE_GET_BLOCKS(size)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      size,
+      A_strides_array,
+      B_strides_array,
+      C_dims_array,
+      op,
+      A,
+      B,
+      C);
+}
+
+template <typename TIn, typename TOut, class BinaryOperator>
+void BroadcastBinaryOp(
+    const int A_ndim,
+    const int* A_dims,
+    const int B_ndim,
+    const int* B_dims,
+    const BinaryOperator& op,
+    const TIn* A,
+    const TIn* B,
+    TOut* C,
+    HIPContext* context) {
+  const int ndim = std::max(A_ndim, B_ndim);
+  std::vector<int> A_dims_array(ndim);
+  std::vector<int> B_dims_array(ndim);
+  std::vector<int> C_dims_array(ndim);
+  utils::ComputeBroadcastBinaryOpDims(
+      A_ndim,
+      A_dims,
+      B_ndim,
+      B_dims,
+      A_dims_array.data(),
+      B_dims_array.data(),
+      C_dims_array.data());
+  if (A_dims_array == B_dims_array) {
+    const int size = std::accumulate(
+        C_dims_array.cbegin(), C_dims_array.cend(), 1, std::multiplies<int>());
+    hipLaunchKernelGGL(
+        (SimpleBinaryOpHIPKernel<TIn, TOut, BinaryOperator>),
+        dim3(CAFFE_GET_BLOCKS(size)),
+        dim3(CAFFE_HIP_NUM_THREADS),
+        0,
+        context->hip_stream(),
+        size,
+        op,
+        A,
+        B,
+        C);
+    return;
+  }
+  int pivot;
+  bool broadcast_1st;
+  if (utils::IsRowwiseBroadcastBinaryOp(
+          ndim,
+          A_dims_array.data(),
+          B_dims_array.data(),
+          &pivot,
+          &broadcast_1st)) {
+    BinaryOpWith2DBroadcasting<TIn, TOut, BinaryOperator>(
+        ndim,
+        C_dims_array.data(),
+        pivot,
+        true,
+        broadcast_1st,
+        op,
+        A,
+        B,
+        C,
+        context);
+    return;
+  }
+  if (utils::IsColwiseBroadcastBinaryOp(
+          ndim,
+          A_dims_array.data(),
+          B_dims_array.data(),
+          &pivot,
+          &broadcast_1st)) {
+    BinaryOpWith2DBroadcasting<TIn, TOut, BinaryOperator>(
+        ndim,
+        C_dims_array.data(),
+        pivot,
+        false,
+        broadcast_1st,
+        op,
+        A,
+        B,
+        C,
+        context);
+    return;
+  }
+  DISPATCH_FUNCTION_BY_VALUE_WITH_TYPE_3(
+      ndim,
+      BroadcastBinaryOpImpl,
+      TIn,
+      TOut,
+      BinaryOperator,
+      A_dims_array.data(),
+      B_dims_array.data(),
+      C_dims_array.data(),
+      op,
+      A,
+      B,
+      C,
+      context);
+}
+} // namespace
+
+#define DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(T, Func, op)            \
+  __global__ void Func##HIPKernel(const int N, const T* X, T* Y) { \
+    HIP_1D_KERNEL_LOOP(i, N) {                                     \
+      Y[i] = op(X[i]);                                             \
+    }                                                              \
+  }                                                                \
+  template <>                                                      \
+  void Func<T, HIPContext>(                                        \
+      const int N, const T* x, T* y, HIPContext* context) {        \
+    hipLaunchKernelGGL(                                            \
+        (Func##HIPKernel),                                         \
+        CAFFE_GET_BLOCKS(N),                                       \
+        CAFFE_HIP_NUM_THREADS,                                     \
+        0,                                                         \
+        context->hip_stream(),                                     \
+        N,                                                         \
+        x,                                                         \
+        y);                                                        \
+  }
+
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Exp, expf)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Log, logf)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Cos, cosf)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Acos, acosf)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Sin, sinf)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Asin, asinf)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Tan, tanf)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Atan, atanf)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Abs, fabsf)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Sqrt, sqrtf)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, InvSqrt, rsqrtf)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Sqr, Square<float>)
+
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(bool, Not, Not)
+
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Neg, Negate<float>)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(double, Neg, Negate<double>)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(std::int32_t, Neg, Negate<std::int32_t>)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(std::int64_t, Neg, Negate<std::int64_t>)
+
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(float, Sign, Sign<float>)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(double, Sign, Sign<double>)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(std::int32_t, Sign, Sign<std::int32_t>)
+DELEGATE_SIMPLE_HIP_UNARY_FUNCTION(std::int64_t, Sign, Sign<std::int64_t>)
+
+#undef DELEGATE_SIMPLE_HIP_UNARY_FUNCTION
+
+#define DELEGATE_SINCOS_HIP_FUNCTION(T, fn)                         \
+  __global__ void _Kernel_##T##_##SinCos(                           \
+      const int N, const T* x, T* ys, T* yc) {                      \
+    HIP_1D_KERNEL_LOOP(i, N) {                                      \
+      fn(__ldg(x + i), ys + i, yc + i);                             \
+    }                                                               \
+  }                                                                 \
+  template <>                                                       \
+  void SinCos<T, HIPContext>(                                       \
+      const int N, const T* x, T* ys, T* yc, HIPContext* context) { \
+    hipLaunchKernelGGL(                                             \
+        (_Kernel_##T##_##SinCos),                                   \
+        CAFFE_GET_BLOCKS(N),                                        \
+        CAFFE_HIP_NUM_THREADS,                                      \
+        0,                                                          \
+        context->hip_stream(),                                      \
+        N,                                                          \
+        x,                                                          \
+        ys,                                                         \
+        yc);                                                        \
+  }
+
+DELEGATE_SINCOS_HIP_FUNCTION(float, sincosf)
+DELEGATE_SINCOS_HIP_FUNCTION(double, sincos)
+
+#undef DELEGATE_SINCOS_HIP_FUNCTION
+
+#define DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(TIn, TOut, Func, Op)               \
+  template <>                                                                  \
+  void Func<TIn, HIPContext>(                                                  \
+      const int N, const TIn* A, const TIn* B, TOut* C, HIPContext* context) { \
+    hipLaunchKernelGGL(                                                        \
+        (SimpleBinaryOpHIPKernel<TIn, TOut, Op<TIn>>),                         \
+        CAFFE_GET_BLOCKS(N),                                                   \
+        CAFFE_HIP_NUM_THREADS,                                                 \
+        0,                                                                     \
+        context->hip_stream(),                                                 \
+        N,                                                                     \
+        Op<TIn>(),                                                             \
+        A,                                                                     \
+        B,                                                                     \
+        C);                                                                    \
+  }
+
+#define DEFINE_SIMPLE_HIP_COMPARE_FUNCTION(Func, Op)                \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(std::int32_t, bool, Func, Op) \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(std::int64_t, bool, Func, Op) \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(float, bool, Func, Op)        \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(double, bool, Func, Op)       \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(bool, bool, Func, Op)
+
+DEFINE_SIMPLE_HIP_COMPARE_FUNCTION(EQ, thrust::equal_to)
+DEFINE_SIMPLE_HIP_COMPARE_FUNCTION(NE, thrust::not_equal_to)
+DEFINE_SIMPLE_HIP_COMPARE_FUNCTION(LT, thrust::less)
+DEFINE_SIMPLE_HIP_COMPARE_FUNCTION(LE, thrust::less_equal)
+DEFINE_SIMPLE_HIP_COMPARE_FUNCTION(GT, thrust::greater)
+DEFINE_SIMPLE_HIP_COMPARE_FUNCTION(GE, thrust::greater_equal)
+
+#undef DEFINE_SIMPLE_HIP_COMPARE_FUNCTION
+
+#define DEFINE_SIMPLE_HIP_BINARY_FUNCTION(Func, Op)                         \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(std::int32_t, std::int32_t, Func, Op) \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(std::int64_t, std::int64_t, Func, Op) \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(float, float, Func, Op)               \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(double, double, Func, Op)             \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(float16, float16, Func, Op)
+
+DEFINE_SIMPLE_HIP_BINARY_FUNCTION(Add, AddFunctor)
+DEFINE_SIMPLE_HIP_BINARY_FUNCTION(Sub, SubFunctor)
+DEFINE_SIMPLE_HIP_BINARY_FUNCTION(Mul, MulFunctor)
+DEFINE_SIMPLE_HIP_BINARY_FUNCTION(Div, DivFunctor)
+
+#undef DEFINE_SIMPLE_HIP_BINARY_FUNCTION
+
+DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(bool, bool, And, thrust::logical_and)
+DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(bool, bool, Or, thrust::logical_or)
+DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(bool, bool, Xor, thrust::bit_xor)
+
+#define DEFINE_SIMPLE_HIP_BITWISE_BINARY_FUNCTION(Func, Op)                 \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(bool, bool, Func, Op)                 \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(std::int32_t, std::int32_t, Func, Op) \
+  DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(std::int64_t, std::int64_t, Func, Op)
+
+DEFINE_SIMPLE_HIP_BITWISE_BINARY_FUNCTION(BitwiseAnd, thrust::bit_and)
+DEFINE_SIMPLE_HIP_BITWISE_BINARY_FUNCTION(BitwiseOr, thrust::bit_or)
+DEFINE_SIMPLE_HIP_BITWISE_BINARY_FUNCTION(BitwiseXor, thrust::bit_xor)
+
+#undef DEFINE_SIMPLE_HIP_BITWISE_BINARY_FUNCTION
+
+DELEGATE_SIMPLE_HIP_BINARY_FUNCTION(float, float, ElemwiseMax, thrust::maximum);
+
+#undef DELEGATE_SIMPLE_HIP_BINARY_FUNCTION
+
+#define DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(TIn, TOut, Func, Op) \
+  template <>                                                          \
+  void Rowwise##Func<TIn, HIPContext, true>(                           \
+      const int rows,                                                  \
+      const int cols,                                                  \
+      const TIn* A,                                                    \
+      const TIn* B,                                                    \
+      TOut* C,                                                         \
+      HIPContext* context) {                                           \
+    const int size = rows * cols;                                      \
+    hipLaunchKernelGGL(                                                \
+        (RowwiseBinaryOpHIPKenel<TIn, TOut, Op<TIn>, true>),           \
+        CAFFE_GET_BLOCKS(size),                                        \
+        CAFFE_HIP_NUM_THREADS,                                         \
+        0,                                                             \
+        context->hip_stream(),                                         \
+        rows,                                                          \
+        cols,                                                          \
+        Op<TIn>(),                                                     \
+        A,                                                             \
+        B,                                                             \
+        C);                                                            \
+  }                                                                    \
+  template <>                                                          \
+  void Rowwise##Func<TIn, HIPContext, false>(                          \
+      const int rows,                                                  \
+      const int cols,                                                  \
+      const TIn* A,                                                    \
+      const TIn* B,                                                    \
+      TOut* C,                                                         \
+      HIPContext* context) {                                           \
+    const int size = rows * cols;                                      \
+    hipLaunchKernelGGL(                                                \
+        (RowwiseBinaryOpHIPKenel<TIn, TOut, Op<TIn>, false>),          \
+        CAFFE_GET_BLOCKS(size),                                        \
+        CAFFE_HIP_NUM_THREADS,                                         \
+        0,                                                             \
+        context->hip_stream(),                                         \
+        rows,                                                          \
+        cols,                                                          \
+        Op<TIn>(),                                                     \
+        A,                                                             \
+        B,                                                             \
+        C);                                                            \
+  }                                                                    \
+  template <>                                                          \
+  void Colwise##Func<TIn, HIPContext, true>(                           \
+      const int rows,                                                  \
+      const int cols,                                                  \
+      const TIn* A,                                                    \
+      const TIn* B,                                                    \
+      TOut* C,                                                         \
+      HIPContext* context) {                                           \
+    const int size = rows * cols;                                      \
+    hipLaunchKernelGGL(                                                \
+        (ColwiseBinaryOpHIPKenel<TIn, TOut, Op<TIn>, true>),           \
+        CAFFE_GET_BLOCKS(size),                                        \
+        CAFFE_HIP_NUM_THREADS,                                         \
+        0,                                                             \
+        context->hip_stream(),                                         \
+        rows,                                                          \
+        cols,                                                          \
+        Op<TIn>(),                                                     \
+        A,                                                             \
+        B,                                                             \
+        C);                                                            \
+  }                                                                    \
+  template <>                                                          \
+  void Colwise##Func<TIn, HIPContext, false>(                          \
+      const int rows,                                                  \
+      const int cols,                                                  \
+      const TIn* A,                                                    \
+      const TIn* B,                                                    \
+      TOut* C,                                                         \
+      HIPContext* context) {                                           \
+    const int size = rows * cols;                                      \
+    hipLaunchKernelGGL(                                                \
+        (ColwiseBinaryOpHIPKenel<TIn, TOut, Op<TIn>, false>),          \
+        CAFFE_GET_BLOCKS(size),                                        \
+        CAFFE_HIP_NUM_THREADS,                                         \
+        0,                                                             \
+        context->hip_stream(),                                         \
+        rows,                                                          \
+        cols,                                                          \
+        Op<TIn>(),                                                     \
+        A,                                                             \
+        B,                                                             \
+        C);                                                            \
+  }
+
+#define DEFINE_2D_BROADCAST_HIP_COMPARE_FUNCTION(Func, Op)                \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(std::int32_t, bool, Func, Op) \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(std::int64_t, bool, Func, Op) \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(float, bool, Func, Op)        \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(double, bool, Func, Op)       \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(bool, bool, Func, Op)
+
+DEFINE_2D_BROADCAST_HIP_COMPARE_FUNCTION(EQ, thrust::equal_to)
+DEFINE_2D_BROADCAST_HIP_COMPARE_FUNCTION(NE, thrust::not_equal_to)
+DEFINE_2D_BROADCAST_HIP_COMPARE_FUNCTION(LT, thrust::less)
+DEFINE_2D_BROADCAST_HIP_COMPARE_FUNCTION(LE, thrust::less_equal)
+DEFINE_2D_BROADCAST_HIP_COMPARE_FUNCTION(GT, thrust::greater)
+DEFINE_2D_BROADCAST_HIP_COMPARE_FUNCTION(GE, thrust::greater_equal)
+
+#undef DEFINE_2D_BROADCAST_HIP_COMPARE_FUNCTION
+
+#define DEFINE_2D_BROADCAST_HIP_BINARY_FUNCTION(Func, Op)             \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(                          \
+      std::int32_t, std::int32_t, Func, Op)                           \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(                          \
+      std::int64_t, std::int64_t, Func, Op)                           \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(float, float, Func, Op)   \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(double, double, Func, Op) \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(float16, float16, Func, Op)
+
+DEFINE_2D_BROADCAST_HIP_BINARY_FUNCTION(Add, AddFunctor)
+DEFINE_2D_BROADCAST_HIP_BINARY_FUNCTION(Sub, SubFunctor)
+DEFINE_2D_BROADCAST_HIP_BINARY_FUNCTION(Mul, MulFunctor)
+DEFINE_2D_BROADCAST_HIP_BINARY_FUNCTION(Div, DivFunctor)
+
+#undef DEFINE_2D_BROADCAST_HIP_BINARY_FUNCTION
+
+DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(bool, bool, And, thrust::logical_and)
+DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(bool, bool, Or, thrust::logical_or)
+DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(bool, bool, Xor, thrust::bit_xor)
+
+#define DEFINE_2D_BROADCAST_HIP_BITWISE_BINARY_FUNCTION(Func, Op) \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(bool, bool, Func, Op) \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(                      \
+      std::int32_t, std::int32_t, Func, Op)                       \
+  DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION(                      \
+      std::int64_t, std::int64_t, Func, Op)
+
+DEFINE_2D_BROADCAST_HIP_BITWISE_BINARY_FUNCTION(BitwiseAnd, thrust::bit_and)
+DEFINE_2D_BROADCAST_HIP_BITWISE_BINARY_FUNCTION(BitwiseOr, thrust::bit_or)
+DEFINE_2D_BROADCAST_HIP_BITWISE_BINARY_FUNCTION(BitwiseXor, thrust::bit_xor)
+
+#undef DEFINE_2D_BROADCAST_HIP_BITWISE_BINARY_FUNCTION
+
+#undef DELEGATE_2D_BROADCAST_HIP_BINARY_FUNCTION
+
+#define DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(TIn, TOut, Func, Op)   \
+  template <>                                                         \
+  void Func<TIn, HIPContext>(                                         \
+      const int A_ndim,                                               \
+      const int* A_dims,                                              \
+      const int B_ndim,                                               \
+      const int* B_dims,                                              \
+      const TIn* A,                                                   \
+      const TIn* B,                                                   \
+      TOut* C,                                                        \
+      HIPContext* context) {                                          \
+    BroadcastBinaryOp<TIn, TOut, Op<TIn>>(                            \
+        A_ndim, A_dims, B_ndim, B_dims, Op<TIn>(), A, B, C, context); \
+  }
+
+#define DEFINE_BROADCAST_HIP_COMPARE_FUNCTION(Func, Op)                \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(std::int32_t, bool, Func, Op) \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(std::int64_t, bool, Func, Op) \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(float, bool, Func, Op)        \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(double, bool, Func, Op)       \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(bool, bool, Func, Op)
+
+DEFINE_BROADCAST_HIP_COMPARE_FUNCTION(EQ, thrust::equal_to)
+DEFINE_BROADCAST_HIP_COMPARE_FUNCTION(NE, thrust::not_equal_to)
+DEFINE_BROADCAST_HIP_COMPARE_FUNCTION(LT, thrust::less)
+DEFINE_BROADCAST_HIP_COMPARE_FUNCTION(LE, thrust::less_equal)
+DEFINE_BROADCAST_HIP_COMPARE_FUNCTION(GT, thrust::greater)
+DEFINE_BROADCAST_HIP_COMPARE_FUNCTION(GE, thrust::greater_equal)
+
+#undef DEFINE_BROADCAST_HIP_COMPARE_FUNCTION
+
+#define DEFINE_BROADCAST_HIP_BINARY_FUNCTION(Func, Op)                         \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(std::int32_t, std::int32_t, Func, Op) \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(std::int64_t, std::int64_t, Func, Op) \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(float, float, Func, Op)               \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(double, double, Func, Op)             \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(float16, float16, Func, Op)
+
+DEFINE_BROADCAST_HIP_BINARY_FUNCTION(Add, AddFunctor)
+DEFINE_BROADCAST_HIP_BINARY_FUNCTION(Sub, SubFunctor)
+DEFINE_BROADCAST_HIP_BINARY_FUNCTION(Mul, MulFunctor)
+DEFINE_BROADCAST_HIP_BINARY_FUNCTION(Div, DivFunctor)
+
+#undef DEFINE_BROADCAST_HIP_BINARY_FUNCTION
+
+DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(bool, bool, And, thrust::logical_and)
+DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(bool, bool, Or, thrust::logical_or)
+DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(bool, bool, Xor, thrust::bit_xor)
+
+#define DEFINE_BROADCAST_HIP_BITWISE_BINARY_FUNCTION(Func, Op)                 \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(bool, bool, Func, Op)                 \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(std::int32_t, std::int32_t, Func, Op) \
+  DELEGATE_BROADCAST_HIP_BINARY_FUNCTION(std::int64_t, std::int64_t, Func, Op)
+
+DEFINE_BROADCAST_HIP_BITWISE_BINARY_FUNCTION(BitwiseAnd, thrust::bit_and)
+DEFINE_BROADCAST_HIP_BITWISE_BINARY_FUNCTION(BitwiseOr, thrust::bit_or)
+DEFINE_BROADCAST_HIP_BITWISE_BINARY_FUNCTION(BitwiseXor, thrust::bit_xor)
+
+#undef DEFINE_BROADCAST_HIP_BITWISE_BINARY_FUNCTION
+
+#undef DELEGATE_BROADCAST_HIP_BINARY_FUNCTION
+
+#define DELEGATE_REDUCTION_FUNCTION(T, Funcname, func)                  \
+  template <>                                                           \
+  void Funcname<T, HIPContext>(                                         \
+      const int N,                                                      \
+      const T* src,                                                     \
+      T* dst,                                                           \
+      Tensor<HIPContext>* scratch_ptr,                                  \
+      HIPContext* context) {                                            \
+    size_t memRequired = 0;                                             \
+    cub::DeviceReduce::func(                                            \
+        nullptr, memRequired, src, dst, N, context->hip_stream());      \
+    auto buffer_size =                                                  \
+        static_cast<TIndex>((memRequired + sizeof(T) - 1) / sizeof(T)); \
+    scratch_ptr->Resize(std::vector<TIndex>{buffer_size});              \
+    cub::DeviceReduce::func(                                            \
+        static_cast<void*>(scratch_ptr->mutable_data<T>()),             \
+        memRequired,                                                    \
+        src,                                                            \
+        dst,                                                            \
+        N,                                                              \
+        context->hip_stream());                                         \
+  }
+
+DELEGATE_REDUCTION_FUNCTION(float, ReduceMin, Min)
+DELEGATE_REDUCTION_FUNCTION(float, ReduceMax, Max)
+DELEGATE_REDUCTION_FUNCTION(int32_t, ReduceMax, Max)
+DELEGATE_REDUCTION_FUNCTION(int64_t, ReduceMax, Max)
+
+#undef DELEGATE_REDUCTION_FUNCTION
+
+// Caffe2 gemm provides a simpler interface to the gemm functions, with the
+// limitation that the data has to be contiguous in memory.
+template <>
+void Gemm<float, HIPContext>(
+    const CBLAS_TRANSPOSE TransA,
+    const CBLAS_TRANSPOSE TransB,
+    const int M,
+    const int N,
+    const int K,
+    const float alpha,
+    const float* A,
+    const float* B,
+    const float beta,
+    float* C,
+    HIPContext* context,
+    TensorProto::DataType math_type) {
+  // Note that rocblas follows fortran order, so the order is different from
+  // the cblas convention.
+  int lda = (TransA == CblasNoTrans) ? K : M;
+  int ldb = (TransB == CblasNoTrans) ? N : K;
+  rocblas_operation cuTransA = (TransA == CblasNoTrans)
+      ? rocblas_operation_none
+      : rocblas_operation_transpose;
+  rocblas_operation cuTransB = (TransB == CblasNoTrans)
+      ? rocblas_operation_none
+      : rocblas_operation_transpose;
+  ROCBLAS_ENFORCE(rocblas_sgemm(
+      context->rocblas_handle(),
+      cuTransB,
+      cuTransA,
+      N,
+      M,
+      K,
+      &alpha,
+      B,
+      ldb,
+      A,
+      lda,
+      &beta,
+      C,
+      N));
+}
+
+template <>
+void Gemm<float16, HIPContext>(
+    const CBLAS_TRANSPOSE TransA,
+    const CBLAS_TRANSPOSE TransB,
+    const int M,
+    const int N,
+    const int K,
+    const float alpha,
+    const float16* A,
+    const float16* B,
+    const float beta,
+    float16* C,
+    HIPContext* context,
+    TensorProto::DataType math_type) {
+  CAFFE_THROW("Unsupported math type");
+#if ROCBLAS_FP16 // rocblas does not support fp16 yet
+  // Note that cublas follows fortran order, so the order is different from
+  // the cblas convention.
+  int lda = (TransA == CblasNoTrans) ? K : M;
+  int ldb = (TransB == CblasNoTrans) ? N : K;
+  rocblas_operation cuTransA = (TransA == CblasNoTrans)
+      ? rocblas_operation_none
+      : rocblas_operation_transpose;
+  rocblas_operation cuTransB = (TransB == CblasNoTrans)
+      ? rocblas_operation_none
+      : rocblas_operation_transpose;
+  if (math_type == TensorProto_DataType_FLOAT) {
+    ROCBLAS_CHECK(rocblas_sgemmEx(
+        context->rocblas_handle(),
+        cuTransB,
+        cuTransA,
+        N,
+        M,
+        K,
+        &alpha,
+        B,
+        CUDA_R_16F,
+        ldb,
+        A,
+        CUDA_R_16F,
+        lda,
+        &beta,
+        C,
+        CUDA_R_16F,
+        N));
+
+  } else if (math_type == TensorProto_DataType_FLOAT16) {
+    // convert alpha, beta from float -> __half
+    /*auto alpha_fp16 = convert::floatToHalf(alpha);
+    auto beta_fp16 = convert::floatToHalf(beta);
+
+    // call cublasHgemm
+    ROCBLAS_CHECK(cublasHgemm(
+        context->rocblas_handle(),
+        cuTransB,
+        cuTransA,
+        N,
+        M,
+        K,
+        &alpha_fp16,
+        (const __half*)B,
+        ldb,
+        (const __half*)A,
+        lda,
+        &beta_fp16,
+        (__half*)C,
+        N));*/
+  } else {
+    // fail
+    CAFFE_THROW("Unsupported math type");
+  }
+#endif
+}
+
+template <>
+void BiasCHW<float, HIPContext>(
+    const float* bias,
+    const float* bias_multiplier,
+    const int bias_channels,
+    const int image_size,
+    float* image,
+    HIPContext* context) {
+  Gemm<float, HIPContext>(
+      CblasNoTrans,
+      CblasNoTrans,
+      bias_channels,
+      image_size,
+      1,
+      1,
+      bias,
+      bias_multiplier,
+      1,
+      image,
+      context);
+}
+
+template <>
+void GemmBatched<float, HIPContext>(
+    const CBLAS_TRANSPOSE TransA,
+    const CBLAS_TRANSPOSE TransB,
+    const int batch_size,
+    const int M,
+    const int N,
+    const int K,
+    const float alpha,
+    const float* A,
+    const float* B,
+    const float beta,
+    float* C,
+    HIPContext* context,
+    Tensor<HIPContext>* scratch,
+    TensorProto::DataType math_type) {
+  const int a_stride = M * K;
+  const int b_stride = K * N;
+  const int c_stride = M * N;
+  // Note that cublas follows fortran order, so the order is different from
+  // the cblas convention.
+  const int lda = (TransA == CblasNoTrans) ? K : M;
+  const int ldb = (TransB == CblasNoTrans) ? N : K;
+  rocblas_operation cuTransA = (TransA == CblasNoTrans)
+      ? rocblas_operation_none
+      : rocblas_operation_transpose;
+  rocblas_operation cuTransB = (TransB == CblasNoTrans)
+      ? rocblas_operation_none
+      : rocblas_operation_transpose;
+  ROCBLAS_ENFORCE(rocblas_sgemm_strided_batched(
+      context->rocblas_handle(),
+      cuTransB,
+      cuTransA,
+      N,
+      M,
+      K,
+      &alpha,
+      B,
+      ldb,
+      b_stride,
+      A,
+      lda,
+      a_stride,
+      &beta,
+      C,
+      N,
+      c_stride,
+      batch_size));
+}
+
+namespace {
+
+__global__ void FloatToHalfKernel(const int N, const float* X, half* Y) {
+  HIP_1D_KERNEL_LOOP(i, N) {
+    Y[i] = __float2half(X[i]);
+  }
+}
+
+__global__ void HalfToFloatKernel(const int N, const half* X, float* Y) {
+  HIP_1D_KERNEL_LOOP(i, N) {
+    Y[i] = __half2float(X[i]);
+  }
+}
+
+}; // namespace
+
+template <>
+void GemmBatched<float16, HIPContext>(
+    const CBLAS_TRANSPOSE TransA,
+    const CBLAS_TRANSPOSE TransB,
+    const int batch_size,
+    const int M,
+    const int N,
+    const int K,
+    const float alpha,
+    const float16* A,
+    const float16* B,
+    const float beta,
+    float16* C,
+    HIPContext* context,
+    Tensor<HIPContext>* scratch,
+    TensorProto::DataType math_type) {
+  const int a_stride = M * K;
+  const int b_stride = K * N;
+  const int c_stride = M * N;
+
+  // 3 options:
+  // 1) scratch != null = cast to fp32, SgemmStridedBatched, cast result to fp16
+  // 2) math_type == FLOAT, scratch == nullptr = looped SgemmEx
+  // 3) math_type == FLOAT16, scratch == nullptr = batched Hgemm
+
+  if (scratch != nullptr) {
+    const int A_size = a_stride * batch_size;
+    const int B_size = b_stride * batch_size;
+    // cast, cublasSgemmStridedBatched, cast
+    size_t in_elems = A_size + B_size;
+    size_t out_elems = c_stride * batch_size;
+
+    scratch->Resize(in_elems + out_elems);
+    float* scratch_ptr = scratch->mutable_data<float>();
+
+    float* A_fp32 = scratch_ptr;
+    float* B_fp32 = scratch_ptr + A_size;
+    float* C_fp32 = scratch_ptr + A_size + B_size;
+
+    // cast A, B into fp32
+    hipLaunchKernelGGL(
+        (HalfToFloatKernel),
+        dim3(CAFFE_GET_BLOCKS(A_size)),
+        dim3(CAFFE_HIP_NUM_THREADS),
+        0,
+        context->hip_stream(),
+        A_size,
+        (half*)A,
+        A_fp32);
+    hipLaunchKernelGGL(
+        (HalfToFloatKernel),
+        dim3(CAFFE_GET_BLOCKS(B_size)),
+        dim3(CAFFE_HIP_NUM_THREADS),
+        0,
+        context->hip_stream(),
+        B_size,
+        (half*)B,
+        B_fp32);
+
+    // run fp32 batched Gemm
+    GemmBatched<float, HIPContext>(
+        TransA,
+        TransB,
+        batch_size,
+        M,
+        N,
+        K,
+        alpha,
+        A_fp32,
+        B_fp32,
+        beta,
+        C_fp32,
+        context);
+
+    // cast result back to fp16
+    hipLaunchKernelGGL(
+        (FloatToHalfKernel),
+        dim3(CAFFE_GET_BLOCKS(batch_size * M * N)),
+        dim3(CAFFE_HIP_NUM_THREADS),
+        0,
+        context->hip_stream(),
+        batch_size * M * N,
+        C_fp32,
+        (half*)C);
+  } else {
+#if ROCBLAS_FP16 // rocblas does not support fp16 yet
+    if (math_type == TensorProto_DataType_FLOAT) {
+      // loop over matrices in the batch
+      for (int i = 0; i < batch_size; ++i) {
+        math::Gemm<float16, HIPContext>(
+            TransA,
+            TransB,
+            M,
+            N,
+            K,
+            alpha,
+            A + a_stride * i,
+            B + b_stride * i,
+            beta,
+            C + c_stride * i,
+            context);
+      }
+    } else if (math_type == TensorProto_DataType_FLOAT16) {
+      // Note that cublas follows fortran order, so the order is different from
+      // the cblas convention.
+      const int lda = (TransA == CblasNoTrans) ? K : M;
+      const int ldb = (TransB == CblasNoTrans) ? N : K;
+      rocblas_operation cuTransA = (TransA == CblasNoTrans)
+          ? rocblas_operation_none
+          : rocblas_operation_transpose;
+      rocblas_operation cuTransB = (TransB == CblasNoTrans)
+          ? rocblas_operation_none
+          : rocblas_operation_transpose;
+
+      // convert alpha, beta from float -> __half
+      auto alpha_fp16 = convert::floatToHalf(alpha);
+      auto beta_fp16 = convert::floatToHalf(beta);
+      ROCBLAS_ENFORCE(cublasHgemmStridedBatched(
+          context->rocblas_handle(),
+          cuTransB,
+          cuTransA,
+          N,
+          M,
+          K,
+          &alpha_fp16,
+          (const __half*)B,
+          ldb,
+          b_stride,
+          (const __half*)A,
+          lda,
+          a_stride,
+          &beta_fp16,
+          (__half*)C,
+          N,
+          c_stride,
+          batch_size));
+    }
+#endif
+  }
+}
+
+template <>
+void GemmEx<float, HIPContext>(
+    const CBLAS_TRANSPOSE TransA,
+    const CBLAS_TRANSPOSE TransB,
+    const int M,
+    const int N,
+    const int K,
+    const float alpha,
+    const float* A,
+    const int lda,
+    const float* B,
+    const int ldb,
+    const float beta,
+    float* C,
+    const int ldc,
+    HIPContext* context) {
+  // Note that cublas follows fortran order, so the order is different from
+  // the cblas convention.
+  rocblas_operation cuTransA = (TransA == CblasNoTrans)
+      ? rocblas_operation_none
+      : rocblas_operation_transpose;
+  rocblas_operation cuTransB = (TransB == CblasNoTrans)
+      ? rocblas_operation_none
+      : rocblas_operation_transpose;
+  ROCBLAS_ENFORCE(rocblas_sgemm(
+      context->rocblas_handle(),
+      cuTransB,
+      cuTransA,
+      N,
+      M,
+      K,
+      &alpha,
+      B,
+      ldb,
+      A,
+      lda,
+      &beta,
+      C,
+      ldc));
+}
+
+template <>
+void Gemv<float, HIPContext>(
+    const CBLAS_TRANSPOSE TransA,
+    const int M,
+    const int N,
+    const float alpha,
+    const float* A,
+    const float* x,
+    const float beta,
+    float* y,
+    HIPContext* context,
+    TensorProto::DataType math_type) {
+  rocblas_operation cuTransA = (TransA == CblasNoTrans)
+      ? rocblas_operation_transpose
+      : rocblas_operation_none;
+  ROCBLAS_ENFORCE(rocblas_sgemv(
+      context->rocblas_handle(),
+      cuTransA,
+      N,
+      M,
+      &alpha,
+      A,
+      N,
+      x,
+      1,
+      &beta,
+      y,
+      1));
+}
+
+// Batched Add variants
+namespace {
+
+template <typename T>
+__global__ void AddStripedBatchKernel(
+    const int N,
+    const T* first,
+    T* Y,
+    const int stripe,
+    const int batch) {
+  for (int j = 0; j < batch; j++) {
+    const T* x = first + j * stripe;
+    HIP_1D_KERNEL_LOOP(i, N) {
+      float tmpY = convert::To<T, float>(Y[i]);
+      tmpY += convert::To<T, float>(x[i]);
+      Y[i] = convert::To<float, T>(tmpY);
+    }
+  }
+}
+} // namespace
+
+#define CAFFE2_SPECIALIZED_HIP_ADD_STRIPED_BATCH(T) \
+  template <>                                       \
+  void AddStripedBatch<T, HIPContext>(              \
+      const int N,                                  \
+      const T* first,                               \
+      T* Y,                                         \
+      const int stripe,                             \
+      const int batch,                              \
+      HIPContext* context) {                        \
+    hipLaunchKernelGGL(                             \
+        (AddStripedBatchKernel<T>),                 \
+        CAFFE_GET_BLOCKS(N),                        \
+        CAFFE_HIP_NUM_THREADS,                      \
+        0,                                          \
+        context->hip_stream(),                      \
+        N,                                          \
+        first,                                      \
+        Y,                                          \
+        stripe,                                     \
+        batch);                                     \
+  }
+
+CAFFE2_SPECIALIZED_HIP_ADD_STRIPED_BATCH(float);
+CAFFE2_SPECIALIZED_HIP_ADD_STRIPED_BATCH(float16);
+#undef CAFFE2_SPECIALIZED_HIP_ADD_STRIPED_BATCH
+
+template <>
+void Gemv<float16, HIPContext>(
+    const CBLAS_TRANSPOSE TransA,
+    const int M,
+    const int N,
+    const float alpha,
+    const float16* A,
+    const float16* x,
+    const float beta,
+    float16* y,
+    HIPContext* context,
+    TensorProto::DataType math_type) {
+  CAFFE_THROW("Unsupported math type");
+#if ROCBLAS_FP16 // rocblas does not support fp16 yet
+  rocblas_operation cuTransA = (TransA == CblasNoTrans)
+      ? rocblas_operation_transpose
+      : rocblas_operation_none;
+
+  // sort out what we need to call cublasSgemmEx / cublasHgemm
+  int m = (cuTransA == rocblas_operation_none) ? N : M;
+  int k = (cuTransA == rocblas_operation_none) ? M : N;
+  int LDA = (cuTransA == rocblas_operation_none) ? m : k;
+  int LDC = m;
+
+  if (math_type == TensorProto_DataType_FLOAT) {
+    ROCBLAS_CHECK(cublasSgemmEx(
+        context->rocblas_handle(),
+        cuTransA,
+        rocblas_operation_none,
+        m,
+        1,
+        k,
+        &alpha,
+        A,
+        CUDA_R_16F,
+        LDA,
+        x,
+        CUDA_R_16F,
+        k,
+        &beta,
+        y,
+        CUDA_R_16F,
+        LDC));
+  } else if (math_type == TensorProto_DataType_FLOAT16) {
+    auto alpha_fp16 = convert::floatToHalf(alpha);
+    auto beta_fp16 = convert::floatToHalf(beta);
+
+    ROCBLAS_CHECK(cublasHgemm(
+        context->rocblas_handle(),
+        cuTransA,
+        rocblas_operation_none,
+        m,
+        1,
+        k,
+        &alpha_fp16,
+        (const __half*)A,
+        LDA,
+        (const __half*)x,
+        k,
+        &beta_fp16,
+        (__half*)y,
+        LDC));
+  } else {
+    // fail
+    CAFFE_THROW("Unsupported math type");
+  }
+#endif
+}
+namespace {
+template <typename T>
+__global__ void SetKernel(const int N, const T alpha, T* Y) {
+  HIP_1D_KERNEL_LOOP(i, N) {
+    Y[i] = alpha;
+  }
+}
+} // namespace
+
+#define CAFFE2_SPECIALIZED_HIP_SET(T)                             \
+  template <>                                                     \
+  void Set<T, HIPContext>(                                        \
+      const size_t N, const T alpha, T* Y, HIPContext* context) { \
+    hipLaunchKernelGGL(                                           \
+        (SetKernel),                                              \
+        CAFFE_GET_BLOCKS(N),                                      \
+        CAFFE_HIP_NUM_THREADS,                                    \
+        0,                                                        \
+        context->hip_stream(),                                    \
+        static_cast<const int>(N),                                \
+        alpha,                                                    \
+        Y);                                                       \
+  }
+
+CAFFE2_SPECIALIZED_HIP_SET(float);
+CAFFE2_SPECIALIZED_HIP_SET(double);
+CAFFE2_SPECIALIZED_HIP_SET(bool);
+CAFFE2_SPECIALIZED_HIP_SET(int8_t);
+CAFFE2_SPECIALIZED_HIP_SET(int16_t);
+CAFFE2_SPECIALIZED_HIP_SET(float16);
+CAFFE2_SPECIALIZED_HIP_SET(int);
+CAFFE2_SPECIALIZED_HIP_SET(int64_t);
+CAFFE2_SPECIALIZED_HIP_SET(char);
+CAFFE2_SPECIALIZED_HIP_SET(uint8_t);
+CAFFE2_SPECIALIZED_HIP_SET(uint16_t);
+#undef CAFFE2_SPECIALIZED_HIP_SET
+
+namespace {
+template <typename T>
+__global__ void
+UniformShift(const size_t N, const float min, const float max, T* x) {
+  float scale = max - min;
+  HIP_1D_KERNEL_LOOP(i, N) {
+    x[i] = convert::To<float, T>(convert::To<T, float>(x[i]) * scale + min);
+  }
+}
+
+__global__ void
+UniformIntFit(const size_t N, const int min, const int max, unsigned int* x) {
+  int* x_int = reinterpret_cast<int*>(x);
+  int range = (max - min + 1);
+  HIP_1D_KERNEL_LOOP(i, N) {
+    x_int[i] = min + static_cast<int>(x[i] % range);
+  }
+}
+} // namespace
+
+template <>
+void RandUniform<float, HIPContext>(
+    const size_t n,
+    const float min,
+    const float max,
+    float* r,
+    HIPContext* context) {
+  HIPRAND_ENFORCE(hiprandGenerateUniform(context->hiprand_generator(), r, n));
+  hipLaunchKernelGGL(
+      (UniformShift<float>),
+      dim3(CAFFE_GET_BLOCKS(n)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      n,
+      min,
+      max,
+      r);
+}
+
+template <>
+void RandUniform<double, HIPContext>(
+    const size_t n,
+    const double min,
+    const double max,
+    double* r,
+    HIPContext* context) {
+  HIPRAND_ENFORCE(
+      hiprandGenerateUniformDouble(context->hiprand_generator(), r, n));
+  hipLaunchKernelGGL(
+      (UniformShift<double>),
+      dim3(CAFFE_GET_BLOCKS(n)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      n,
+      min,
+      max,
+      r);
+}
+
+template <>
+void RandUniform<int, HIPContext>(
+    const size_t n,
+    const int min,
+    const int max,
+    int* r,
+    HIPContext* context) {
+  HIPRAND_ENFORCE(hiprandGenerate(
+      context->hiprand_generator(), reinterpret_cast<unsigned int*>(r), n));
+  hipLaunchKernelGGL(
+      (UniformIntFit),
+      dim3(CAFFE_GET_BLOCKS(n)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      n,
+      min,
+      max,
+      reinterpret_cast<unsigned int*>(r));
+}
+
+template <typename T>
+size_t HandleOddLengthRandGaussian(
+    const size_t n,
+    const T mean,
+    const T std,
+    T* r,
+    HIPContext* context) {
+  if (n % 2 == 1) {
+    std::default_random_engine generator;
+    std::normal_distribution<T> distribution(mean, std);
+    const T random_value = distribution(generator);
+    math::Set<T, HIPContext>(1, random_value, r + (n - 1), context);
+    return n - 1;
+  }
+  return n;
+}
+
+template <>
+void RandGaussian<float, HIPContext>(
+    const size_t n,
+    const float mean,
+    const float std,
+    float* r,
+    HIPContext* context) {
+  // If n is odd, we add a random Gaussian value at the end manually
+  // and generate n-1 random values using curandGenerateNormal.
+  // curandGenerateNormal requires n to be even.
+  const size_t even_n =
+      HandleOddLengthRandGaussian<float>(n, mean, std, r, context);
+  HIPRAND_ENFORCE(hiprandGenerateNormal(
+      context->hiprand_generator(), r, even_n, mean, std));
+}
+
+template <>
+void RandGaussian<double, HIPContext>(
+    const size_t n,
+    const double mean,
+    const double std,
+    double* r,
+    HIPContext* context) {
+  const size_t even_n =
+      HandleOddLengthRandGaussian<double>(n, mean, std, r, context);
+  HIPRAND_ENFORCE(hiprandGenerateNormalDouble(
+      context->hiprand_generator(), r, even_n, mean, std));
+}
+
+template <>
+void Dot<float, HIPContext>(
+    const int n,
+    const float* a,
+    const float* b,
+    float* y,
+    HIPContext* context) {
+  float result;
+  ROCBLAS_ENFORCE(
+      rocblas_sdot(context->rocblas_handle(), n, a, 1, b, 1, &result));
+  context->Copy<float, CPUContext, HIPContext>(1, &result, y);
+}
+
+template <>
+void Dot<float16, HIPContext>(
+    const int n,
+    const float16* a,
+    const float16* b,
+    float16* y,
+    HIPContext* context) {
+  CAFFE_THROW("Unsupported math type");
+#if ROCBLAS_FP16 // rocblas does not support fp16 yet
+  float16 result;
+  // execute with 32-bit math
+  ROCBLAS_CHECK(cublasDotEx(
+      context->rocblas_handle(),
+      n,
+      a,
+      CUDA_R_16F,
+      1,
+      b,
+      CUDA_R_16F,
+      1,
+      &result,
+      CUDA_R_16F,
+      CUDA_R_32F));
+  context->Copy<float16, CPUContext, HIPContext>(1, &result, y);
+#endif
+}
+
+// A previous version of caffe2 used Thrust but it turns out that thrust
+// reduction has an implicit scratch space allocation and deallocation, which
+// may interfere with NCCL and create a deadlock. Hence we are using a custom
+// reduction here.
+#define SUM_KERNEL_NTHREADS 128
+template <typename T>
+__global__ void SumKernel(const int N, const T* X, T* Y, bool square) {
+  const int idx = threadIdx.x;
+  __shared__ float reduction_buffer[SUM_KERNEL_NTHREADS];
+
+  reduction_buffer[idx] = 0;
+
+  // A multilevel reduction.
+  // N -> 128
+  if (!square) {
+    for (int i = idx; i < N; i += SUM_KERNEL_NTHREADS) {
+      reduction_buffer[idx] += convert::To<T, float>(X[i]);
+    }
+  } else {
+    for (int i = idx; i < N; i += SUM_KERNEL_NTHREADS) {
+      float Xi = convert::To<T, float>(X[i]);
+      reduction_buffer[idx] += Xi * Xi;
+    }
+  }
+  __syncthreads();
+  // 128 -> 32
+  if (idx < 32) {
+    reduction_buffer[idx] += reduction_buffer[idx + 32] +
+        reduction_buffer[idx + 64] + reduction_buffer[idx + 96];
+  }
+  __syncthreads();
+  // 32 -> 1
+  if (idx == 0) {
+    float tmp = 0;
+    for (int i = 0; i < 32; ++i) {
+      tmp += reduction_buffer[i];
+    }
+    *Y = convert::To<float, T>(tmp);
+  }
+}
+
+// According to the benchmarks script
+// caffe2/caffe2/experiments/python/device_reduce_sum_bench.py,
+// device reduce is slower for N <= 10000.
+#define DEVICE_REDUCE_SIZE_THRESHOLD 10000
+
+namespace {
+
+template <typename T>
+__global__ void SumConvertKernel(float* sum, T* dest) {
+  *dest = convert::To<float, T>(*sum);
+}
+
+template <typename T, typename IterT>
+void SumGenericIter(
+    const int N,
+    IterT it,
+    T*& dest,
+    HIPContext* context,
+    Tensor<HIPContext>* scratch_ptr) {
+  size_t memRequired = 0;
+  cub::DeviceReduce::Sum(
+      nullptr, memRequired, it, dest, N, context->hip_stream());
+  auto buffer_size =
+      static_cast<TIndex>((memRequired + sizeof(T) - 1) / sizeof(T));
+  if (!dest) {
+    // allocate one more T at the end of scratch for dest
+    scratch_ptr->Resize(std::vector<TIndex>{buffer_size + 1});
+    dest = scratch_ptr->template mutable_data<T>() + buffer_size;
+  } else {
+    scratch_ptr->Resize(std::vector<TIndex>{buffer_size});
+  }
+  cub::DeviceReduce::Sum(
+      static_cast<void*>(scratch_ptr->template mutable_data<T>()),
+      memRequired,
+      it,
+      dest,
+      N,
+      context->hip_stream());
+}
+} // namespace
+
+template <>
+void Sum<float, HIPContext>(
+    const int N,
+    const float* x,
+    float* y,
+    HIPContext* context,
+    Tensor<HIPContext>* scratch_ptr) {
+  if (scratch_ptr && N > DEVICE_REDUCE_SIZE_THRESHOLD) {
+    SumGenericIter<float>(N, x, y, context, scratch_ptr);
+  } else {
+    hipLaunchKernelGGL(
+        (SumKernel),
+        dim3(1),
+        dim3(SUM_KERNEL_NTHREADS),
+        0,
+        context->hip_stream(),
+        N,
+        x,
+        y,
+        false);
+  }
+}
+
+template <>
+void Sum<int32_t, HIPContext>(
+    const int N,
+    const int32_t* x,
+    int32_t* y,
+    HIPContext* context,
+    Tensor<HIPContext>* scratch_ptr) {
+  if (scratch_ptr && N > DEVICE_REDUCE_SIZE_THRESHOLD) {
+    SumGenericIter<int32_t>(N, x, y, context, scratch_ptr);
+  } else {
+    hipLaunchKernelGGL(
+        (SumKernel),
+        dim3(1),
+        dim3(SUM_KERNEL_NTHREADS),
+        0,
+        context->hip_stream(),
+        N,
+        x,
+        y,
+        false);
+  }
+}
+
+namespace {
+template <typename T>
+struct FloatTransform {
+  inline __host__ __device__ float operator()(const T v) const {
+    return convert::To<T, float>(v);
+  }
+};
+} // namespace
+
+#define CAFFE2_MATH_SUM_FUNC(T)                                           \
+  template <>                                                             \
+  void Sum<T, HIPContext>(                                                \
+      const int N,                                                        \
+      const T* x,                                                         \
+      T* y,                                                               \
+      HIPContext* context,                                                \
+      Tensor<HIPContext>* scratch_ptr) {                                  \
+    if (scratch_ptr && N > DEVICE_REDUCE_SIZE_THRESHOLD) {                \
+      FloatTransform<T> transform;                                        \
+      cub::TransformInputIterator<float, FloatTransform<T>, const T*> it( \
+          x, transform);                                                  \
+      float* sum = nullptr;                                               \
+      SumGenericIter<float>(N, it, sum, context, scratch_ptr);            \
+      hipLaunchKernelGGL(                                                 \
+          (SumConvertKernel),                                             \
+          dim3(1),                                                        \
+          dim3(1),                                                        \
+          0,                                                              \
+          context->hip_stream(),                                          \
+          sum,                                                            \
+          y);                                                             \
+    } else {                                                              \
+      hipLaunchKernelGGL(                                                 \
+          (SumKernel),                                                    \
+          dim3(1),                                                        \
+          dim3(SUM_KERNEL_NTHREADS),                                      \
+          0,                                                              \
+          context->hip_stream(),                                          \
+          N,                                                              \
+          x,                                                              \
+          y,                                                              \
+          false);                                                         \
+    }                                                                     \
+  }
+
+CAFFE2_MATH_SUM_FUNC(float16)
+#undef CAFFE2_MATH_SUM_FUNC
+
+namespace {
+template <typename T>
+struct SqrTransform {
+  inline __host__ __device__ T operator()(const T v) const {
+    return v * v;
+  }
+};
+} //  namespace
+
+template <>
+void SumSqr<float, HIPContext>(
+    const int N,
+    const float* x,
+    float* y,
+    HIPContext* context,
+    Tensor<HIPContext>* scratch_ptr) {
+  if (scratch_ptr && N > DEVICE_REDUCE_SIZE_THRESHOLD) {
+    SqrTransform<float> transform;
+    cub::TransformInputIterator<float, SqrTransform<float>, const float*> it(
+        x, transform);
+    SumGenericIter<float>(N, it, y, context, scratch_ptr);
+  } else {
+    hipLaunchKernelGGL(
+        (SumKernel),
+        dim3(1),
+        dim3(SUM_KERNEL_NTHREADS),
+        0,
+        context->hip_stream(),
+        N,
+        x,
+        y,
+        true);
+  }
+}
+
+#define CAFFE2_MATH_SUMSQR_FUNC(T)                                    \
+  template <>                                                         \
+  void SumSqr<T, HIPContext>(                                         \
+      const int N,                                                    \
+      const T* x,                                                     \
+      T* y,                                                           \
+      HIPContext* context,                                            \
+      Tensor<HIPContext>* scratch_ptr) {                              \
+    if (scratch_ptr && N > DEVICE_REDUCE_SIZE_THRESHOLD) {            \
+      FloatTransform<T> float_transform;                              \
+      cub::TransformInputIterator<float, FloatTransform<T>, const T*> \
+          float_it(x, float_transform);                               \
+      SqrTransform<float> sqr_transform;                              \
+      cub::TransformInputIterator<                                    \
+          float,                                                      \
+          SqrTransform<float>,                                        \
+          decltype(float_it)>                                         \
+          it(float_it, sqr_transform);                                \
+      float* sum = nullptr;                                           \
+      SumGenericIter<float>(N, it, sum, context, scratch_ptr);        \
+      hipLaunchKernelGGL(                                             \
+          (SumConvertKernel),                                         \
+          dim3(1),                                                    \
+          dim3(1),                                                    \
+          0,                                                          \
+          context->hip_stream(),                                      \
+          sum,                                                        \
+          y);                                                         \
+    } else {                                                          \
+      hipLaunchKernelGGL(                                             \
+          (SumKernel),                                                \
+          dim3(1),                                                    \
+          dim3(SUM_KERNEL_NTHREADS),                                  \
+          0,                                                          \
+          context->hip_stream(),                                      \
+          N,                                                          \
+          x,                                                          \
+          y,                                                          \
+          true);                                                      \
+    }                                                                 \
+  }
+
+CAFFE2_MATH_SUMSQR_FUNC(float16)
+#undef CAFFE2_MATH_SUMSQR_FUNC
+#undef DEVICE_REDUCE_SIZE_THRESHOLD
+
+namespace {
+template <typename T>
+__global__ void
+SelectKernel(const int N, const int D, const T* x, const int* idx, T* y) {
+  HIP_1D_KERNEL_LOOP(i, N) {
+    y[i] = x[i * D + idx[i]];
+  }
+}
+} // namespace
+
+template <>
+void Select<float, HIPContext>(
+    const int N,
+    const int D,
+    const float* x,
+    const int* idx,
+    float* y,
+    HIPContext* context) {
+  hipLaunchKernelGGL(
+      (SelectKernel<float>),
+      dim3(CAFFE_GET_BLOCKS(N)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      N,
+      D,
+      x,
+      idx,
+      y);
+}
+
+template <>
+void Select<float16, HIPContext>(
+    const int N,
+    const int D,
+    const float16* x,
+    const int* idx,
+    float16* y,
+    HIPContext* context) {
+  hipLaunchKernelGGL(
+      (SelectKernel<float16>),
+      dim3(CAFFE_GET_BLOCKS(N)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      N,
+      D,
+      x,
+      idx,
+      y);
+}
+
+namespace {
+template <typename T>
+__global__ void ScaleKernel(const int n, const float alpha, const T* x, T* y) {
+  HIP_1D_KERNEL_LOOP(i, n) {
+    // y[i] = convert::To<float,T>(convert::To<T, float>(x[i]) * alpha);
+    y[i] = convert::Get<T>(convert::Get<float>(x[i]) * alpha);
+  }
+}
+
+template <typename T>
+__global__ void
+ScaleKernelDeviceAlpha(const int n, const float* alpha, const T* x, T* y) {
+  HIP_1D_KERNEL_LOOP(i, n) {
+    y[i] = x[i] * (*alpha);
+  }
+}
+
+template <typename T>
+__global__ void PowKernel(const int n, const T* x, const T exponent, T* y) {
+  HIP_1D_KERNEL_LOOP(i, n) {
+    y[i] = powf(x[i], exponent);
+  }
+}
+
+// fp16 specialization
+template <>
+__global__ void ScaleKernelDeviceAlpha(
+    const int n,
+    const float* alpha,
+    const float16* x,
+    float16* y) {
+  HIP_1D_KERNEL_LOOP(i, n) {
+    y[i] = convert::To<float, float16>(
+        convert::To<float16, float>(x[i]) * (*alpha));
+  }
+}
+
+} // namespace
+
+template <>
+void Powx<float, HIPContext>(
+    const int N,
+    const float* a,
+    const float b,
+    float* y,
+    HIPContext* context) {
+  hipLaunchKernelGGL(
+      (PowKernel),
+      dim3(CAFFE_GET_BLOCKS(N)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      N,
+      a,
+      b,
+      y);
+}
+
+template <>
+void Scale<float, HIPContext>(
+    const int n,
+    const float alpha,
+    const float* x,
+    float* y,
+    HIPContext* context) {
+  hipLaunchKernelGGL(
+      (ScaleKernel<float>),
+      dim3(CAFFE_GET_BLOCKS(n)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      n,
+      alpha,
+      x,
+      y);
+}
+
+template <>
+void Scale<float16, HIPContext>(
+    const int n,
+    const float alpha,
+    const float16* x,
+    float16* y,
+    HIPContext* context) {
+  hipLaunchKernelGGL(
+      (ScaleKernel<float16>),
+      dim3(CAFFE_GET_BLOCKS(n)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      n,
+      alpha,
+      x,
+      y);
+}
+
+template <>
+void Scale<float, HIPContext>(
+    const int n,
+    const float* alpha,
+    const float* x,
+    float* y,
+    HIPContext* context) {
+  hipLaunchKernelGGL(
+      (ScaleKernelDeviceAlpha<float>),
+      dim3(CAFFE_GET_BLOCKS(n)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      n,
+      alpha,
+      x,
+      y);
+}
+
+template <>
+void Scale<float16, HIPContext>(
+    const int n,
+    const float* alpha,
+    const float16* x,
+    float16* y,
+    HIPContext* context) {
+  hipLaunchKernelGGL(
+      (ScaleKernelDeviceAlpha<float16>),
+      dim3(CAFFE_GET_BLOCKS(n)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      n,
+      alpha,
+      x,
+      y);
+}
+
+template <>
+void Axpy<float, HIPContext>(
+    const int N,
+    const float alpha,
+    const float* X,
+    float* Y,
+    HIPContext* context) {
+  ROCBLAS_ENFORCE(
+      rocblas_saxpy(context->rocblas_handle(), N, &alpha, X, 1, Y, 1));
+}
+
+template <>
+void Axpy<double, HIPContext>(
+    const int N,
+    const float alpha,
+    const double* X,
+    double* Y,
+    HIPContext* context) {
+  double alpha_d{alpha};
+  ROCBLAS_ENFORCE(
+      rocblas_daxpy(context->rocblas_handle(), N, &alpha_d, X, 1, Y, 1));
+}
+
+template <>
+void Axpy<float16, HIPContext>(
+    const int N,
+    const float alpha,
+    const float16* X,
+    float16* Y,
+    HIPContext* context) {
+  CAFFE_THROW("Unsupported math type");
+#if ROCBLAS_FP16
+  ROCBLAS_CHECK(cublasAxpyEx(
+      context->rocblas_handle(),
+      N,
+      &alpha,
+      CUDA_R_16F,
+      X,
+      CUDA_R_16F,
+      1,
+      Y,
+      CUDA_R_16F,
+      1,
+      CUDA_R_32F));
+#endif
+}
+
+namespace {
+template <typename T>
+__global__ void AxpyKernel(const int n, const float* a, const T* x, T* y) {
+  HIP_1D_KERNEL_LOOP(index, n) {
+    y[index] = convert::Get<T>(
+        convert::Get<float>(x[index]) * (*a) + convert::Get<float>(y[index]));
+  }
+}
+} // namespace
+
+template <>
+void Axpy<float, HIPContext>(
+    const int n,
+    const float* alpha,
+    const float* X,
+    float* Y,
+    HIPContext* context) {
+  hipLaunchKernelGGL(
+      (AxpyKernel<float>),
+      dim3(CAFFE_GET_BLOCKS(n)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      n,
+      alpha,
+      X,
+      Y);
+}
+
+template <>
+void Axpy<float16, HIPContext>(
+    const int n,
+    const float* alpha,
+    const float16* X,
+    float16* Y,
+    HIPContext* context) {
+  hipLaunchKernelGGL(
+      (AxpyKernel<float16>),
+      dim3(CAFFE_GET_BLOCKS(n)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      n,
+      alpha,
+      X,
+      Y);
+}
+
+namespace {
+template <typename T>
+__global__ void
+AxpbyKernel(const int n, const T a, const T* x, const T b, T* y) {
+  HIP_1D_KERNEL_LOOP(index, n) {
+    y[index] = x[index] * a + y[index] * b;
+  }
+}
+} // namespace
+
+template <>
+void Axpby<float, HIPContext>(
+    const int n,
+    const float a,
+    const float* x,
+    const float b,
+    float* y,
+    HIPContext* context) {
+  hipLaunchKernelGGL(
+      (AxpbyKernel<float>),
+      dim3(CAFFE_GET_BLOCKS(n)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      n,
+      a,
+      x,
+      b,
+      y);
+}
+
+namespace {
+
+template <typename T>
+__global__ void Im2ColNCHWHIPKernel(
+    const int n,
+    const int input_h,
+    const int input_w,
+    const int kernel_h,
+    const int kernel_w,
+    const int dilation_h,
+    const int dilation_w,
+    const int pad_t,
+    const int pad_l,
+    const int stride_h,
+    const int stride_w,
+    const int output_h,
+    const int output_w,
+    const T* img_data,
+    T* col_data) {
+  HIP_1D_KERNEL_LOOP(index, n) {
+    const int w_out = index % output_w;
+    const int h_index = index / output_w;
+    const int h_out = h_index % output_h;
+    const int channel_in = h_index / output_h;
+    const int channel_out = channel_in * kernel_h * kernel_w;
+    const int h_in = h_out * stride_h - pad_t;
+    const int w_in = w_out * stride_w - pad_l;
+    const int output_size = output_h * output_w;
+    T* col_data_ptr =
+        col_data + (channel_out * output_h + h_out) * output_w + w_out;
+    const T* img_data_ptr =
+        img_data + (channel_in * input_h + h_in) * input_w + w_in;
+    int dh = 0;
+    for (int i = 0; i < kernel_h; ++i) {
+      int dw = 0;
+      for (int j = 0; j < kernel_w; ++j) {
+        const int h = h_in + dh;
+        const int w = w_in + dw;
+        *col_data_ptr = (h >= 0 && w >= 0 && h < input_h && w < input_w)
+            ? __ldg(img_data_ptr + dh * input_w + dw)
+            : 0;
+        col_data_ptr += output_size;
+        dw += dilation_w;
+      }
+      dh += dilation_h;
+    }
+  }
+}
+
+template <typename T>
+__global__ void Im2ColNHWCHIPKernel(
+    const int n,
+    const int input_h,
+    const int input_w,
+    const int kernel_h,
+    const int kernel_w,
+    const int dilation_h,
+    const int dilation_w,
+    const int pad_t,
+    const int pad_l,
+    const int stride_h,
+    const int stride_w,
+    const int output_w,
+    const int channels,
+    const T* img_data,
+    T* col_data) {
+  HIP_1D_KERNEL_LOOP(index, n) {
+    const int channel_in = index % channels;
+    const int w_out = index / channels % output_w;
+    const int h_out = index / channels / output_w;
+    const int h_in = h_out * stride_h - pad_t;
+    const int w_in = w_out * stride_w - pad_l;
+    T* col_data_ptr = col_data +
+        (h_out * output_w + w_out) * channels * kernel_h * kernel_w +
+        channel_in;
+    int dh = 0;
+    for (int i = 0; i < kernel_h; ++i) {
+      int dw = 0;
+      for (int j = 0; j < kernel_w; ++j) {
+        const int h = h_in + dh;
+        const int w = w_in + dw;
+        *col_data_ptr = (h >= 0 && w >= 0 && h < input_h && w < input_w)
+            ? __ldg(img_data + (h * input_w + w) * channels + channel_in)
+            : 0;
+        col_data_ptr += channels;
+        dw += dilation_w;
+      }
+      dh += dilation_h;
+    }
+  }
+}
+
+template <typename T>
+__global__ void Col2ImNCHWHIPKernel(
+    const int n,
+    const int input_h,
+    const int input_w,
+    const int patch_h,
+    const int patch_w,
+    const int dilation_h,
+    const int dilation_w,
+    const int pad_t,
+    const int pad_l,
+    const int stride_h,
+    const int stride_w,
+    const int output_h,
+    const int output_w,
+    const T* col_data,
+    T* img_data) {
+  const int dpatch_h = dilation_h * (patch_h - 1) + 1;
+  const int dpatch_w = dilation_w * (patch_w - 1) + 1;
+
+  HIP_1D_KERNEL_LOOP(index, n) {
+    T val = 0;
+    const int w = index % input_w + pad_l;
+    const int h = index / input_w % input_h + pad_t;
+    const int c = index / (input_h * input_w);
+
+    // compute the start and end of the output
+    const int w_col_start = (w < dpatch_w) ? 0 : (w - dpatch_w) / stride_w + 1;
+    const int w_col_end = min(w / stride_w + 1, output_w);
+    const int h_col_start = (h < dpatch_h) ? 0 : (h - dpatch_h) / stride_h + 1;
+    const int h_col_end = min(h / stride_h + 1, output_h);
+
+    for (int h_col = h_col_start; h_col < h_col_end; ++h_col) {
+      for (int w_col = w_col_start; w_col < w_col_end; ++w_col) {
+        int h_k = (h - h_col * stride_h);
+        int w_k = (w - w_col * stride_w);
+        if (h_k % dilation_h == 0 && w_k % dilation_w == 0) {
+          h_k /= dilation_h;
+          w_k /= dilation_w;
+          const int col_data_index =
+              (((c * patch_h + h_k) * patch_w + w_k) * output_h + h_col) *
+                  output_w +
+              w_col;
+          val += __ldg(col_data + col_data_index);
+        }
+      }
+    }
+    img_data[index] = val;
+  }
+}
+
+template <typename T>
+__global__ void Col2ImNHWCHIPKernel(
+    const int n,
+    const int input_w,
+    const int channels,
+    const int patch_h,
+    const int patch_w,
+    const int dilation_h,
+    const int dilation_w,
+    const int pad_t,
+    const int pad_l,
+    const int stride_h,
+    const int stride_w,
+    const int output_h,
+    const int output_w,
+    const T* col_data,
+    T* img_data) {
+  const int dpatch_h = dilation_h * (patch_h - 1) + 1;
+  const int dpatch_w = dilation_w * (patch_w - 1) + 1;
+
+  HIP_1D_KERNEL_LOOP(index, n) {
+    T val = 0;
+    const int c = index % channels;
+    const int w = index / channels % input_w + pad_l;
+    const int h = index / channels / input_w + pad_t;
+    // compute the start and end of the output
+    const int w_col_start = (w < dpatch_w) ? 0 : (w - dpatch_w) / stride_w + 1;
+    const int w_col_end = min(w / stride_w + 1, output_w);
+    const int h_col_start = (h < dpatch_h) ? 0 : (h - dpatch_h) / stride_h + 1;
+    const int h_col_end = min(h / stride_h + 1, output_h);
+    const int channels_col = patch_h * patch_w * channels;
+
+    for (int h_col = h_col_start; h_col < h_col_end; ++h_col) {
+      for (int w_col = w_col_start; w_col < w_col_end; ++w_col) {
+        int h_k = h - h_col * stride_h;
+        int w_k = w - w_col * stride_w;
+        if (h_k % dilation_h == 0 && w_k % dilation_w == 0) {
+          h_k /= dilation_h;
+          w_k /= dilation_w;
+          const int c_col = (h_k * patch_w + w_k) * channels + c;
+          val += __ldg(
+              col_data + (h_col * output_w + w_col) * channels_col + c_col);
+        }
+      }
+    }
+    img_data[index] = val;
+  }
+}
+
+template <typename T, int N, bool kCol2Im>
+__global__ void Im2ColNdNCHWHIPKernel(
+    const int outer_size,
+    const int inner_size,
+    const int kernel_size,
+    SimpleArray<int, N + 1> img_shape,
+    SimpleArray<int, N + 1> col_shape,
+    SimpleArray<int, N> kernel_shape,
+    SimpleArray<int, N> stride,
+    SimpleArray<int, N> dilation,
+    SimpleArray<int, N> pad,
+    const T* X_data,
+    T* Y_data) {
+  int d_offset[N];
+  int d_iter[N];
+  for (int i = blockIdx.x; i < outer_size; i += gridDim.x) {
+    int offset_i = i;
+#pragma unroll
+    for (int d_i = N - 1; d_i >= 0; --d_i) {
+      d_offset[d_i] = offset_i % kernel_shape.data[d_i];
+      offset_i /= kernel_shape.data[d_i];
+    }
+    for (int j = threadIdx.x; j < inner_size; j += blockDim.x) {
+      int offset_j = j;
+#pragma unroll
+      for (int d_i = N - 1; d_i >= 0; --d_i) {
+        d_iter[d_i] = offset_j % col_shape.data[d_i + 1];
+        offset_j /= col_shape.data[d_i + 1];
+      }
+      const int col_index = i * inner_size + j;
+      int img_index = i / kernel_size;
+      bool is_padding = false;
+#pragma unroll
+      for (int d_i = 0; d_i < N; ++d_i) {
+        const int d_img = d_iter[d_i] * stride.data[d_i] - pad.data[d_i] +
+            d_offset[d_i] * dilation.data[d_i];
+        is_padding |= d_img < 0 || d_img >= img_shape.data[d_i + 1];
+        img_index = img_index * img_shape.data[d_i + 1] + d_img;
+      }
+      if (!kCol2Im) {
+        Y_data[col_index] = is_padding ? 0 : __ldg(X_data + img_index);
+      } else if (!is_padding) {
+        atomicAdd(Y_data + img_index, __ldg(X_data + col_index));
+      }
+    }
+  }
+}
+
+template <typename T, int N>
+void Im2ColNdNCHWHIPImpl(
+    const int img_size,
+    const int col_size,
+    const int* img_shape,
+    const int* col_shape,
+    const int* kernel_shape,
+    const int* stride,
+    const int* dilation,
+    const int* pad,
+    const float* img_data,
+    float* col_data,
+    HIPContext* context) {
+  const int outer_size = col_shape[0];
+  const int inner_size = col_size / outer_size;
+  const int kernel_size = std::accumulate(
+      kernel_shape, kernel_shape + N, 1, std::multiplies<int>());
+  SimpleArray<int, N + 1> img_shape_array;
+  SimpleArray<int, N + 1> col_shape_array;
+  SimpleArray<int, N> kernel_shape_array;
+  SimpleArray<int, N> stride_array;
+  SimpleArray<int, N> dilation_array;
+  SimpleArray<int, N> pad_array;
+  std::memcpy(img_shape_array.data, img_shape, (N + 1) * sizeof(int));
+  std::memcpy(col_shape_array.data, col_shape, (N + 1) * sizeof(int));
+  std::memcpy(kernel_shape_array.data, kernel_shape, N * sizeof(int));
+  std::memcpy(stride_array.data, stride, N * sizeof(int));
+  std::memcpy(dilation_array.data, dilation, N * sizeof(int));
+  std::memcpy(pad_array.data, pad, N * sizeof(int));
+  hipLaunchKernelGGL(
+      (Im2ColNdNCHWHIPKernel<T, N, false>),
+      dim3(std::min(outer_size, CAFFE_MAXIMUM_NUM_BLOCKS)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      outer_size,
+      inner_size,
+      kernel_size,
+      img_shape_array,
+      col_shape_array,
+      kernel_shape_array,
+      stride_array,
+      dilation_array,
+      pad_array,
+      img_data,
+      col_data);
+}
+
+template <typename T, int N>
+void Col2ImNdNCHWHIPImpl(
+    const int img_size,
+    const int col_size,
+    const int* img_shape,
+    const int* col_shape,
+    const int* kernel_shape,
+    const int* stride,
+    const int* dilation,
+    const int* pad,
+    const float* col_data,
+    float* img_data,
+    HIPContext* context) {
+  const int outer_size = col_shape[0];
+  const int inner_size = col_size / outer_size;
+  const int kernel_size = std::accumulate(
+      kernel_shape, kernel_shape + N, 1, std::multiplies<int>());
+  SimpleArray<int, N + 1> img_shape_array;
+  SimpleArray<int, N + 1> col_shape_array;
+  SimpleArray<int, N> kernel_shape_array;
+  SimpleArray<int, N> stride_array;
+  SimpleArray<int, N> dilation_array;
+  SimpleArray<int, N> pad_array;
+  std::memcpy(img_shape_array.data, img_shape, (N + 1) * sizeof(int));
+  std::memcpy(col_shape_array.data, col_shape, (N + 1) * sizeof(int));
+  std::memcpy(kernel_shape_array.data, kernel_shape, N * sizeof(int));
+  std::memcpy(stride_array.data, stride, N * sizeof(int));
+  std::memcpy(dilation_array.data, dilation, N * sizeof(int));
+  std::memcpy(pad_array.data, pad, N * sizeof(int));
+  Set<T, HIPContext>(img_size, 0, img_data, context);
+  hipLaunchKernelGGL(
+      (Im2ColNdNCHWHIPKernel<T, N, true>),
+      dim3(std::min(outer_size, CAFFE_MAXIMUM_NUM_BLOCKS)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      outer_size,
+      inner_size,
+      kernel_size,
+      img_shape_array,
+      col_shape_array,
+      kernel_shape_array,
+      stride_array,
+      dilation_array,
+      pad_array,
+      col_data,
+      img_data);
+}
+
+} // namespace
+
+template <>
+void Im2Col<float, HIPContext, StorageOrder::NCHW>(
+    const int channels,
+    const int height,
+    const int width,
+    const int kernel_h,
+    const int kernel_w,
+    const int dilation_h,
+    const int dilation_w,
+    const int pad_t,
+    const int pad_l,
+    const int pad_b,
+    const int pad_r,
+    const int stride_h,
+    const int stride_w,
+    const float* img_data,
+    float* col_data,
+    HIPContext* context) {
+  const int dkernel_h = dilation_h * (kernel_h - 1) + 1;
+  const int dkernel_w = dilation_w * (kernel_w - 1) + 1;
+  const int output_h = (height + pad_t + pad_b - dkernel_h) / stride_h + 1;
+  const int output_w = (width + pad_l + pad_r - dkernel_w) / stride_w + 1;
+  const int num_kernels = channels * output_h * output_w;
+  hipLaunchKernelGGL(
+      (Im2ColNCHWHIPKernel<float>),
+      dim3(CAFFE_GET_BLOCKS(num_kernels)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      num_kernels,
+      height,
+      width,
+      kernel_h,
+      kernel_w,
+      dilation_h,
+      dilation_w,
+      pad_t,
+      pad_l,
+      stride_h,
+      stride_w,
+      output_h,
+      output_w,
+      img_data,
+      col_data);
+}
+
+template <>
+void Im2Col<float, HIPContext, StorageOrder::NHWC>(
+    const int channels,
+    const int height,
+    const int width,
+    const int kernel_h,
+    const int kernel_w,
+    const int dilation_h,
+    const int dilation_w,
+    const int pad_t,
+    const int pad_l,
+    const int pad_b,
+    const int pad_r,
+    const int stride_h,
+    const int stride_w,
+    const float* img_data,
+    float* col_data,
+    HIPContext* context) {
+  const int dkernel_h = dilation_h * (kernel_h - 1) + 1;
+  const int dkernel_w = dilation_w * (kernel_w - 1) + 1;
+  const int output_h = (height + pad_t + pad_b - dkernel_h) / stride_h + 1;
+  const int output_w = (width + pad_l + pad_r - dkernel_w) / stride_w + 1;
+  const int num_kernels = output_h * output_w * channels;
+  hipLaunchKernelGGL(
+      (Im2ColNHWCHIPKernel<float>),
+      dim3(CAFFE_GET_BLOCKS(num_kernels)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      num_kernels,
+      height,
+      width,
+      kernel_h,
+      kernel_w,
+      dilation_h,
+      dilation_w,
+      pad_t,
+      pad_l,
+      stride_h,
+      stride_w,
+      output_w,
+      channels,
+      img_data,
+      col_data);
+}
+
+template <>
+void Col2Im<float, HIPContext, StorageOrder::NCHW>(
+    const int channels,
+    const int height,
+    const int width,
+    const int kernel_h,
+    const int kernel_w,
+    const int dilation_h,
+    const int dilation_w,
+    const int pad_t,
+    const int pad_l,
+    const int pad_b,
+    const int pad_r,
+    const int stride_h,
+    const int stride_w,
+    const float* col_data,
+    float* img_data,
+    HIPContext* context) {
+  const int dkernel_h = dilation_h * (kernel_h - 1) + 1;
+  const int dkernel_w = dilation_w * (kernel_w - 1) + 1;
+  const int output_h = (height + pad_t + pad_b - dkernel_h) / stride_h + 1;
+  const int output_w = (width + pad_l + pad_r - dkernel_w) / stride_w + 1;
+  const int num_kernels = channels * height * width;
+  hipLaunchKernelGGL(
+      (Col2ImNCHWHIPKernel<float>),
+      dim3(CAFFE_GET_BLOCKS(num_kernels)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      num_kernels,
+      height,
+      width,
+      kernel_h,
+      kernel_w,
+      dilation_h,
+      dilation_w,
+      pad_t,
+      pad_l,
+      stride_h,
+      stride_w,
+      output_h,
+      output_w,
+      col_data,
+      img_data);
+}
+
+template <>
+void Col2Im<float, HIPContext, StorageOrder::NHWC>(
+    const int channels,
+    const int height,
+    const int width,
+    const int kernel_h,
+    const int kernel_w,
+    const int dilation_h,
+    const int dilation_w,
+    const int pad_t,
+    const int pad_l,
+    const int pad_b,
+    const int pad_r,
+    const int stride_h,
+    const int stride_w,
+    const float* col_data,
+    float* img_data,
+    HIPContext* context) {
+  const int dkernel_h = dilation_h * (kernel_h - 1) + 1;
+  const int dkernel_w = dilation_w * (kernel_w - 1) + 1;
+  const int output_h = (height + pad_t + pad_b - dkernel_h) / stride_h + 1;
+  const int output_w = (width + pad_l + pad_r - dkernel_w) / stride_w + 1;
+  const int num_kernels = height * width * channels;
+  hipLaunchKernelGGL(
+      (Col2ImNHWCHIPKernel<float>),
+      dim3(CAFFE_GET_BLOCKS(num_kernels)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      num_kernels,
+      width,
+      channels,
+      kernel_h,
+      kernel_w,
+      dilation_h,
+      dilation_w,
+      pad_t,
+      pad_l,
+      stride_h,
+      stride_w,
+      output_h,
+      output_w,
+      col_data,
+      img_data);
+}
+
+template <>
+void Im2ColNd<float, HIPContext, StorageOrder::NCHW>(
+    const int N,
+    const int img_size,
+    const int col_size,
+    const int* img_shape,
+    const int* col_shape,
+    const int* kernel_shape,
+    const int* stride,
+    const int* dilation,
+    const int* pad,
+    const float* img_data,
+    float* col_data,
+    HIPContext* context) {
+  DISPATCH_FUNCTION_BY_VALUE_WITH_TYPE_1(
+      N,
+      Im2ColNdNCHWHIPImpl,
+      float,
+      img_size,
+      col_size,
+      img_shape,
+      col_shape,
+      kernel_shape,
+      stride,
+      dilation,
+      pad,
+      img_data,
+      col_data,
+      context);
+}
+
+template <>
+void Col2ImNd<float, HIPContext, StorageOrder::NCHW>(
+    const int N,
+    const int img_size,
+    const int col_size,
+    const int* img_shape,
+    const int* col_shape,
+    const int* kernel_shape,
+    const int* stride,
+    const int* dilation,
+    const int* pad,
+    const float* col_data,
+    float* img_data,
+    HIPContext* context) {
+  DISPATCH_FUNCTION_BY_VALUE_WITH_TYPE_1(
+      N,
+      Col2ImNdNCHWHIPImpl,
+      float,
+      img_size,
+      col_size,
+      img_shape,
+      col_shape,
+      kernel_shape,
+      stride,
+      dilation,
+      pad,
+      col_data,
+      img_data,
+      context);
+}
+
+template <>
+void CopyMatrix<HIPContext>(
+    const size_t itemsize,
+    const int M,
+    const int N,
+    const void* A,
+    const int lda,
+    void* B,
+    const int ldb,
+    HIPContext* context,
+    TypeMeta::TypedCopy copy) {
+  CAFFE_ENFORCE(!copy, "Copy constructor is not supported in HIP context");
+  hipMemcpy2DAsync(
+      B,
+      ldb * itemsize,
+      A,
+      lda * itemsize,
+      N * itemsize,
+      M,
+      hipMemcpyDeviceToDevice,
+      context->hip_stream());
+}
+
+template <>
+void CopyVector<float, HIPContext>(
+    const int N,
+    const float* src,
+    float* dst,
+    HIPContext* context) {
+  if (src != dst && N > 0) {
+    hipMemcpyAsync(
+        dst,
+        src,
+        sizeof(float) * N,
+        hipMemcpyDeviceToDevice,
+        context->hip_stream());
+  }
+}
+
+namespace {
+
+template <typename T>
+using BlockReduce = cub::BlockReduce<T, CAFFE_HIP_NUM_THREADS>;
+
+template <typename T, class Reducer>
+__global__ void RowwiseReduceKernel(
+    const int rows,
+    const int cols,
+    const Reducer reducer,
+    const T init,
+    const T* X,
+    T* Y) {
+  __shared__ typename BlockReduce<T>::TempStorage temp_storage;
+  for (int i = blockIdx.x; i < rows; i += gridDim.x) {
+    T val = init;
+    for (int j = threadIdx.x; j < cols; j += blockDim.x) {
+      val = reducer(X[i * cols + j], val);
+    }
+    val = BlockReduce<T>(temp_storage).Reduce(val, reducer);
+    if (threadIdx.x == 0) {
+      Y[i] = val;
+    }
+    __syncthreads();
+  }
+}
+
+template <typename T, class Reducer>
+__global__ void ColwiseReduceKernel(
+    const int rows,
+    const int cols,
+    const Reducer reducer,
+    const T init,
+    const T* X,
+    T* Y) {
+  __shared__ typename BlockReduce<T>::TempStorage temp_storage;
+  for (int i = blockIdx.x; i < cols; i += gridDim.x) {
+    T val = init;
+    for (int j = threadIdx.x; j < rows; j += blockDim.x) {
+      val = reducer(X[j * cols + i], val);
+    }
+    val = BlockReduce<T>(temp_storage).Reduce(val, reducer);
+    if (threadIdx.x == 0) {
+      Y[i] = val;
+    }
+    __syncthreads();
+  }
+}
+
+} // namespace
+
+#define CAFFE2_SPECIALIZED_HIP_ROWWISE_MAX(T)                            \
+  template <>                                                            \
+  void RowwiseMax<T, HIPContext>(                                        \
+      const int N, const int D, const T* x, T* y, HIPContext* context) { \
+    hipLaunchKernelGGL(                                                  \
+        (RowwiseReduceKernel),                                           \
+        std::min(N, CAFFE_MAXIMUM_NUM_BLOCKS),                           \
+        CAFFE_HIP_NUM_THREADS,                                           \
+        0,                                                               \
+        context->hip_stream(),                                           \
+        N,                                                               \
+        D,                                                               \
+        cub::Max(),                                                      \
+        std::numeric_limits<T>::lowest(),                                \
+        x,                                                               \
+        y);                                                              \
+  }
+CAFFE2_SPECIALIZED_HIP_ROWWISE_MAX(float)
+#undef CAFFE2_SPECIALIZED_HIP_ROWWISE_MAX
+
+#define CAFFE2_SPECIALIZED_HIP_COLWISE_MAX(T)                            \
+  template <>                                                            \
+  void ColwiseMax<T, HIPContext>(                                        \
+      const int N, const int D, const T* x, T* y, HIPContext* context) { \
+    hipLaunchKernelGGL(                                                  \
+        (ColwiseReduceKernel),                                           \
+        std::min(D, CAFFE_MAXIMUM_NUM_BLOCKS),                           \
+        CAFFE_HIP_NUM_THREADS,                                           \
+        0,                                                               \
+        context->hip_stream(),                                           \
+        N,                                                               \
+        D,                                                               \
+        cub::Max(),                                                      \
+        std::numeric_limits<T>::lowest(),                                \
+        x,                                                               \
+        y);                                                              \
+  }
+CAFFE2_SPECIALIZED_HIP_COLWISE_MAX(float)
+#undef CAFFE2_SPECIALIZED_HIP_COLWISE_MAX
+
+namespace {
+__global__ void
+maximum_kernel(const int N, const float alpha, const float* x, float* y) {
+  HIP_1D_KERNEL_LOOP(i, N) {
+    y[i] = fmaxf(x[i], alpha);
+  }
+}
+} // namespace
+
+template <>
+void Maximum(
+    const int N,
+    const float alpha,
+    const float* x,
+    float* y,
+    HIPContext* context) {
+  hipLaunchKernelGGL(
+      (maximum_kernel),
+      dim3(std::min(N, CAFFE_MAXIMUM_NUM_BLOCKS)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      N,
+      alpha,
+      x,
+      y);
+}
+
+namespace {
+
+template <typename T, class Reducer, int D>
+__global__ void ReduceTensorHIPKernel(
+    const int outer_size,
+    const int inner_size,
+    SimpleArray<int, D> X_strides,
+    SimpleArray<int, D> Y_dims,
+    const Reducer reducer,
+    const T init,
+    const T* X,
+    T* Y) {
+  __shared__ typename BlockReduce<T>::TempStorage temp_storage;
+  for (int i = blockIdx.x; i < outer_size; i += gridDim.x) {
+    T val = init;
+    for (int j = threadIdx.x; j < inner_size; j += blockDim.x) {
+      int X_index = 0;
+      int Y_index = i * inner_size + j;
+#pragma unroll
+      for (int d = D - 1; d >= 0; --d) {
+        X_index += (Y_index % Y_dims.data[d]) * X_strides.data[d];
+        Y_index /= Y_dims.data[d];
+      }
+      val = reducer(val, __ldg(X + X_index));
+    }
+    val = BlockReduce<T>(temp_storage).Reduce(val, reducer);
+    if (threadIdx.x == 0) {
+      Y[i] = val;
+    }
+    __syncthreads();
+  }
+}
+
+template <typename T, class Reducer, int D>
+void ReduceTensorHIPImpl(
+    const int outer_size,
+    const int inner_size,
+    const int* dims,
+    const int* axes,
+    const Reducer& reducer,
+    const T& init,
+    const T* X,
+    T* Y,
+    HIPContext* context) {
+  SimpleArray<int, D> X_strides;
+  SimpleArray<int, D> Y_dims;
+  utils::ComputeTransposedStrides(D, dims, axes, X_strides.data);
+  for (int i = 0; i < D; ++i) {
+    Y_dims.data[i] = dims[axes[i]];
+  }
+  hipLaunchKernelGGL(
+      (ReduceTensorHIPKernel<T, Reducer, D>),
+      dim3(std::min(outer_size, CAFFE_MAXIMUM_NUM_BLOCKS)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      outer_size,
+      inner_size,
+      X_strides,
+      Y_dims,
+      reducer,
+      init,
+      X,
+      Y);
+}
+
+template <typename T, class Reducer>
+void ReduceTensorHIP(
+    const int num_dims,
+    const int* dims,
+    const int num_axes,
+    const int* axes,
+    const Reducer& reducer,
+    const T& init,
+    const T* X,
+    T* Y,
+    HIPContext* context) {
+  CAFFE_ENFORCE_LE(num_axes, num_dims);
+  std::vector<int> transpose_axes(num_dims);
+  utils::ComputeTransposeAxesForReduceOp(
+      num_dims, num_axes, axes, transpose_axes.data());
+  const int pivot = num_dims - num_axes;
+  int outer_size = 1;
+  for (int i = 0; i < pivot; ++i) {
+    outer_size *= dims[transpose_axes[i]];
+  }
+  int inner_size = 1;
+  for (int i = pivot; i < num_dims; ++i) {
+    inner_size *= dims[transpose_axes[i]];
+  }
+  if (transpose_axes[pivot] == pivot) {
+    hipLaunchKernelGGL(
+        (RowwiseReduceKernel<T>),
+        dim3(std::min(outer_size, CAFFE_MAXIMUM_NUM_BLOCKS)),
+        dim3(CAFFE_HIP_NUM_THREADS),
+        0,
+        context->hip_stream(),
+        outer_size,
+        inner_size,
+        reducer,
+        init,
+        X,
+        Y);
+    return;
+  }
+  DISPATCH_FUNCTION_BY_VALUE_WITH_TYPE_2(
+      num_dims,
+      ReduceTensorHIPImpl,
+      T,
+      Reducer,
+      outer_size,
+      inner_size,
+      dims,
+      transpose_axes.data(),
+      reducer,
+      init,
+      X,
+      Y,
+      context);
+}
+
+template <typename T>
+void ReduceMeanHIPImpl(
+    const int num_dims,
+    const int* dims,
+    const int num_axes,
+    const int* axes,
+    const T* X,
+    T* Y,
+    HIPContext* context) {
+  ReduceTensorHIP(
+      num_dims, dims, num_axes, axes, cub::Sum(), T(0), X, Y, context);
+  const int X_size =
+      std::accumulate(dims, dims + num_dims, 1, std::multiplies<int>());
+  int scale = 1;
+  for (int i = 0; i < num_axes; ++i) {
+    scale *= dims[axes[i]];
+  }
+  const int Y_size = X_size / scale;
+  Scale<T, HIPContext>(Y_size, 1.0f / static_cast<float>(scale), Y, Y, context);
+}
+
+} // namespace
+
+#define CAFFE2_SPECIALIZED_HIP_REDUCE_MIN(T) \
+  template <>                                \
+  void ReduceMin<T, HIPContext>(             \
+      const int num_dims,                    \
+      const int* dims,                       \
+      const int num_axes,                    \
+      const int* axes,                       \
+      const T* X,                            \
+      T* Y,                                  \
+      HIPContext* context) {                 \
+    ReduceTensorHIP(                         \
+        num_dims,                            \
+        dims,                                \
+        num_axes,                            \
+        axes,                                \
+        cub::Min(),                          \
+        std::numeric_limits<T>::max(),       \
+        X,                                   \
+        Y,                                   \
+        context);                            \
+  }
+CAFFE2_SPECIALIZED_HIP_REDUCE_MIN(std::int32_t)
+CAFFE2_SPECIALIZED_HIP_REDUCE_MIN(std::int64_t)
+CAFFE2_SPECIALIZED_HIP_REDUCE_MIN(float)
+CAFFE2_SPECIALIZED_HIP_REDUCE_MIN(double)
+#undef CAFFE2_SPECIALIZED_HIP_REDUCE_MIN
+
+#define CAFFE2_SPECIALIZED_HIP_REDUCE_MAX(T) \
+  template <>                                \
+  void ReduceMax<T, HIPContext>(             \
+      const int num_dims,                    \
+      const int* dims,                       \
+      const int num_axes,                    \
+      const int* axes,                       \
+      const T* X,                            \
+      T* Y,                                  \
+      HIPContext* context) {                 \
+    ReduceTensorHIP(                         \
+        num_dims,                            \
+        dims,                                \
+        num_axes,                            \
+        axes,                                \
+        cub::Max(),                          \
+        std::numeric_limits<T>::lowest(),    \
+        X,                                   \
+        Y,                                   \
+        context);                            \
+  }
+CAFFE2_SPECIALIZED_HIP_REDUCE_MAX(std::int32_t)
+CAFFE2_SPECIALIZED_HIP_REDUCE_MAX(std::int64_t)
+CAFFE2_SPECIALIZED_HIP_REDUCE_MAX(float)
+CAFFE2_SPECIALIZED_HIP_REDUCE_MAX(double)
+#undef CAFFE2_SPECIALIZED_HIP_REDUCE_MAX
+
+#define CAFFE2_SPECIALIZED_HIP_REDUCE_SUM(T)                              \
+  template <>                                                             \
+  void ReduceSum<T, HIPContext>(                                          \
+      const int num_dims,                                                 \
+      const int* dims,                                                    \
+      const int num_axes,                                                 \
+      const int* axes,                                                    \
+      const T* X,                                                         \
+      T* Y,                                                               \
+      HIPContext* context) {                                              \
+    ReduceTensorHIP(                                                      \
+        num_dims, dims, num_axes, axes, cub::Sum(), T(0), X, Y, context); \
+  }
+CAFFE2_SPECIALIZED_HIP_REDUCE_SUM(std::int32_t)
+CAFFE2_SPECIALIZED_HIP_REDUCE_SUM(std::int64_t)
+CAFFE2_SPECIALIZED_HIP_REDUCE_SUM(float)
+CAFFE2_SPECIALIZED_HIP_REDUCE_SUM(double)
+#undef CAFFE2_SPECIALIZED_HIP_REDUCE_SUM
+
+#define CAFFE2_SPECIALIZED_HIP_REDUCE_MEAN(T)                            \
+  template <>                                                            \
+  void ReduceMean<T, HIPContext>(                                        \
+      const int num_dims,                                                \
+      const int* dims,                                                   \
+      const int num_axes,                                                \
+      const int* axes,                                                   \
+      const T* X,                                                        \
+      T* Y,                                                              \
+      HIPContext* context) {                                             \
+    ReduceMeanHIPImpl<T>(num_dims, dims, num_axes, axes, X, Y, context); \
+  }
+CAFFE2_SPECIALIZED_HIP_REDUCE_MEAN(float)
+#undef CAFFE2_SPECIALIZED_HIP_REDUCE_MEAN
+
+namespace {
+
+template <typename T, int D>
+__global__ void BroadcastHIPKernel(
+    const int Y_size,
+    const SimpleArray<int, D> X_strides,
+    const SimpleArray<int, D> Y_dims,
+    const T* X,
+    T* Y) {
+  HIP_1D_KERNEL_LOOP(Y_index, Y_size) {
+    int X_index = 0;
+    int Y_index_val = Y_index;
+#pragma unroll
+    for (int i = D - 1; i >= 0; --i) {
+      X_index += X_strides.data[i] == 0
+          ? 0
+          : (Y_index_val % Y_dims.data[i]) * X_strides.data[i];
+      Y_index_val /= Y_dims.data[i];
+    }
+    Y[Y_index] = __ldg(X + X_index);
+  }
+}
+
+template <typename T, int D>
+void BroadcastHIPImpl(
+    const int X_ndim,
+    const int* X_dims,
+    const int* Y_dims,
+    const T* X,
+    T* Y,
+    HIPContext* context) {
+  SimpleArray<int, D> X_strides_array;
+  SimpleArray<int, D> Y_dims_array;
+  const int d = D - X_ndim;
+  std::fill(X_strides_array.data, X_strides_array.data + d, 0);
+  int cur_stride = 1;
+  for (int i = D - 1; i >= d; --i) {
+    CAFFE_ENFORCE(X_dims[i - d] == 1 || X_dims[i - d] == Y_dims[i]);
+    X_strides_array.data[i] = X_dims[i - d] == 1 ? 0 : cur_stride;
+    cur_stride *= X_dims[i - d];
+  }
+  std::copy_n(Y_dims, D, Y_dims_array.data);
+  const int Y_size =
+      std::accumulate(Y_dims, Y_dims + D, 1, std::multiplies<int>());
+  hipLaunchKernelGGL(
+      (BroadcastHIPKernel<T, D>),
+      dim3(CAFFE_GET_BLOCKS(Y_size)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      Y_size,
+      X_strides_array,
+      Y_dims_array,
+      X,
+      Y);
+}
+
+} // namespace
+
+#define CAFFE2_SPECIALIZED_HIP_BROADCAST(T)                                  \
+  template <>                                                                \
+  void Broadcast<T, HIPContext>(                                             \
+      const int X_ndim,                                                      \
+      const int* X_dims,                                                     \
+      const int Y_ndim,                                                      \
+      const int* Y_dims,                                                     \
+      const T* X,                                                            \
+      T* Y,                                                                  \
+      HIPContext* context) {                                                 \
+    CAFFE_ENFORCE_LE(X_ndim, Y_ndim);                                        \
+    DISPATCH_FUNCTION_BY_VALUE_WITH_TYPE_1(                                  \
+        Y_ndim, BroadcastHIPImpl, T, X_ndim, X_dims, Y_dims, X, Y, context); \
+  }
+CAFFE2_SPECIALIZED_HIP_BROADCAST(std::int32_t)
+CAFFE2_SPECIALIZED_HIP_BROADCAST(std::int64_t)
+CAFFE2_SPECIALIZED_HIP_BROADCAST(float)
+CAFFE2_SPECIALIZED_HIP_BROADCAST(double)
+#undef CAFFE2_SPECIALIZED_HIP_BROADCAST
+
+namespace {
+
+template <typename T>
+__global__ void RowwiseMomentsHIPKernel(
+    const int rows,
+    const int cols,
+    const T* X,
+    T* mean,
+    T* variance) {
+  __shared__ typename BlockReduce<T>::TempStorage m_storage;
+  __shared__ typename BlockReduce<T>::TempStorage v_storage;
+  for (int i = blockIdx.x; i < rows; i += gridDim.x) {
+    T m_val = 0;
+    T v_val = 0;
+    for (int j = threadIdx.x; j < cols; j += blockDim.x) {
+      const int X_index = i * cols + j;
+      m_val += __ldg(X + X_index);
+      v_val += __ldg(X + X_index) * __ldg(X + X_index);
+    }
+    m_val = BlockReduce<T>(m_storage).Reduce(m_val, cub::Sum());
+    v_val = BlockReduce<T>(v_storage).Reduce(v_val, cub::Sum());
+    if (threadIdx.x == 0) {
+      mean[i] = m_val / static_cast<T>(cols);
+      variance[i] = v_val / static_cast<T>(cols) - mean[i] * mean[i];
+    }
+    __syncthreads();
+  }
+}
+
+template <typename T, int D>
+__global__ void MomentsHIPKernel(
+    const int outer_size,
+    const int inner_size,
+    SimpleArray<int, D> X_strides,
+    SimpleArray<int, D> Y_dims,
+    const T* X,
+    T* mean,
+    T* variance) {
+  __shared__ typename BlockReduce<T>::TempStorage m_storage;
+  __shared__ typename BlockReduce<T>::TempStorage v_storage;
+  for (int i = blockIdx.x; i < outer_size; i += gridDim.x) {
+    T m_val = 0;
+    T v_val = 0;
+    for (int j = threadIdx.x; j < inner_size; j += blockDim.x) {
+      int X_index = 0;
+      int Y_index = i * inner_size + j;
+#pragma unroll
+      for (int i = D - 1; i >= 0; --i) {
+        X_index += (Y_index % Y_dims.data[i]) * X_strides.data[i];
+        Y_index /= Y_dims.data[i];
+      }
+      m_val += __ldg(X + X_index);
+      v_val += __ldg(X + X_index) * __ldg(X + X_index);
+    }
+    m_val = BlockReduce<T>(m_storage).Reduce(m_val, cub::Sum());
+    v_val = BlockReduce<T>(v_storage).Reduce(v_val, cub::Sum());
+    if (threadIdx.x == 0) {
+      mean[i] = m_val / static_cast<T>(inner_size);
+      variance[i] = v_val / static_cast<T>(inner_size) - mean[i] * mean[i];
+    }
+    __syncthreads();
+  }
+}
+
+template <typename T, int D>
+void MomentsHIPImpl(
+    const int outer_size,
+    const int inner_size,
+    const int* dims,
+    const int* axes,
+    const T* X,
+    T* mean,
+    T* variance,
+    HIPContext* context) {
+  SimpleArray<int, D> X_strides;
+  SimpleArray<int, D> Y_dims;
+  utils::ComputeTransposedStrides(D, dims, axes, X_strides.data);
+  for (int i = 0; i < D; ++i) {
+    Y_dims.data[i] = dims[axes[i]];
+  }
+  hipLaunchKernelGGL(
+      (MomentsHIPKernel<T, D>),
+      dim3(std::min(outer_size, CAFFE_MAXIMUM_NUM_BLOCKS)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      outer_size,
+      inner_size,
+      X_strides,
+      Y_dims,
+      X,
+      mean,
+      variance);
+}
+
+template <typename T>
+void MomentsHIP(
+    const int num_dims,
+    const int* dims,
+    const int num_axes,
+    const int* axes,
+    const T* X,
+    T* mean,
+    T* variance,
+    HIPContext* context) {
+  CAFFE_ENFORCE_LE(num_axes, num_dims);
+  std::vector<int> transpose_axes(num_dims);
+  utils::ComputeTransposeAxesForReduceOp(
+      num_dims, num_axes, axes, transpose_axes.data());
+  const int pivot = num_dims - num_axes;
+  int outer_size = 1;
+  for (int i = 0; i < pivot; ++i) {
+    outer_size *= dims[transpose_axes[i]];
+  }
+  int inner_size = 1;
+  for (int i = pivot; i < num_dims; ++i) {
+    inner_size *= dims[transpose_axes[i]];
+  }
+  if (transpose_axes[pivot] == pivot) {
+    hipLaunchKernelGGL(
+        (RowwiseMomentsHIPKernel<T>),
+        dim3(std::min(outer_size, CAFFE_MAXIMUM_NUM_BLOCKS)),
+        dim3(CAFFE_HIP_NUM_THREADS),
+        0,
+        context->hip_stream(),
+        outer_size,
+        inner_size,
+        X,
+        mean,
+        variance);
+    return;
+  }
+  DISPATCH_FUNCTION_BY_VALUE_WITH_TYPE_1(
+      num_dims,
+      MomentsHIPImpl,
+      T,
+      outer_size,
+      inner_size,
+      dims,
+      transpose_axes.data(),
+      X,
+      mean,
+      variance,
+      context);
+}
+
+} // namespace
+
+#define CAFFE2_SPECIALIZED_HIP_MOMENTS(T)                                      \
+  template <>                                                                  \
+  void Moments<T, HIPContext>(                                                 \
+      const int num_dims,                                                      \
+      const int* dims,                                                         \
+      const int num_axes,                                                      \
+      const int* axes,                                                         \
+      const T* X,                                                              \
+      T* mean,                                                                 \
+      T* variance,                                                             \
+      HIPContext* context) {                                                   \
+    MomentsHIP<T>(num_dims, dims, num_axes, axes, X, mean, variance, context); \
+  }
+CAFFE2_SPECIALIZED_HIP_MOMENTS(float)
+#undef CAFFE2_SPECIALIZED_HIP_MOMENTS
+
+namespace {
+
+template <typename T, int D>
+__global__ void TransposeHIPKernel(
+    const int size,
+    const SimpleArray<int, D> X_strides,
+    const SimpleArray<int, D> Y_dims,
+    const T* X,
+    T* Y) {
+  HIP_1D_KERNEL_LOOP(Y_index, size) {
+    int X_index = 0;
+    int Y_index_val = Y_index;
+#pragma unroll
+    for (int i = D - 1; i >= 0; --i) {
+      X_index += (Y_index_val % Y_dims.data[i]) * X_strides.data[i];
+      Y_index_val /= Y_dims.data[i];
+    }
+    Y[Y_index] = __ldg(X + X_index);
+  }
+}
+
+template <typename T, int D>
+void TransposeHIPImpl(
+    const int* dims,
+    const int* axes,
+    const T* X,
+    T* Y,
+    HIPContext* context) {
+  SimpleArray<int, D> X_strides;
+  SimpleArray<int, D> Y_dims;
+  utils::ComputeTransposedStrides(D, dims, axes, X_strides.data);
+  int size = 1;
+  for (int i = 0; i < D; ++i) {
+    Y_dims.data[i] = dims[axes[i]];
+    size *= dims[i];
+  }
+  hipLaunchKernelGGL(
+      (TransposeHIPKernel<T, D>),
+      dim3(CAFFE_GET_BLOCKS(size)),
+      dim3(CAFFE_HIP_NUM_THREADS),
+      0,
+      context->hip_stream(),
+      size,
+      X_strides,
+      Y_dims,
+      X,
+      Y);
+}
+
+} // namespace
+
+#define CAFFE2_SPECIALIZED_HIP_TRANSPOSE(T)                    \
+  template <>                                                  \
+  void Transpose<T, HIPContext>(                               \
+      const int ndim,                                          \
+      const int* dims,                                         \
+      const int* axes,                                         \
+      const T* X,                                              \
+      T* Y,                                                    \
+      HIPContext* context) {                                   \
+    DISPATCH_FUNCTION_BY_VALUE_WITH_TYPE_1(                    \
+        ndim, TransposeHIPImpl, T, dims, axes, X, Y, context); \
+  }
+CAFFE2_SPECIALIZED_HIP_TRANSPOSE(float)
+CAFFE2_SPECIALIZED_HIP_TRANSPOSE(double)
+CAFFE2_SPECIALIZED_HIP_TRANSPOSE(int)
+CAFFE2_SPECIALIZED_HIP_TRANSPOSE(TIndex)
+#undef CAFFE2_SPECIALIZED_HIP_TRANSPOSE
+} // namespace math
+} // namespace caffe2
diff --git a/caffe2/utils/math_hip_test.cc b/caffe2/utils/math_hip_test.cc
new file mode 100644
index 0000000000000..19a4eed95632e
--- /dev/null
+++ b/caffe2/utils/math_hip_test.cc
@@ -0,0 +1,898 @@
+#include <iostream>
+#include <memory>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "caffe2/core/context.h"
+#include "caffe2/core/flags.h"
+#include "caffe2/core/hip/context_hip.h"
+#include "caffe2/operators/utility_ops.h"
+#include "caffe2/utils/math.h"
+
+CAFFE2_DECLARE_string(caffe_test_root);
+
+namespace caffe2 {
+
+void executeGpuBinaryOpTest(
+    int shapex0,
+    int shapex1,
+    int shapey,
+    std::function<float(int)> input0,
+    std::function<float(int)> input1,
+    std::function<void(
+        int N0,
+        int N1,
+        const float* src0,
+        const float* src1,
+        float* dst,
+        HIPContext* context)> operation,
+    std::function<float(int)> correct_output) {
+  if (!HasHipGPU())
+    return;
+  Workspace ws;
+  DeviceOption option;
+  option.set_device_type(HIP);
+  HIPContext context(option);
+
+  Blob* blobx0 = ws.CreateBlob("X0");
+  Blob* blobx1 = ws.CreateBlob("X1");
+  Blob* bloby = ws.CreateBlob("Y");
+  Blob* bloby_host = ws.CreateBlob("Y_host");
+
+  auto* tensorx0 = blobx0->GetMutable<Tensor<HIPContext>>();
+  auto* tensorx1 = blobx1->GetMutable<Tensor<HIPContext>>();
+  auto* tensory = bloby->GetMutable<Tensor<HIPContext>>();
+
+  vector<int> shapex0_vector{shapex0};
+  vector<int> shapex1_vector{shapex1};
+  vector<int> shapey_vector{shapey};
+
+  tensorx0->Resize(shapex0_vector);
+  tensorx1->Resize(shapex1_vector);
+  tensory->Resize(shapey_vector);
+
+  for (int i = 0; i < shapex0; i++) {
+    math::Set<float, HIPContext>(
+        1, input0(i), tensorx0->mutable_data<float>() + i, &context);
+  }
+  for (int i = 0; i < shapex1; i++) {
+    math::Set<float, HIPContext>(
+        1, input1(i), tensorx1->mutable_data<float>() + i, &context);
+  }
+  operation(
+      shapex0,
+      shapex1,
+      tensorx0->template data<float>(),
+      tensorx1->template data<float>(),
+      tensory->mutable_data<float>(),
+      &context);
+  context.FinishDeviceComputation();
+
+  // Copy result to CPU so we can inspect it
+  auto* tensory_host = bloby_host->GetMutable<Tensor<CPUContext>>();
+  tensory_host->CopyFrom<HIPContext, HIPContext>(*tensory, &context);
+  context.FinishDeviceComputation();
+
+  for (int i = 0; i < shapey; ++i) {
+    EXPECT_EQ(tensory_host->data<float>()[i], correct_output(i));
+  }
+}
+
+TEST(MathUtilGPUTest, testAddStripedBatch) {
+  if (!HasHipGPU())
+    return;
+  Workspace ws;
+  DeviceOption option;
+  option.set_device_type(HIP);
+  HIPContext context(option);
+  Blob* blobx = ws.CreateBlob("X");
+  Blob* bloby = ws.CreateBlob("Y");
+  Blob* bloby_host = ws.CreateBlob("Y_host");
+
+  vector<int> shapex{33 * 9, 25};
+  vector<int> shapey{33, 25};
+
+  auto* tensorx = blobx->GetMutable<Tensor<HIPContext>>();
+  tensorx->Resize(shapex);
+  int stripe = 33 * 25;
+  vector<float> tot(33, 0.0);
+  for (int j = 0; j < 9; j++) {
+    // Have different values for each line
+    for (int k = 0; k < 33; k++) {
+      math::Set<float, HIPContext>(
+          33,
+          1.0 + j + k,
+          tensorx->mutable_data<float>() + j * stripe + k * 25,
+          &context);
+      tot[k] += 1.0 + j + k;
+    }
+  }
+
+  auto* tensory = bloby->GetMutable<Tensor<HIPContext>>();
+  tensory->Resize(shapey);
+  math::Set<float, HIPContext>(
+      stripe, 0.0, tensory->mutable_data<float>(), &context);
+
+  math::AddStripedBatch<float, HIPContext>(
+      stripe,
+      tensorx->template data<float>(),
+      tensory->mutable_data<float>(),
+      stripe,
+      9,
+      &context);
+  context.FinishDeviceComputation();
+
+  // Copy result to CPU so we can inspect it
+  auto* tensory_host = bloby_host->GetMutable<Tensor<CPUContext>>();
+  tensory_host->CopyFrom<HIPContext, HIPContext>(*tensory, &context);
+  context.FinishDeviceComputation();
+
+  for (int k = 0; k < 33; k++) {
+    for (int i = 0; i < 25; i++) {
+      EXPECT_EQ(tensory_host->data<float>()[k * 25 + i], tot[k]);
+    }
+  }
+}
+
+TEST(MathUtilGPUTest, testReduceMin) {
+  executeGpuBinaryOpTest(
+      6,
+      1,
+      1,
+      [](int /*i*/) { return 11.0f; },
+      [](int /*i*/) { return 0.0f; },
+      [](int N0,
+         int /*N1*/,
+         const float* src0,
+         const float* /*src1*/,
+         float* dst,
+         HIPContext* context) {
+        Tensor<HIPContext> aux;
+        math::ReduceMin<float, HIPContext>(N0, src0, dst, &aux, context);
+      },
+      [](int /*i*/) { return 11.0f; });
+  executeGpuBinaryOpTest(
+      6,
+      1,
+      1,
+      [](int i) { return i == 3 ? 11.0f : 17.0f; },
+      [](int /*i*/) { return 0.0f; },
+      [](int N0,
+         int /*N1*/,
+         const float* src0,
+         const float* /*src1*/,
+         float* dst,
+         HIPContext* context) {
+        Tensor<HIPContext> aux;
+        math::ReduceMin<float, HIPContext>(N0, src0, dst, &aux, context);
+      },
+      [](int /*i*/) { return 11.0f; });
+}
+
+TEST(MathUtilGPUTest, testReduceMax) {
+  executeGpuBinaryOpTest(
+      6,
+      1,
+      1,
+      [](int /*i*/) { return 11.0f; },
+      [](int /*i*/) { return 0.0f; },
+      [](int N0,
+         int /*N1*/,
+         const float* src0,
+         const float* /*src1*/,
+         float* dst,
+         HIPContext* context) {
+        Tensor<HIPContext> aux;
+        math::ReduceMax<float, HIPContext>(N0, src0, dst, &aux, context);
+      },
+      [](int /*i*/) { return 11.0f; });
+  executeGpuBinaryOpTest(
+      6,
+      1,
+      1,
+      [](int i) { return i == 3 ? 17.0f : 11.0f; },
+      [](int /*i*/) { return 0.0f; },
+      [](int N0,
+         int /*N1*/,
+         const float* src0,
+         const float* /*src1*/,
+         float* dst,
+         HIPContext* context) {
+        Tensor<HIPContext> aux;
+        math::ReduceMax<float, HIPContext>(N0, src0, dst, &aux, context);
+      },
+      [](int /*i*/) { return 17.0f; });
+}
+
+TEST(MathUtilGPUTest, testElemwiseMax) {
+  executeGpuBinaryOpTest(
+      13,
+      13,
+      13,
+      [](int i) { return 2.0f - i; },
+      [](int i) { return i - 6.0f; },
+      [](int N0,
+         int /*N1*/,
+         const float* src0,
+         const float* src1,
+         float* dst,
+         HIPContext* context) {
+        math::ElemwiseMax<float, HIPContext>(N0, src0, src1, dst, context);
+      },
+      [](int i) { return std::max(2.0f - i, i - 6.0f); });
+}
+
+TEST(MathUtilGPUTest, testCopyVector) {
+  executeGpuBinaryOpTest(
+      6,
+      1,
+      6,
+      [](int i) { return 5.0f - i; },
+      [](int /*i*/) { return 0.0f; },
+      [](int N0,
+         int /*N1*/,
+         const float* src0,
+         const float* /*src1*/,
+         float* dst,
+         HIPContext* context) {
+        math::CopyVector<float, HIPContext>(N0, src0, dst, context);
+      },
+      [](int i) { return 5.0f - i; });
+}
+
+namespace {
+
+constexpr float kEps = 1e-5;
+
+class GemmBatchedGPUTest
+    : public testing::TestWithParam<testing::tuple<bool, bool>> {
+ protected:
+  void SetUp() override {
+    if (!HasHipGPU()) {
+      return;
+    }
+    option_.set_device_type(HIP);
+    hip_context_ = make_unique<HIPContext>(option_);
+    Blob* X_blob = ws_.CreateBlob("X");
+    Blob* W_blob = ws_.CreateBlob("W");
+    Blob* Y_blob = ws_.CreateBlob("Y");
+    X_ = X_blob->GetMutable<Tensor<HIPContext>>();
+    W_ = W_blob->GetMutable<Tensor<HIPContext>>();
+    Y_ = Y_blob->GetMutable<Tensor<HIPContext>>();
+    X_->Resize(std::vector<TIndex>{3, 5, 10});
+    W_->Resize(std::vector<TIndex>{3, 6, 10});
+    Y_->Resize(std::vector<TIndex>{3, 5, 6});
+    math::Set<float, HIPContext>(
+        X_->size(), 1.0f, X_->mutable_data<float>(), hip_context_.get());
+    math::Set<float, HIPContext>(
+        W_->size(), 1.0f, W_->mutable_data<float>(), hip_context_.get());
+    trans_X_ = std::get<0>(GetParam());
+    trans_W_ = std::get<1>(GetParam());
+  }
+
+  void RunGemmBatched(const float alpha, const float beta) {
+    math::GemmBatched(
+        trans_X_ ? CblasTrans : CblasNoTrans,
+        trans_W_ ? CblasTrans : CblasNoTrans,
+        3,
+        5,
+        6,
+        10,
+        alpha,
+        X_->template data<float>(),
+        W_->template data<float>(),
+        beta,
+        Y_->template mutable_data<float>(),
+        hip_context_.get());
+  }
+
+  void VerifyOutput(const float value) const {
+    TensorCPU Y_cpu(*Y_);
+    for (int i = 0; i < Y_cpu.size(); ++i) {
+      EXPECT_FLOAT_EQ(value, Y_cpu.template data<float>()[i]);
+    }
+  }
+
+  Workspace ws_;
+  DeviceOption option_;
+  std::unique_ptr<HIPContext> hip_context_;
+  Tensor<HIPContext>* X_ = nullptr;
+  Tensor<HIPContext>* W_ = nullptr;
+  Tensor<HIPContext>* Y_ = nullptr;
+  bool trans_X_;
+  bool trans_W_;
+};
+
+TEST_P(GemmBatchedGPUTest, GemmBatchedGPUFloatTest) {
+  if (!HasHipGPU()) {
+    return;
+  }
+  RunGemmBatched(1.0f, 0.0f);
+  VerifyOutput(10.0f);
+  RunGemmBatched(1.0f, 0.5f);
+  VerifyOutput(15.0f);
+  RunGemmBatched(0.5f, 1.0f);
+  VerifyOutput(20.0f);
+}
+
+INSTANTIATE_TEST_CASE_P(
+    GemmBatchedGPUTrans,
+    GemmBatchedGPUTest,
+    testing::Combine(testing::Bool(), testing::Bool()));
+
+class ReduceTensorGPUTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    if (!HasHipGPU()) {
+      return;
+    }
+    option_.set_device_type(HIP);
+    hip_context_ = make_unique<HIPContext>(option_);
+    Blob* blob_x = ws_.CreateBlob("X");
+    Blob* blob_y = ws_.CreateBlob("Y");
+    X_ = blob_x->GetMutable<Tensor<HIPContext>>();
+    Y_ = blob_y->GetMutable<Tensor<HIPContext>>();
+  }
+
+  void SetUpData(
+      const std::vector<int>& X_dims,
+      const std::vector<int>& axes,
+      const std::vector<float>& X_data) {
+    std::vector<int> Y_dims = X_dims;
+    for (const int axis : axes) {
+      Y_dims[axis] = 1;
+    }
+    X_->Resize(X_dims);
+    Y_->Resize(Y_dims);
+    ASSERT_EQ(X_data.size(), X_->size());
+    hip_context_->Copy<float, CPUContext, HIPContext>(
+        X_data.size(), X_data.data(), X_->mutable_data<float>());
+  }
+
+  void VerifyResult(const std::vector<float>& expected_output) {
+    Blob* blob_y_host = ws_.CreateBlob("Y_host");
+    auto* Y_host = blob_y_host->GetMutable<TensorCPU>();
+    Y_host->CopyFrom<HIPContext, HIPContext>(*Y_, hip_context_.get());
+    hip_context_->FinishDeviceComputation();
+    ASSERT_EQ(expected_output.size(), Y_host->size());
+    for (std::size_t i = 0; i < expected_output.size(); ++i) {
+      EXPECT_FLOAT_EQ(expected_output[i], Y_host->data<float>()[i]);
+    }
+  }
+
+  template <class ReduceFunc>
+  void RunRedcueTensorTest(
+      const ReduceFunc& reduce_func,
+      const std::vector<int>& X_dims,
+      const std::vector<int>& axes,
+      const std::vector<float>& X_data,
+      const std::vector<float>& Y_data) {
+    SetUpData(X_dims, axes, X_data);
+    reduce_func(
+        X_dims.size(),
+        X_dims.data(),
+        axes.size(),
+        axes.data(),
+        X_->data<float>(),
+        Y_->mutable_data<float>(),
+        hip_context_.get());
+    VerifyResult(Y_data);
+  }
+
+  Workspace ws_;
+  DeviceOption option_;
+  std::unique_ptr<HIPContext> hip_context_;
+  Tensor<HIPContext>* X_ = nullptr;
+  Tensor<HIPContext>* Y_ = nullptr;
+};
+
+TEST_F(ReduceTensorGPUTest, ReduceMinGPUTest) {
+  if (!HasHipGPU()) {
+    return;
+  }
+  const auto& reduce_min = [](const int num_dims,
+                              const int* dims,
+                              const int num_axes,
+                              const int* axes,
+                              const float* X,
+                              float* Y,
+                              HIPContext* context) {
+    return math::ReduceMin<float, HIPContext>(
+        num_dims, dims, num_axes, axes, X, Y, context);
+  };
+  // Test for 1D tensor.
+  RunRedcueTensorTest(reduce_min, {3}, {0}, {1.0f, 2.0f, 3.0f}, {1.0f});
+
+  // Test for 2D Tensor.
+  RunRedcueTensorTest(
+      reduce_min,
+      {2, 3},
+      {1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {1.0f, 4.0f});
+  RunRedcueTensorTest(
+      reduce_min,
+      {2, 3},
+      {0},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {1.0f, 2.0f, 3.0f});
+  RunRedcueTensorTest(
+      reduce_min, {2, 3}, {0, 1}, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}, {1.0f});
+
+  // Test for 3D tensor.
+  RunRedcueTensorTest(
+      reduce_min,
+      {2, 2, 2},
+      {1, 2},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {1.0f, 5.0f});
+  RunRedcueTensorTest(
+      reduce_min,
+      {2, 2, 2},
+      {0, 1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {1.0f, 2.0f});
+  RunRedcueTensorTest(
+      reduce_min,
+      {2, 2, 2},
+      {0, 2},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {1.0f, 3.0f});
+}
+
+TEST_F(ReduceTensorGPUTest, ReduceMaxGPUTest) {
+  if (!HasHipGPU()) {
+    return;
+  }
+  const auto& reduce_max = [](const int num_dims,
+                              const int* dims,
+                              const int num_axes,
+                              const int* axes,
+                              const float* X,
+                              float* Y,
+                              HIPContext* context) {
+    return math::ReduceMax<float, HIPContext>(
+        num_dims, dims, num_axes, axes, X, Y, context);
+  };
+  // Test for 1D tensor.
+  RunRedcueTensorTest(reduce_max, {3}, {0}, {1.0f, 2.0f, 3.0f}, {3.0f});
+
+  // Test for 2D Tensor.
+  RunRedcueTensorTest(
+      reduce_max,
+      {2, 3},
+      {1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {3.0f, 6.0f});
+  RunRedcueTensorTest(
+      reduce_max,
+      {2, 3},
+      {0},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {4.0f, 5.0f, 6.0f});
+  RunRedcueTensorTest(
+      reduce_max, {2, 3}, {0, 1}, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}, {6.0f});
+
+  // Test for 3D tensor.
+  RunRedcueTensorTest(
+      reduce_max,
+      {2, 2, 2},
+      {1, 2},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {4.0f, 8.0f});
+  RunRedcueTensorTest(
+      reduce_max,
+      {2, 2, 2},
+      {0, 1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {7.0f, 8.0f});
+  RunRedcueTensorTest(
+      reduce_max,
+      {2, 2, 2},
+      {0, 2},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {6.0f, 8.0f});
+}
+
+TEST_F(ReduceTensorGPUTest, ReduceSumGPUTest) {
+  if (!HasHipGPU()) {
+    return;
+  }
+  // Test for 1D tensor.
+  RunRedcueTensorTest(
+      math::ReduceSum<float, HIPContext>, {3}, {0}, {1.0f, 2.0f, 3.0f}, {6.0f});
+
+  // Test for 2D Tensor.
+  RunRedcueTensorTest(
+      math::ReduceSum<float, HIPContext>,
+      {2, 3},
+      {1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {6.0f, 15.0f});
+  RunRedcueTensorTest(
+      math::ReduceSum<float, HIPContext>,
+      {2, 3},
+      {0},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {5.0f, 7.0f, 9.0f});
+  RunRedcueTensorTest(
+      math::ReduceSum<float, HIPContext>,
+      {2, 3},
+      {0, 1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {21.0f});
+
+  // Test for 3D tensor.
+  RunRedcueTensorTest(
+      math::ReduceSum<float, HIPContext>,
+      {2, 2, 2},
+      {1, 2},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {10.0f, 26.0f});
+  RunRedcueTensorTest(
+      math::ReduceSum<float, HIPContext>,
+      {2, 2, 2},
+      {0, 1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {16.0f, 20.0f});
+  RunRedcueTensorTest(
+      math::ReduceSum<float, HIPContext>,
+      {2, 2, 2},
+      {0, 2},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {14.0f, 22.0f});
+}
+
+TEST_F(ReduceTensorGPUTest, ReduceMeanGPUTest) {
+  if (!HasHipGPU()) {
+    return;
+  }
+  // Test for 1D tensor.
+  RunRedcueTensorTest(
+      math::ReduceMean<float, HIPContext>,
+      {3},
+      {0},
+      {1.0f, 2.0f, 3.0f},
+      {2.0f});
+
+  // Test for 2D Tensor.
+  RunRedcueTensorTest(
+      math::ReduceMean<float, HIPContext>,
+      {2, 3},
+      {1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {2.0f, 5.0f});
+  RunRedcueTensorTest(
+      math::ReduceMean<float, HIPContext>,
+      {2, 3},
+      {0},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {2.5f, 3.5f, 4.5f});
+  RunRedcueTensorTest(
+      math::ReduceMean<float, HIPContext>,
+      {2, 3},
+      {0, 1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {3.5f});
+
+  // Test for 3D tensor.
+  RunRedcueTensorTest(
+      math::ReduceMean<float, HIPContext>,
+      {2, 2, 2},
+      {1, 2},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {2.5f, 6.5f});
+  RunRedcueTensorTest(
+      math::ReduceMean<float, HIPContext>,
+      {2, 2, 2},
+      {0, 1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {4.0f, 5.0f});
+  RunRedcueTensorTest(
+      math::ReduceMean<float, HIPContext>,
+      {2, 2, 2},
+      {0, 2},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {3.5f, 5.5f});
+}
+
+class BroadcastGPUTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    if (!HasHipGPU()) {
+      return;
+    }
+    option_.set_device_type(HIP);
+    hip_context_ = make_unique<HIPContext>(option_);
+    Blob* blob_x = ws_.CreateBlob("X");
+    Blob* blob_y = ws_.CreateBlob("Y");
+    X_ = blob_x->GetMutable<Tensor<HIPContext>>();
+    Y_ = blob_y->GetMutable<Tensor<HIPContext>>();
+  }
+
+  void SetUpData(
+      const std::vector<int>& X_dims,
+      const std::vector<int>& Y_dims,
+      const std::vector<float>& X_data) {
+    X_->Resize(X_dims);
+    Y_->Resize(Y_dims);
+    ASSERT_EQ(X_data.size(), X_->size());
+    hip_context_->Copy<float, CPUContext, HIPContext>(
+        X_data.size(), X_data.data(), X_->mutable_data<float>());
+  }
+
+  void VerifyResult(const std::vector<float>& expected_output) {
+    Blob* blob_y_host = ws_.CreateBlob("Y_host");
+    auto* Y_host = blob_y_host->GetMutable<TensorCPU>();
+    Y_host->CopyFrom<HIPContext, HIPContext>(*Y_, hip_context_.get());
+    hip_context_->FinishDeviceComputation();
+    ASSERT_EQ(expected_output.size(), Y_host->size());
+    for (std::size_t i = 0; i < expected_output.size(); ++i) {
+      EXPECT_FLOAT_EQ(expected_output[i], Y_host->data<float>()[i]);
+    }
+  }
+
+  void RunBroadcastTest(
+      const std::vector<int>& X_dims,
+      const std::vector<int>& Y_dims,
+      const std::vector<float>& X_data,
+      const std::vector<float>& Y_data) {
+    SetUpData(X_dims, Y_dims, X_data);
+    math::Broadcast<float, HIPContext>(
+        X_dims.size(),
+        X_dims.data(),
+        Y_dims.size(),
+        Y_dims.data(),
+        X_->data<float>(),
+        Y_->mutable_data<float>(),
+        hip_context_.get());
+    VerifyResult(Y_data);
+  }
+
+  Workspace ws_;
+  DeviceOption option_;
+  std::unique_ptr<HIPContext> hip_context_;
+  Tensor<HIPContext>* X_ = nullptr;
+  Tensor<HIPContext>* Y_ = nullptr;
+};
+
+TEST_F(BroadcastGPUTest, BroadcastGPUFloatTest) {
+  if (!HasHipGPU()) {
+    return;
+  }
+  RunBroadcastTest({2}, {2}, {1.0f, 2.0f}, {1.0f, 2.0f});
+  RunBroadcastTest({1}, {2}, {1.0f}, {1.0f, 1.0f});
+  RunBroadcastTest({1}, {2, 2}, {1.0f}, {1.0f, 1.0f, 1.0f, 1.0f});
+  RunBroadcastTest({2, 1}, {2, 2}, {1.0f, 2.0f}, {1.0f, 1.0f, 2.0f, 2.0f});
+  RunBroadcastTest(
+      {2, 1},
+      {2, 2, 2},
+      {1.0f, 2.0f},
+      {1.0f, 1.0f, 2.0f, 2.0f, 1.0f, 1.0f, 2.0f, 2.0f});
+}
+
+class MomentsGPUTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    if (!HasHipGPU()) {
+      return;
+    }
+    option_.set_device_type(HIP);
+    hip_context_ = make_unique<HIPContext>(option_);
+    Blob* blob_x = ws_.CreateBlob("X");
+    Blob* blob_mean = ws_.CreateBlob("mean");
+    Blob* blob_variance = ws_.CreateBlob("variance");
+    X_ = blob_x->GetMutable<Tensor<HIPContext>>();
+    mean_ = blob_mean->GetMutable<Tensor<HIPContext>>();
+    variance_ = blob_variance->GetMutable<Tensor<HIPContext>>();
+  }
+
+  void SetUpData(
+      const std::vector<int>& X_dims,
+      const std::vector<int>& axes,
+      const std::vector<float>& X_data) {
+    std::vector<int> Y_dims = X_dims;
+    for (const int axis : axes) {
+      Y_dims[axis] = 1;
+    }
+    X_->Resize(X_dims);
+    mean_->Resize(Y_dims);
+    variance_->Resize(Y_dims);
+    ASSERT_EQ(X_data.size(), X_->size());
+    hip_context_->Copy<float, CPUContext, HIPContext>(
+        X_data.size(), X_data.data(), X_->mutable_data<float>());
+  }
+
+  void VerifyResult(
+      const std::vector<float>& mean_data,
+      const std::vector<float>& variance_data) {
+    Blob* blob_mean_host = ws_.CreateBlob("mean_host");
+    auto* mean_host = blob_mean_host->GetMutable<TensorCPU>();
+    mean_host->CopyFrom<HIPContext, HIPContext>(*mean_, hip_context_.get());
+    Blob* blob_variance_host = ws_.CreateBlob("variance_host");
+    auto* variance_host = blob_variance_host->GetMutable<TensorCPU>();
+    variance_host->CopyFrom<HIPContext, HIPContext>(
+        *variance_, hip_context_.get());
+    hip_context_->FinishDeviceComputation();
+
+    ASSERT_EQ(mean_data.size(), mean_host->size());
+    for (std::size_t i = 0; i < mean_data.size(); ++i) {
+      EXPECT_FLOAT_EQ(mean_data[i], mean_host->data<float>()[i]);
+    }
+    ASSERT_EQ(variance_data.size(), variance_host->size());
+    for (std::size_t i = 0; i < variance_data.size(); ++i) {
+      EXPECT_NEAR(variance_data[i], variance_host->data<float>()[i], kEps);
+    }
+  }
+
+  void RunMomentsTest(
+      const std::vector<int>& X_dims,
+      const std::vector<int>& axes,
+      const std::vector<float>& X_data,
+      const std::vector<float>& mean_data,
+      const std::vector<float>& variance_data) {
+    SetUpData(X_dims, axes, X_data);
+    math::Moments<float, HIPContext>(
+        X_dims.size(),
+        X_dims.data(),
+        axes.size(),
+        axes.data(),
+        X_->data<float>(),
+        mean_->mutable_data<float>(),
+        variance_->mutable_data<float>(),
+        hip_context_.get());
+    VerifyResult(mean_data, variance_data);
+  }
+
+  Workspace ws_;
+  DeviceOption option_;
+  std::unique_ptr<HIPContext> hip_context_;
+  Tensor<HIPContext>* X_ = nullptr;
+  Tensor<HIPContext>* mean_ = nullptr;
+  Tensor<HIPContext>* variance_ = nullptr;
+};
+
+TEST_F(MomentsGPUTest, MomentsGPUFloatTest) {
+  if (!HasHipGPU()) {
+    return;
+  }
+  // Test for 1D tensor.
+  RunMomentsTest({3}, {0}, {1.0f, 2.0f, 3.0f}, {2.0f}, {2.0f / 3.0f});
+
+  // Test for 2D Tensor.
+  RunMomentsTest(
+      {2, 3},
+      {1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {2.0f, 5.0f},
+      {2.0f / 3.0f, 2.0f / 3.0f});
+  RunMomentsTest(
+      {2, 3},
+      {0},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {2.5f, 3.5f, 4.5f},
+      {2.25f, 2.25f, 2.25f});
+  RunMomentsTest(
+      {2, 3},
+      {0, 1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {3.5f},
+      {35.0f / 12.0f});
+
+  // Test for 3D tensor.
+  RunMomentsTest(
+      {2, 2, 2},
+      {1, 2},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {2.5f, 6.5f},
+      {1.25, 1.25});
+  RunMomentsTest(
+      {2, 2, 2},
+      {0, 1},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {4.0f, 5.0f},
+      {5.0f, 5.0f});
+  RunMomentsTest(
+      {2, 2, 2},
+      {0, 2},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {3.5f, 5.5f},
+      {4.25, 4.25});
+}
+
+class TransposeGPUTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    if (!HasHipGPU()) {
+      return;
+    }
+    option_.set_device_type(HIP);
+    hip_context_ = make_unique<HIPContext>(option_);
+    Blob* blob_x = ws_.CreateBlob("X");
+    Blob* blob_y = ws_.CreateBlob("Y");
+    X_ = blob_x->GetMutable<Tensor<HIPContext>>();
+    Y_ = blob_y->GetMutable<Tensor<HIPContext>>();
+  }
+
+  void SetUpData(
+      const std::vector<int>& X_dims,
+      const std::vector<int>& axes,
+      const std::vector<float>& X_data) {
+    const int ndim = X_dims.size();
+    std::vector<int> Y_dims(ndim);
+    for (int i = 0; i < ndim; ++i) {
+      Y_dims[i] = X_dims[axes[i]];
+    }
+    X_->Resize(X_dims);
+    Y_->Resize(Y_dims);
+    ASSERT_EQ(X_data.size(), X_->size());
+    hip_context_->Copy<float, CPUContext, HIPContext>(
+        X_data.size(), X_data.data(), X_->mutable_data<float>());
+  }
+
+  void VerifyResult(const std::vector<float>& expected_output) {
+    Blob* blob_y_host = ws_.CreateBlob("Y_host");
+    auto* Y_host = blob_y_host->GetMutable<TensorCPU>();
+    Y_host->CopyFrom<HIPContext, HIPContext>(*Y_, hip_context_.get());
+    hip_context_->FinishDeviceComputation();
+    ASSERT_EQ(expected_output.size(), Y_host->size());
+    for (std::size_t i = 0; i < expected_output.size(); ++i) {
+      EXPECT_FLOAT_EQ(expected_output[i], Y_host->data<float>()[i]);
+    }
+  }
+
+  void RunTransposeTest(
+      const std::vector<int>& X_dims,
+      const std::vector<int>& axes,
+      const std::vector<float>& X_data,
+      const std::vector<float>& Y_data) {
+    SetUpData(X_dims, axes, X_data);
+    math::Transpose<float, HIPContext>(
+        X_dims.size(),
+        X_dims.data(),
+        axes.data(),
+        X_->data<float>(),
+        Y_->mutable_data<float>(),
+        hip_context_.get());
+    hip_context_->FinishDeviceComputation();
+    VerifyResult(Y_data);
+  }
+
+  Workspace ws_;
+  DeviceOption option_;
+  std::unique_ptr<HIPContext> hip_context_;
+  Tensor<HIPContext>* X_ = nullptr;
+  Tensor<HIPContext>* Y_ = nullptr;
+};
+
+TEST_F(TransposeGPUTest, TransposeGPUFloatTest) {
+  if (!HasHipGPU()) {
+    return;
+  }
+  // Test for 1D transpose.
+  RunTransposeTest({3}, {0}, {1.0f, 2.0f, 3.0f}, {1.0f, 2.0f, 3.0f});
+
+  // Test for 2D transpose.
+  RunTransposeTest(
+      {2, 3},
+      {1, 0},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+      {1.0f, 4.0f, 2.0f, 5.0f, 3.0f, 6.0f});
+
+  // Test for 3D transpose.
+  RunTransposeTest(
+      {2, 2, 2},
+      {1, 2, 0},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {1.0f, 5.0f, 2.0f, 6.0f, 3.0f, 7.0f, 4.0f, 8.0f});
+  RunTransposeTest(
+      {2, 2, 2},
+      {1, 0, 2},
+      {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f},
+      {1.0f, 2.0f, 5.0f, 6.0f, 3.0f, 4.0f, 7.0f, 8.0f});
+}
+
+} // namespace
+
+} // namespace caffe2
diff --git a/caffe2/utils/mixed_utils_hip.h b/caffe2/utils/mixed_utils_hip.h
new file mode 100644
index 0000000000000..efbd428190800
--- /dev/null
+++ b/caffe2/utils/mixed_utils_hip.h
@@ -0,0 +1,101 @@
+// Copyright 2004-present Facebook. All Rights Reserved.
+#ifndef CAFFE2_UTILS_MIXED_UTILS_HIP_H
+#define CAFFE2_UTILS_MIXED_UTILS_HIP_H
+
+#include "caffe2/core/hip/common_hip.h"
+#include "caffe2/core/hip/context_hip.h"
+
+// define functions to allow add/mult/store operaions for input/output with
+// mixed precisions.
+namespace caffe2 {
+
+// functions that will only be triggered when there is no spcialized version
+// supported
+template <typename T, typename T2>
+inline __device__ T mixed_mult(T data1, T2 data2) {
+  return data1 * data2;
+};
+
+template <typename T, typename T2>
+inline __device__ T mixed_add(T data1, T2 data2) {
+  return data1 + data2;
+};
+
+template <typename TIN, typename TOUT>
+inline __device__ void mixed_store(TIN* data_in, TOUT* data_out) {
+  *data_out = *data_in;
+  return;
+};
+
+template <typename T>
+inline __device__ void mixed_store(T* data_in, T* data_out) {
+  *data_out = *data_in;
+  return;
+};
+
+template <>
+inline __device__ float mixed_mult(float data1, const float data2) {
+  return data1 * data2;
+}
+
+template <>
+inline __device__ float mixed_mult(float data1, const half data2) {
+  return data1 * __half2float(data2);
+}
+
+template <>
+inline __device__ float mixed_mult(float data1, float16 data2) {
+  half* data2_half = reinterpret_cast<half*>(&data2);
+  return data1 * __half2float(*data2_half);
+}
+template <>
+inline __device__ float mixed_add(float data1, const float data2) {
+  return data1 + data2;
+}
+
+template <>
+inline __device__ float mixed_add(float data1, const half data2) {
+  return data1 + __half2float(data2);
+}
+
+template <>
+inline __device__ float mixed_add(float data1, float16 data2) {
+  half* data2_half = reinterpret_cast<half*>(&data2);
+  return data1 + __half2float(*data2_half);
+}
+
+template <>
+inline __device__ void mixed_store(float* data_in, float* data_out) {
+  *data_out = *data_in;
+  return;
+}
+
+template <>
+inline __device__ void mixed_store(half* data_in, float* data_out) {
+  *data_out = __half2float(*data_in);
+  return;
+}
+
+template <>
+inline __device__ void mixed_store(float16* data_in, float* data_out) {
+  half* data_in_half = reinterpret_cast<half*>(data_in);
+  *data_out = __half2float(*data_in_half);
+  return;
+}
+
+template <>
+inline __device__ void mixed_store(float* data_in, float16* data_out) {
+  half data_in_half = __float2half(*data_in);
+  float16* data_in_float16 = reinterpret_cast<float16*>(&data_in_half);
+  *data_out = *data_in_float16;
+  return;
+}
+
+template <>
+inline __device__ void mixed_store(float* data_in, half* data_out) {
+  half data_in_half = __float2half(*data_in);
+  *data_out = data_in_half;
+  return;
+}
+} // namespace caffe2
+#endif // for CAFFE2_UTILS_MIXED_UTILS_HIP_H
diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake
index 3846ff30904d5..3365818b0de8c 100644
--- a/cmake/Dependencies.cmake
+++ b/cmake/Dependencies.cmake
@@ -448,9 +448,23 @@ if(BUILD_CAFFE2 OR BUILD_ATEN)
     message(INFO "Compiling with HIP for AMD.")
     caffe2_update_option(USE_ROCM ON)
 
-    set(Caffe2_HIP_CXX_FLAGS "-D__HIP_PLATFORM_HCC__=1")
+    set(HIP_HIPCC_FLAGS "${HIP_HIPCC_FLAGS} -fPIC")
+    set(HIP_HIPCC_FLAGS "${HIP_HIPCC_FLAGS} -D__HIP_PLATFORM_HCC__=1")
+    set(HIP_HIPCC_FLAGS "${HIP_HIPCC_FLAGS} -DCUDA_HAS_FP16=1")
+    set(HIP_HIPCC_FLAGS "${HIP_HIPCC_FLAGS} -D__HIP_NO_HALF_OPERATORS__=1")
+    set(HIP_HIPCC_FLAGS "${HIP_HIPCC_FLAGS} -D__HIP_NO_HALF_CONVERSIONS__=1")
+    set(HIP_HIPCC_FLAGS "${HIP_HIPCC_FLAGS} -Wno-macro-redefined")
+    set(HIP_HIPCC_FLAGS "${HIP_HIPCC_FLAGS} -Wno-inconsistent-missing-override")
+    set(HIP_HIPCC_FLAGS "${HIP_HIPCC_FLAGS} -Wno-exceptions")
+    set(HIP_HIPCC_FLAGS "${HIP_HIPCC_FLAGS} -Wno-shift-count-negative")
+    set(HIP_HIPCC_FLAGS "${HIP_HIPCC_FLAGS} -Wno-shift-count-overflow")
+    set(HIP_HIPCC_FLAGS "${HIP_HIPCC_FLAGS} -Wno-unused-command-line-argument")
+
     set(Caffe2_HIP_INCLUDES
-      ${hip_INCLUDE_DIRS} ${rocrand_INCLUDE_DIRS} ${hiprand_INCLUDE_DIRS} ${rocblas_INCLUDE_DIRS} ${miopen_INCLUDE_DIRS} ${Caffe2_HIP_INCLUDES} ${thrust_INCLUDE_DIRS})
+      ${hip_INCLUDE_DIRS} ${rocrand_INCLUDE_DIRS} ${hiprand_INCLUDE_DIRS} ${rocblas_INCLUDE_DIRS} ${miopen_INCLUDE_DIRS} ${thrust_INCLUDE_DIRS} $<INSTALL_INTERFACE:include> ${Caffe2_HIP_INCLUDES})
+    # This is needed for library added by hip_add_library (same for hip_add_executable)
+    hip_include_directories(${Caffe2_HIP_INCLUDES})
+
     set(Caffe2_HIP_DEPENDENCY_LIBS
       ${rocrand_LIBRARIES} ${hiprand_LIBRARIES} ${PYTORCH_HIP_HCC_LIBRARIES} ${PYTORCH_MIOPEN_LIBRARIES} ${hipblas_LIBRARIES})
     # Additional libraries required by PyTorch AMD that aren't used by Caffe2 (not in Caffe2's docker image)
diff --git a/cmake/public/LoadHIP.cmake b/cmake/public/LoadHIP.cmake
index c6b98143ddc89..55497467e2846 100644
--- a/cmake/public/LoadHIP.cmake
+++ b/cmake/public/LoadHIP.cmake
@@ -95,9 +95,9 @@ FIND_PACKAGE(HIP 1.0)
 IF(HIP_FOUND)
   set(PYTORCH_FOUND_HIP TRUE)
 
-  set(CMAKE_HIP_LINK_EXECUTABLE "${HIP_HIPCC_CMAKE_LINKER_HELPER} ${HCC_PATH} <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
-  set(CMAKE_HIP_CREATE_SHARED_LIBRARY "${HIP_HIPCC_CMAKE_LINKER_HELPER} ${HCC_PATH} <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES> -shared")
-  set(CMAKE_HIP_CREATE_SHARED_MODULE "${HIP_HIPCC_CMAKE_LINKER_HELPER} ${HCC_PATH} <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES> -shared")
+  set(CMAKE_HIP_LINK_EXECUTABLE "${HIP_HIPCC_CMAKE_LINKER_HELPER} ${HCC_PATH} <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>" )
+  set(CMAKE_HIP_CREATE_SHARED_LIBRARY "${HIP_HIPCC_CMAKE_LINKER_HELPER} ${HCC_PATH} <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES> -shared" )
+  set(CMAKE_HIP_CREATE_SHARED_MODULE "${HIP_HIPCC_CMAKE_LINKER_HELPER} ${HCC_PATH} <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES> -shared" )
 
   set(rocrand_DIR ${ROCRAND_PATH}/lib/cmake/rocrand)
   set(hiprand_DIR ${HIPRAND_PATH}/lib/cmake/hiprand)

From 95fc5555c873f025735a9bcef2599a59c19c8335 Mon Sep 17 00:00:00 2001
From: Lu Fang <30275821+houseroad@users.noreply.github.com>
Date: Wed, 13 Jun 2018 21:32:50 +0800
Subject: [PATCH 110/118] Enable some reduce operators' ONNX backend tests
 (#8418)

---
 caffe2/python/onnx/tests/onnx_backend_test.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/caffe2/python/onnx/tests/onnx_backend_test.py b/caffe2/python/onnx/tests/onnx_backend_test.py
index 4c9c3ea848fba..ce11767cde87c 100644
--- a/caffe2/python/onnx/tests/onnx_backend_test.py
+++ b/caffe2/python/onnx/tests/onnx_backend_test.py
@@ -25,11 +25,8 @@
                      '|test_reduce_l1.*'  # Does not support ReduceL1.
                      '|test_reduce_l2.*'  # Does not support ReduceL2.
                      '|test_reduce_log_sum.*'  # Does not support ReduceLogSum.
-                     '|test_reduce_max.*'  # Does not support ReduceMax.
-                     '|test_reduce_min.*'  # Does not support ReduceMin.
-                     '|test_reduce_mean_cuda.*'  # Does not support ReduceMean CUDA.
                      '|test_reduce_prod.*'  # Does not support ReduceProd.
-                     '|test_reduce_sum.*'  # Does not support ReduceSum and ReduceSumSquare
+                     '|test_reduce_sum_square.*'  # Does not support ReduceSumSquare
                      '|test_tile.*'  # Tile's Caffe2 implementation needs some tweak
                      '|test_lstm.*'  # Seems LSTM case has some problem
                      '|test_simple_rnn.*'  # Seems simple RNN case has some problem

From 8f61edced4d7987c034b15df71e827aed44d24cb Mon Sep 17 00:00:00 2001
From: Yangqing Jia <jiayq84@gmail.com>
Date: Wed, 13 Jun 2018 06:33:05 -0700
Subject: [PATCH 111/118] fix old comment to point to the right file (#8416)

---
 caffe2/proto/caffe2.proto | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/caffe2/proto/caffe2.proto b/caffe2/proto/caffe2.proto
index cc41d991b4364..6d001436739f6 100644
--- a/caffe2/proto/caffe2.proto
+++ b/caffe2/proto/caffe2.proto
@@ -109,7 +109,7 @@ message Argument {
 
 // DeviceType that Caffe2 currently supports.
 // Note: if you add a device type, make sure you add the corresponding device
-// line in core/blob_serialization.cc.
+// line in the DeviceTypeName() function in caffe2/utils/proto_utils.cc.
 enum DeviceType {
   CPU = 0;                    // In default, we will use CPU.
   CUDA = 1;                   // CUDA.

From 8a807c22725ab1e2a2cea6d105e43915ff230382 Mon Sep 17 00:00:00 2001
From: "Edward Z. Yang" <ezyang@mit.edu>
Date: Wed, 13 Jun 2018 10:53:56 -0400
Subject: [PATCH 112/118] Stop pinning nccl version. (#8421)

Signed-off-by: Edward Z. Yang <ezyang@fb.com>
---
 docker/caffe2/jenkins/common/install_nccl.sh | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/docker/caffe2/jenkins/common/install_nccl.sh b/docker/caffe2/jenkins/common/install_nccl.sh
index 3488eabc41326..5594c317ee9bc 100755
--- a/docker/caffe2/jenkins/common/install_nccl.sh
+++ b/docker/caffe2/jenkins/common/install_nccl.sh
@@ -30,9 +30,6 @@ if [ -n "$NCCL_UBUNTU_VER" ]; then
   apt-get install -y wget
   dpkg -i "${NCCL_DEB}"
 
-  # On March 8, 2018 Nvidia began recommending version 2.1.15
-  NCCL_LIB_VERSION="2.1.15-1+cuda${CUDA_VERSION:0:3}"
-
   apt update
-  apt install -y libnccl2=$NCCL_LIB_VERSION libnccl-dev=$NCCL_LIB_VERSION
+  apt install -y libnccl2 libnccl-dev
 fi

From 7f5f5d01a5a0fd3aca8cd557638d2c6a543a3747 Mon Sep 17 00:00:00 2001
From: Vishwak Srinivasan <cs15btech11043@iith.ac.in>
Date: Wed, 13 Jun 2018 12:27:58 -0400
Subject: [PATCH 113/118] Expose logsumexp docs and mark log_sum_exp in
 distributions for internal use (#8428)

---
 docs/source/tensors.rst                    | 1 +
 docs/source/torch.rst                      | 1 +
 torch/_torch_docs.py                       | 3 ++-
 torch/distributions/categorical.py         | 4 ++--
 torch/distributions/relaxed_categorical.py | 6 +++---
 torch/distributions/utils.py               | 2 +-
 6 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/docs/source/tensors.rst b/docs/source/tensors.rst
index 0b434bd412182..2562832a887cd 100644
--- a/docs/source/tensors.rst
+++ b/docs/source/tensors.rst
@@ -271,6 +271,7 @@ view of a storage and defines numeric operations on it.
    .. automethod:: log2
    .. automethod:: log2_
    .. automethod:: log_normal_
+   .. automethod:: logsumexp
    .. automethod:: long
    .. automethod:: lt
    .. automethod:: lt_
diff --git a/docs/source/torch.rst b/docs/source/torch.rst
index f90596505f291..3c6e6aa367d89 100644
--- a/docs/source/torch.rst
+++ b/docs/source/torch.rst
@@ -204,6 +204,7 @@ Reduction Ops
 .. autofunction:: cumprod
 .. autofunction:: cumsum
 .. autofunction:: dist
+.. autofunction:: logsumexp
 .. autofunction:: mean
 .. autofunction:: median
 .. autofunction:: mode
diff --git a/torch/_torch_docs.py b/torch/_torch_docs.py
index 500b073453fff..c6198dadb93df 100644
--- a/torch/_torch_docs.py
+++ b/torch/_torch_docs.py
@@ -2198,7 +2198,8 @@ def parse_kwargs(desc):
 
 For summation index :math:`j` given by `dim` and other indices :math:`i`, the result is
 
-           :math:`\text{logsumexp}(x)_{i} = \log \sum_j \exp(x_ij).`
+    .. math::
+        \text{logsumexp}(x)_{i} = \log \sum_j \exp(x_{ij})
 
 If :attr:`keepdim` is ``True``, the output tensor is of the same size
 as :attr:`input` except in the dimension :attr:`dim` where it is of size 1.
diff --git a/torch/distributions/categorical.py b/torch/distributions/categorical.py
index 480987961ed56..cea2474e58323 100644
--- a/torch/distributions/categorical.py
+++ b/torch/distributions/categorical.py
@@ -1,7 +1,7 @@
 import torch
 from torch.distributions import constraints
 from torch.distributions.distribution import Distribution
-from torch.distributions.utils import probs_to_logits, logits_to_probs, log_sum_exp, lazy_property, broadcast_all
+from torch.distributions.utils import probs_to_logits, logits_to_probs, _log_sum_exp, lazy_property, broadcast_all
 
 
 class Categorical(Distribution):
@@ -44,7 +44,7 @@ def __init__(self, probs=None, logits=None, validate_args=None):
         if probs is not None:
             self.probs = probs / probs.sum(-1, keepdim=True)
         else:
-            self.logits = logits - log_sum_exp(logits)
+            self.logits = logits - _log_sum_exp(logits)
         self._param = self.probs if probs is not None else self.logits
         self._num_events = self._param.size()[-1]
         batch_shape = self._param.size()[:-1] if self._param.ndimension() > 1 else torch.Size()
diff --git a/torch/distributions/relaxed_categorical.py b/torch/distributions/relaxed_categorical.py
index 0e64e10eb277e..bf1dfc7d822c3 100644
--- a/torch/distributions/relaxed_categorical.py
+++ b/torch/distributions/relaxed_categorical.py
@@ -1,7 +1,7 @@
 import torch
 from torch.distributions import constraints
 from torch.distributions.categorical import Categorical
-from torch.distributions.utils import clamp_probs, broadcast_all, log_sum_exp
+from torch.distributions.utils import clamp_probs, broadcast_all, _log_sum_exp
 from torch.distributions.distribution import Distribution
 from torch.distributions.transformed_distribution import TransformedDistribution
 from torch.distributions.transforms import ExpTransform
@@ -58,7 +58,7 @@ def rsample(self, sample_shape=torch.Size()):
         uniforms = clamp_probs(self.logits.new(self._extended_shape(sample_shape)).uniform_())
         gumbels = -((-(uniforms.log())).log())
         scores = (self.logits + gumbels) / self.temperature
-        return scores - log_sum_exp(scores)
+        return scores - _log_sum_exp(scores)
 
     def log_prob(self, value):
         K = self._categorical._num_events
@@ -68,7 +68,7 @@ def log_prob(self, value):
         log_scale = (self.temperature.new(self.temperature.shape).fill_(K).lgamma() -
                      self.temperature.log().mul(-(K - 1)))
         score = logits - value.mul(self.temperature)
-        score = (score - log_sum_exp(score)).sum(-1)
+        score = (score - _log_sum_exp(score)).sum(-1)
         return score + log_scale
 
 
diff --git a/torch/distributions/utils.py b/torch/distributions/utils.py
index ef1a78f864736..fab614578849b 100644
--- a/torch/distributions/utils.py
+++ b/torch/distributions/utils.py
@@ -96,7 +96,7 @@ def _sum_rightmost(value, dim):
     return value.reshape(required_shape).sum(-1)
 
 
-def log_sum_exp(tensor, keepdim=True):
+def _log_sum_exp(tensor, keepdim=True):
     r"""
     Numerically stable implementation for the `LogSumExp` operation. The
     summing is done along the last dimension.

From 8c287495b0637745a337c2ce1eb201bf34880843 Mon Sep 17 00:00:00 2001
From: Lu Fang <30275821+houseroad@users.noreply.github.com>
Date: Thu, 14 Jun 2018 01:15:56 +0800
Subject: [PATCH 114/118] Enable some of the ONNX backend test on broadcasting
 (#8423)

* Enable some of the ONNX backend test on broadcasting

* enable gemm broadcast
---
 caffe2/python/onnx/tests/onnx_backend_test.py | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/caffe2/python/onnx/tests/onnx_backend_test.py b/caffe2/python/onnx/tests/onnx_backend_test.py
index ce11767cde87c..24d6bc83878de 100644
--- a/caffe2/python/onnx/tests/onnx_backend_test.py
+++ b/caffe2/python/onnx/tests/onnx_backend_test.py
@@ -48,18 +48,7 @@
                      '|test_lrn_default_cuda)')
 
 # Temporarily skip some ONNX backend tests with broadcasting.
-backend_test.exclude('(test_xor_bcast'
-                     '|test_or_bcast'
-                     '|test_and_bcast'
-                     '|test_greater_bcast'
-                     '|test_equal_bcast'
-                     '|test_less_bcast'
-                     '|test_add_bcast'
-                     '|test_sub_bcast'
-                     '|test_mul_bcast'
-                     '|test_div_bcast'
-                     '|test_pow_bcast'
-                     '|test_gemm_broadcast'
+backend_test.exclude('(test_pow_bcast'
                      ')')
 
 # Skip vgg to speed up CI

From a83811568b93929a58fd140ef4ce5ef7845098df Mon Sep 17 00:00:00 2001
From: Orion Reblitz-Richardson <orionr@gmail.com>
Date: Wed, 13 Jun 2018 10:25:32 -0700
Subject: [PATCH 115/118] Expose proto utils and ONNX (#8073)

* Expose proto utils and ONNX from PyTorch libcaffe2.so

* Try to use protobuf from _C.so

* Fix ONNX proto header include

* Adjust order of imports for ONNX until nanopb goes away

* Set and use ONNX_NAMESPACE for PyTorch builds

* Show protobuf summary for all builds

* Add ONNX_NAMESPACE for cpp_build

* Statically link libprotobuf.a into libtorch.so

* Set ONNX_NAMESPACE on Windows build

* Move core/dispatch up as well

* Add /MD flag for Windows build of _C

* Potential Windows fix for ONNX and protobuf

* Add direct linkage from _C to ONNX on Windows

* Only include protobuf wrapper for PyTorch

* Pass extra_compile_args to _nvrtc ext build

* Remove installation of .a files
---
 CMakeLists.txt                          |  4 +-
 caffe2/CMakeLists.txt                   | 84 +++++++++++++------------
 caffe2/utils/CMakeLists.txt             | 34 ++++++----
 caffe2/utils/proto_utils.cc             | 33 ----------
 caffe2/utils/proto_utils.h              |  5 +-
 caffe2/utils/proto_wrap.cc              | 41 ++++++++++++
 caffe2/utils/proto_wrap.h               | 12 ++++
 cmake/Dependencies.cmake                | 43 ++++++-------
 cmake/ProtoBuf.cmake                    |  2 +-
 cmake/ProtoBufPatch.cmake               |  2 +-
 cmake/Summary.cmake                     | 16 ++---
 setup.py                                | 58 ++++++++++++-----
 tools/build_pytorch_libs.bat            |  1 +
 tools/build_pytorch_libs.sh             |  1 +
 tools/cpp_build/build_caffe2.sh         |  1 +
 tools/cpp_build/build_common.sh         |  5 ++
 tools/cpp_build/build_libtorch.sh       |  1 +
 tools/cpp_build/libtorch/CMakeLists.txt |  9 ++-
 torch/csrc/jit/test_jit.cpp             |  8 +++
 19 files changed, 217 insertions(+), 143 deletions(-)
 create mode 100644 caffe2/utils/proto_wrap.cc
 create mode 100644 caffe2/utils/proto_wrap.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2b96e2eec7362..6500c23d5662d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -111,9 +111,7 @@ option(USE_SYSTEM_NCCL "Use system-wide NCCL" OFF)
 option(USE_NERVANA_GPU "Use Nervana GPU backend" OFF)
 option(USE_NNAPI "Use NNAPI" OFF)
 option(USE_NNPACK "Use NNPACK" ON)
-cmake_dependent_option(
-    USE_NUMA "Use NUMA (only available on Linux)" ON
-    "BUILD_CAFFE2" OFF)
+option(USE_NUMA "Use NUMA (only available on Linux)" ON)
 cmake_dependent_option(
     USE_NVRTC "Use NVRTC. Only available if USE_CUDA is on." OFF
     "USE_CUDA" OFF)
diff --git a/caffe2/CMakeLists.txt b/caffe2/CMakeLists.txt
index fa224bb2bab54..f453516087bdc 100644
--- a/caffe2/CMakeLists.txt
+++ b/caffe2/CMakeLists.txt
@@ -3,6 +3,9 @@ include(../cmake/Codegen.cmake)
 
 # ---[ Declare source file lists
 
+# ---[ Shared build
+add_subdirectory(utils)
+
 # ---[ ATen build
 if(BUILD_ATEN)
   set(__caffe2_CMAKE_POSITION_INDEPENDENT_CODE ${CMAKE_POSITION_INDEPENDENT_CODE})
@@ -55,9 +58,8 @@ if(BUILD_CAFFE2)
   # Note: the folders that are being commented out have not been properly
   # addressed yet.
   add_subdirectory(proto)
-  add_subdirectory(core)
-  add_subdirectory(utils)
   add_subdirectory(contrib)
+  add_subdirectory(core)
   add_subdirectory(core/nomnigraph)
   add_subdirectory(core/dispatch)
   if (USE_NVRTC)
@@ -149,51 +151,53 @@ if (FALSE)
 endif()
 
 # ---[ List of libraries to link with
-if(BUILD_CAFFE2)
+if (BUILD_CAFFE2)
   add_library(caffe2_protos STATIC $<TARGET_OBJECTS:Caffe_PROTO> $<TARGET_OBJECTS:Caffe2_PROTO>)
   add_dependencies(caffe2_protos Caffe_PROTO Caffe2_PROTO)
-  # If we are going to link protobuf locally inside caffe2 libraries, what we will do is
-  # to create a helper static library that always contains libprotobuf source files, and
-  # link the caffe2 related dependent libraries to it.
-  target_include_directories(caffe2_protos INTERFACE $<INSTALL_INTERFACE:include>)
-  # Reason for this public dependency is as follows:
-  # (1) Strictly speaking, we should not expose any Protobuf related functions. We should
-  #     only use function interfaces wrapped with our own public API, and link protobuf
-  #     locally.
-  # (2) However, currently across the Caffe2 codebase, we have extensive use of protobuf
-  #     functionalities. For example, not only libcaffe2.so uses it, but also other
-  #     binaries such as python extensions etc. As a result, we will have to have a
-  #     transitive dependency to libprotobuf.
-  #
-  # Good thing is that, if we specify CAFFE2_LINK_LOCAL_PROTOBUF, then we do not need to
-  # separately deploy protobuf binaries - libcaffe2.so will contain all functionalities
-  # one needs. One can verify this via ldd.
-  #
-  # TODO item in the future includes:
-  # (1) Enable using lite protobuf
-  # (2) Properly define public API that do not directly depend on protobuf itself.
-  # (3) Expose the libprotobuf.a file for dependent libraries to link to.
-  #
-  # What it means for users/developers?
-  # (1) Users: nothing affecting the users, other than the fact that CAFFE2_LINK_LOCAL_PROTOBUF
-  #     avoids the need to deploy protobuf.
-  # (2) Developers: if one simply uses core caffe2 functionality without using protobuf,
-  #     nothing changes. If one has a dependent library that uses protobuf, then one needs to
-  #     have the right protobuf version as well as linking to libprotobuf.a.
-  target_link_libraries(caffe2_protos PUBLIC protobuf::libprotobuf)
+else()
+  # Do not include caffe2 or caffe protos, but rather have it only be
+  # a library to attach local protobuf.
+  add_library(caffe2_protos STATIC utils/dummy.cpp)
 endif()
+# If we are going to link protobuf locally inside caffe2 libraries, what we will do is
+# to create a helper static library that always contains libprotobuf source files, and
+# link the caffe2 related dependent libraries to it.
+target_include_directories(caffe2_protos INTERFACE $<INSTALL_INTERFACE:include>)
+# Reason for this public dependency is as follows:
+# (1) Strictly speaking, we should not expose any Protobuf related functions. We should
+#     only use function interfaces wrapped with our own public API, and link protobuf
+#     locally.
+# (2) However, currently across the Caffe2 codebase, we have extensive use of protobuf
+#     functionalities. For example, not only libcaffe2.so uses it, but also other
+#     binaries such as python extensions etc. As a result, we will have to have a
+#     transitive dependency to libprotobuf.
+#
+# Good thing is that, if we specify CAFFE2_LINK_LOCAL_PROTOBUF, then we do not need to
+# separately deploy protobuf binaries - libcaffe2.so will contain all functionalities
+# one needs. One can verify this via ldd.
+#
+# TODO item in the future includes:
+# (1) Enable using lite protobuf
+# (2) Properly define public API that do not directly depend on protobuf itself.
+# (3) Expose the libprotobuf.a file for dependent libraries to link to.
+#
+# What it means for users/developers?
+# (1) Users: nothing affecting the users, other than the fact that CAFFE2_LINK_LOCAL_PROTOBUF
+#     avoids the need to deploy protobuf.
+# (2) Developers: if one simply uses core caffe2 functionality without using protobuf,
+#     nothing changes. If one has a dependent library that uses protobuf, then one needs to
+#     have the right protobuf version as well as linking to libprotobuf.a.
+target_link_libraries(caffe2_protos PUBLIC protobuf::libprotobuf)
 
 # Compile exposed libraries.
 list(APPEND Caffe2_CPU_SRCs $<TARGET_OBJECTS:c10>)
 add_library(caffe2 ${Caffe2_CPU_SRCS})
-if (BUILD_CAFFE2)
-  caffe2_interface_library(caffe2_protos caffe2_protos_whole)
-  target_link_libraries(caffe2 PRIVATE caffe2_protos_whole)
-  if (${CAFFE2_LINK_LOCAL_PROTOBUF})
-    target_link_libraries(caffe2 INTERFACE protobuf::libprotobuf)
-  else()
-    target_link_libraries(caffe2 PUBLIC protobuf::libprotobuf)
-  endif()
+caffe2_interface_library(caffe2_protos caffe2_protos_whole)
+target_link_libraries(caffe2 PRIVATE caffe2_protos_whole)
+if (${CAFFE2_LINK_LOCAL_PROTOBUF})
+  target_link_libraries(caffe2 INTERFACE protobuf::libprotobuf)
+else()
+  target_link_libraries(caffe2 PUBLIC protobuf::libprotobuf)
 endif()
 target_link_libraries(caffe2 PUBLIC ${Caffe2_PUBLIC_DEPENDENCY_LIBS})
 target_link_libraries(caffe2 PRIVATE ${Caffe2_DEPENDENCY_LIBS})
diff --git a/caffe2/utils/CMakeLists.txt b/caffe2/utils/CMakeLists.txt
index 93e12839e9231..5213baafce0e7 100644
--- a/caffe2/utils/CMakeLists.txt
+++ b/caffe2/utils/CMakeLists.txt
@@ -1,16 +1,24 @@
-set(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS}
-        utils/proto_utils.cc
-        utils/murmur_hash3.cc
-        utils/smart_tensor_printer.cc
-        utils/signal_handler.cc
-        utils/string_utils.cc
-        utils/threadpool/ThreadPool.cc
-        utils/cpuid.cc
-        utils/bench_utils.cc
-        utils/math_cpu.cc
-        utils/math_utils.cc
-        utils/thread_name.cc
-        )
+list(APPEND Caffe2_CPU_SRCS
+  utils/proto_wrap.cc)
+
+# ---[ only support the above when full caffe2 isn't built
+if (NOT BUILD_CAFFE2)
+  set(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS} PARENT_SCOPE)
+  set(Caffe2_GPU_SRCS ${Caffe2_GPU_SRCS} PARENT_SCOPE)
+  return()
+endif()
+
+list(APPEND Caffe2_CPU_SRCS
+  utils/proto_utils.cc
+  utils/murmur_hash3.cc
+  utils/smart_tensor_printer.cc
+  utils/signal_handler.cc
+  utils/string_utils.cc
+  utils/threadpool/ThreadPool.cc
+  utils/cpuid.cc
+  utils/bench_utils.cc
+  utils/math_cpu.cc
+  utils/math_utils.cc)
 
 # ---[ threadpool/pthreadpool* is a local modification of the NNPACK
 # pthreadpool with a very similar interface. Neither NNPACK, nor this
diff --git a/caffe2/utils/proto_utils.cc b/caffe2/utils/proto_utils.cc
index 32fc074aa80ee..d39eb3f4e3be0 100644
--- a/caffe2/utils/proto_utils.cc
+++ b/caffe2/utils/proto_utils.cc
@@ -17,41 +17,8 @@
 
 using ::google::protobuf::MessageLite;
 
-namespace caffe {
-
-// Caffe wrapper functions for protobuf's GetEmptyStringAlreadyInited() function
-// used to avoid duplicated global variable in the case when protobuf
-// is built with hidden visibility.
-const ::std::string& GetEmptyStringAlreadyInited() {
-  return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
-}
-
-}  // namespace caffe
-
-namespace ONNX_NAMESPACE {
-
-// ONNX wrapper functions for protobuf's GetEmptyStringAlreadyInited() function
-// used to avoid duplicated global variable in the case when protobuf
-// is built with hidden visibility.
-const ::std::string& GetEmptyStringAlreadyInited() {
-  return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
-}
-
-}  // namespace ONNX_NAMESPACE
-
 namespace caffe2 {
 
-// Caffe2 wrapper functions for protobuf's GetEmptyStringAlreadyInited() function
-// used to avoid duplicated global variable in the case when protobuf
-// is built with hidden visibility.
-const ::std::string& GetEmptyStringAlreadyInited() {
-  return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
-}
-
-void ShutdownProtobufLibrary() {
-  ::google::protobuf::ShutdownProtobufLibrary();
-}
-
 std::string DeviceTypeName(const int32_t& d) {
   switch (d) {
     case CPU:
diff --git a/caffe2/utils/proto_utils.h b/caffe2/utils/proto_utils.h
index 127d660abd2c0..85fbc416940b3 100644
--- a/caffe2/utils/proto_utils.h
+++ b/caffe2/utils/proto_utils.h
@@ -8,6 +8,7 @@
 #endif  // !CAFFE2_USE_LITE_PROTO
 
 #include "caffe2/core/logging.h"
+#include "caffe2/utils/proto_wrap.h"
 #include "caffe2/proto/caffe2.pb.h"
 
 namespace caffe2 {
@@ -15,10 +16,6 @@ namespace caffe2 {
 using std::string;
 using ::google::protobuf::MessageLite;
 
-// A wrapper function to shut down protobuf library (this is needed in ASAN
-// testing and valgrind cases to avoid protobuf appearing to "leak" memory).
-void ShutdownProtobufLibrary();
-
 // A wrapper function to return device name string for use in blob serialization
 // / deserialization. This should have one to one correspondence with
 // caffe2/proto/caffe2.proto: enum DeviceType.
diff --git a/caffe2/utils/proto_wrap.cc b/caffe2/utils/proto_wrap.cc
new file mode 100644
index 0000000000000..c0a85af480740
--- /dev/null
+++ b/caffe2/utils/proto_wrap.cc
@@ -0,0 +1,41 @@
+#include "caffe2/utils/proto_wrap.h"
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/generated_message_util.h>
+
+namespace caffe {
+
+// Caffe wrapper functions for protobuf's GetEmptyStringAlreadyInited() function
+// used to avoid duplicated global variable in the case when protobuf
+// is built with hidden visibility.
+const ::std::string& GetEmptyStringAlreadyInited() {
+  return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
+}
+
+}  // namespace caffe
+
+namespace ONNX_NAMESPACE {
+
+// ONNX wrapper functions for protobuf's GetEmptyStringAlreadyInited() function
+// used to avoid duplicated global variable in the case when protobuf
+// is built with hidden visibility.
+const ::std::string& GetEmptyStringAlreadyInited() {
+  return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
+}
+
+}  // namespace ONNX_NAMESPACE
+
+namespace caffe2 {
+
+// Caffe2 wrapper functions for protobuf's GetEmptyStringAlreadyInited() function
+// used to avoid duplicated global variable in the case when protobuf
+// is built with hidden visibility.
+const ::std::string& GetEmptyStringAlreadyInited() {
+  return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
+}
+
+void ShutdownProtobufLibrary() {
+  ::google::protobuf::ShutdownProtobufLibrary();
+}
+
+}  // namespace caffe2
diff --git a/caffe2/utils/proto_wrap.h b/caffe2/utils/proto_wrap.h
new file mode 100644
index 0000000000000..853ca4ecce40d
--- /dev/null
+++ b/caffe2/utils/proto_wrap.h
@@ -0,0 +1,12 @@
+#ifndef CAFFE2_UTILS_PROTO_WRAP_H_
+#define CAFFE2_UTILS_PROTO_WRAP_H_
+
+namespace caffe2 {
+
+// A wrapper function to shut down protobuf library (this is needed in ASAN
+// testing and valgrind cases to avoid protobuf appearing to "leak" memory).
+void ShutdownProtobufLibrary();
+
+} // namespace caffe2
+
+#endif // CAFFE2_UTILS_PROTO_WRAP_H_
diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake
index 3365818b0de8c..88b9305b29b44 100644
--- a/cmake/Dependencies.cmake
+++ b/cmake/Dependencies.cmake
@@ -15,7 +15,7 @@ if(BUILD_CAFFE2)
 endif()
 
 # ---[ protobuf
-if(BUILD_CAFFE2)
+if(CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
   if(USE_LITE_PROTO)
     set(CAFFE2_USE_LITE_PROTO 1)
   endif()
@@ -303,18 +303,16 @@ if(USE_FFMPEG)
 endif()
 
 # ---[ EIGEN
-if(BUILD_CAFFE2)
-  # Due to license considerations, we will only use the MPL2 parts of Eigen.
-  set(EIGEN_MPL2_ONLY 1)
-  find_package(Eigen3)
-  if(EIGEN3_FOUND)
-    message(STATUS "Found system Eigen at " ${EIGEN3_INCLUDE_DIR})
-  else()
-    message(STATUS "Did not find system Eigen. Using third party subdirectory.")
-    set(EIGEN3_INCLUDE_DIR ${CMAKE_CURRENT_LIST_DIR}/../third_party/eigen)
-  endif()
-  include_directories(SYSTEM ${EIGEN3_INCLUDE_DIR})
+# Due to license considerations, we will only use the MPL2 parts of Eigen.
+set(EIGEN_MPL2_ONLY 1)
+find_package(Eigen3)
+if(EIGEN3_FOUND)
+  message(STATUS "Found system Eigen at " ${EIGEN3_INCLUDE_DIR})
+else()
+  message(STATUS "Did not find system Eigen. Using third party subdirectory.")
+  set(EIGEN3_INCLUDE_DIR ${CMAKE_CURRENT_LIST_DIR}/../third_party/eigen)
 endif()
+include_directories(SYSTEM ${EIGEN3_INCLUDE_DIR})
 
 # ---[ Python + Numpy
 if(BUILD_PYTHON)
@@ -516,14 +514,12 @@ if(USE_NCCL)
 endif()
 
 # ---[ CUB
-if(BUILD_CAFFE2)
-  if(USE_CUDA)
-    find_package(CUB)
-    if(CUB_FOUND)
-      include_directories(SYSTEM ${CUB_INCLUDE_DIRS})
-    else()
-      include_directories(SYSTEM ${CMAKE_CURRENT_LIST_DIR}/../third_party/cub)
-    endif()
+if(USE_CUDA)
+  find_package(CUB)
+  if(CUB_FOUND)
+    include_directories(SYSTEM ${CUB_INCLUDE_DIRS})
+  else()
+    include_directories(SYSTEM ${CMAKE_CURRENT_LIST_DIR}/../third_party/cub)
   endif()
 endif()
 
@@ -704,9 +700,10 @@ if (CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)
   # We will build onnx as static libs and embed it directly into the binary.
   set(BUILD_SHARED_LIBS OFF)
   set(ONNX_USE_MSVC_STATIC_RUNTIME ${CAFFE2_USE_MSVC_STATIC_RUNTIME})
-  # Do not do post-processing if caffe2 is not included in the build,
-  # otherwise the caffe2 protobuf symbols will not be found
-  if (BUILD_CAFFE2 AND CAFFE2_LINK_LOCAL_PROTOBUF)
+  # If linking local protobuf, make sure ONNX has the same protobuf
+  # patches as Caffe2 and Caffe proto. This forces some functions to
+  # not be inline and instead route back to the statically-linked protobuf.
+  if (CAFFE2_LINK_LOCAL_PROTOBUF)
     set(ONNX_PROTO_POST_BUILD_SCRIPT ${PROJECT_SOURCE_DIR}/cmake/ProtoBufPatch.cmake)
   endif()
   add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/../third_party/onnx)
diff --git a/cmake/ProtoBuf.cmake b/cmake/ProtoBuf.cmake
index 8e287336e7d53..c270471e83c72 100644
--- a/cmake/ProtoBuf.cmake
+++ b/cmake/ProtoBuf.cmake
@@ -181,7 +181,7 @@ function(caffe2_protobuf_generate_cpp_py srcs_var hdrs_var python_var)
 
         # If we remove all reference to these pb.h files from external
         # libraries and binaries this rewrite can be removed.
-        COMMAND ${CMAKE_COMMAND} -DFILENAME=${CMAKE_CURRENT_BINARY_DIR}/${fil_we}.pb.h -DNAMESPACES=caffe\;caffe2 -P ${PROJECT_SOURCE_DIR}/cmake/ProtoBufPatch.cmake
+        COMMAND ${CMAKE_COMMAND} -DFILENAME=${CMAKE_CURRENT_BINARY_DIR}/${fil_we}.pb.h -DNAMESPACES=caffe\;caffe2\;onnx -P ${PROJECT_SOURCE_DIR}/cmake/ProtoBufPatch.cmake
 
         DEPENDS ${CAFFE2_PROTOC_EXECUTABLE} ${abs_fil}
         COMMENT "Running C++/Python protocol buffer compiler on ${fil}" VERBATIM )
diff --git a/cmake/ProtoBufPatch.cmake b/cmake/ProtoBufPatch.cmake
index 656a227a568af..18ac37b00e749 100644
--- a/cmake/ProtoBufPatch.cmake
+++ b/cmake/ProtoBufPatch.cmake
@@ -1,4 +1,4 @@
-# CMake file to replace the string contents in Caffe and Caffe2 proto.
+# CMake file to replace the string contents in ONNX, Caffe, and Caffe2 proto.
 # Usage example:
 #   cmake -DFILENAME=caffe2.pb.h -P ProtoBufPatch.cmake
 
diff --git a/cmake/Summary.cmake b/cmake/Summary.cmake
index 9f5c9ed739bdf..5472ba5e80aba 100644
--- a/cmake/Summary.cmake
+++ b/cmake/Summary.cmake
@@ -21,15 +21,15 @@ function (caffe2_print_configuration_summary)
   message(STATUS "  BUILD_CAFFE2          : ${BUILD_CAFFE2}")
   message(STATUS "  BUILD_ATEN            : ${BUILD_ATEN}")
   message(STATUS "  BUILD_BINARY          : ${BUILD_BINARY}")
+  message(STATUS "  BUILD_CUSTOM_PROTOBUF : ${BUILD_CUSTOM_PROTOBUF}")
+  if (${CAFFE2_LINK_LOCAL_PROTOBUF})
+    message(STATUS "    Link local protobuf : ${CAFFE2_LINK_LOCAL_PROTOBUF}")
+  else()
+    message(STATUS "    Protobuf compiler   : ${PROTOBUF_PROTOC_EXECUTABLE}")
+    message(STATUS "    Protobuf includes   : ${PROTOBUF_INCLUDE_DIRS}")
+    message(STATUS "    Protobuf libraries  : ${PROTOBUF_LIBRARIES}")
+  endif()
   if (${BUILD_CAFFE2})
-    message(STATUS "  BUILD_CUSTOM_PROTOBUF : ${BUILD_CUSTOM_PROTOBUF}")
-    if (${CAFFE2_LINK_LOCAL_PROTOBUF})
-      message(STATUS "    Link local protobuf : ${CAFFE2_LINK_LOCAL_PROTOBUF}")
-    else()
-      message(STATUS "    Protobuf compiler   : ${PROTOBUF_PROTOC_EXECUTABLE}")
-      message(STATUS "    Protobuf includes   : ${PROTOBUF_INCLUDE_DIRS}")
-      message(STATUS "    Protobuf libraries  : ${PROTOBUF_LIBRARIES}")
-    endif()
     message(STATUS "  BUILD_DOCS            : ${BUILD_DOCS}")
   endif()
   message(STATUS "  BUILD_PYTHON          : ${BUILD_PYTHON}")
diff --git a/setup.py b/setup.py
index 92356404723b8..91d65a635fbc7 100644
--- a/setup.py
+++ b/setup.py
@@ -52,6 +52,10 @@
 #     specify which CUDA architectures to build for.
 #     ie `TORCH_CUDA_ARCH_LIST="6.0;7.0"`
 #
+#   ONNX_NAMESPACE
+#     specify a namespace for ONNX built here rather than the hard-coded
+#     one in this file; needed to build with other frameworks that share ONNX.
+#
 # Environment variables we respect (these environment variables are
 # conventional and are often understood/set by other software.)
 #
@@ -136,6 +140,10 @@
 if max_jobs is not None:
     NUM_JOBS = min(NUM_JOBS, int(max_jobs))
 
+ONNX_NAMESPACE = os.getenv("ONNX_NAMESPACE")
+if not ONNX_NAMESPACE:
+    ONNX_NAMESPACE = "onnx_torch"
+
 # Ninja
 try:
     import ninja
@@ -277,6 +285,7 @@ def build_libs(libs):
     my_env = os.environ.copy()
     my_env["PYTORCH_PYTHON"] = sys.executable
     my_env["NUM_JOBS"] = str(NUM_JOBS)
+    my_env["ONNX_NAMESPACE"] = ONNX_NAMESPACE
     if not IS_WINDOWS:
         if WITH_NINJA:
             my_env["CMAKE_GENERATOR"] = '-GNinja'
@@ -330,6 +339,7 @@ def check_file(f):
         check_file(os.path.join(third_party_path, 'cpuinfo', 'CMakeLists.txt'))
         check_file(os.path.join(third_party_path, 'tbb', 'Makefile'))
         check_file(os.path.join(third_party_path, 'catch', 'CMakeLists.txt'))
+        check_file(os.path.join(third_party_path, 'onnx', 'CMakeLists.txt'))
 
         check_pydep('yaml', 'pyyaml')
         check_pydep('typing', 'typing')
@@ -577,23 +587,29 @@ def run(self):
 
 include_dirs = []
 library_dirs = []
-extra_link_args = []
 
 if IS_WINDOWS:
-    extra_compile_args = ['/Z7', '/EHa', '/DNOMINMAX', '/wd4267', '/wd4251', '/wd4522',
-                          '/wd4522', '/wd4838', '/wd4305', '/wd4244', '/wd4190',
-                          '/wd4101', '/wd4996', '/wd4275'
-                          # /Z7 turns on symbolic debugging information in .obj files
-                          # /EHa is about native C++ catch support for asynchronous
-                          # structured exception handling (SEH)
-                          # /DNOMINMAX removes builtin min/max functions
-                          # /wdXXXX disables warning no. XXXX
-                          ]
+    # /NODEFAULTLIB makes sure we only link to DLL runtime
+    # and matches the flags set for protobuf and ONNX
+    extra_link_args = ['/NODEFAULTLIB:LIBCMT.LIB']
+    # /MD links against DLL runtime
+    # and matches the flags set for protobuf and ONNX
+    # /Z7 turns on symbolic debugging information in .obj files
+    # /EHa is about native C++ catch support for asynchronous
+    # structured exception handling (SEH)
+    # /DNOMINMAX removes builtin min/max functions
+    # /wdXXXX disables warning no. XXXX
+    extra_compile_args = ['/MD', '/Z7',
+                          '/EHa', '/DNOMINMAX',
+                          '/wd4267', '/wd4251', '/wd4522', '/wd4522', '/wd4838',
+                          '/wd4305', '/wd4244', '/wd4190', '/wd4101', '/wd4996',
+                          '/wd4275']
     if sys.version_info[0] == 2:
         # /bigobj increases number of sections in .obj file, which is needed to link
         # against libaries in Python 2.7 under Windows
         extra_compile_args.append('/bigobj')
 else:
+    extra_link_args = []
     extra_compile_args = [
         '-std=c++11',
         '-Wall',
@@ -619,12 +635,13 @@ def run(self):
 
 include_dirs += [
     cwd,
-    os.path.join(cwd, "torch", "csrc"),
-    third_party_path + "/pybind11/include",
     tmp_install_path + "/include",
     tmp_install_path + "/include/TH",
     tmp_install_path + "/include/THNN",
     tmp_install_path + "/include/ATen",
+    third_party_path + "/pybind11/include",
+    os.path.join(cwd, "torch", "csrc"),
+    "build/third_party",
 ]
 
 library_dirs.append(lib_path)
@@ -642,6 +659,10 @@ def run(self):
 
 # static library only
 NANOPB_STATIC_LIB = os.path.join(lib_path, 'libprotobuf-nanopb.a')
+if DEBUG:
+    PROTOBUF_STATIC_LIB = os.path.join(lib_path, 'libprotobufd.a')
+else:
+    PROTOBUF_STATIC_LIB = os.path.join(lib_path, 'libprotobuf.a')
 
 if IS_DARWIN:
     CAFFE2_LIBS = [os.path.join(lib_path, 'libcaffe2.dylib')]
@@ -657,14 +678,22 @@ def run(self):
         CAFFE2_LIBS.append(os.path.join(lib_path, 'caffe2_gpu.lib'))
     if WITH_ROCM:
         CAFFE2_LIBS.append(os.path.join(lib_path, 'caffe2_hip.lib'))
+    # Windows needs direct access to ONNX libraries as well
+    # as through Caffe2 library
+    CAFFE2_LIBS += [
+        os.path.join(lib_path, 'onnx.lib'),
+        os.path.join(lib_path, 'onnx_proto.lib'),
+    ]
     if DEBUG:
         NANOPB_STATIC_LIB = os.path.join(lib_path, 'protobuf-nanopbd.lib')
+        PROTOBUF_STATIC_LIB = os.path.join(lib_path, 'libprotobufd.lib')
     else:
         NANOPB_STATIC_LIB = os.path.join(lib_path, 'protobuf-nanopb.lib')
+        PROTOBUF_STATIC_LIB = os.path.join(lib_path, 'libprotobuf.lib')
 
-main_compile_args = ['-D_THP_CORE']
+main_compile_args = ['-D_THP_CORE', '-DONNX_NAMESPACE=' + ONNX_NAMESPACE]
 main_libraries = ['shm']
-main_link_args = CAFFE2_LIBS + [NANOPB_STATIC_LIB]
+main_link_args = CAFFE2_LIBS + [NANOPB_STATIC_LIB, PROTOBUF_STATIC_LIB]
 main_sources = [
     "torch/csrc/PtrWrapper.cpp",
     "torch/csrc/Module.cpp",
@@ -952,6 +981,7 @@ def make_relative_rpath(path):
     THNVRTC = Extension("torch._nvrtc",
                         sources=['torch/csrc/nvrtc.cpp'],
                         language='c++',
+                        extra_compile_args=main_compile_args + extra_compile_args,
                         include_dirs=include_dirs,
                         library_dirs=library_dirs + cuda_stub_path,
                         extra_link_args=thnvrtc_link_flags,
diff --git a/tools/build_pytorch_libs.bat b/tools/build_pytorch_libs.bat
index 66aaf26dbda5a..167fcf3e258c2 100755
--- a/tools/build_pytorch_libs.bat
+++ b/tools/build_pytorch_libs.bat
@@ -178,6 +178,7 @@ goto:eof
                   -DBUILD_ATEN=ON ^
                   -DBUILD_PYTHON=OFF ^
                   -DBUILD_BINARY=OFF ^
+                  -DONNX_NAMESPACE=%ONNX_NAMESPACE% ^
                   -DUSE_CUDA=%USE_CUDA% ^
                   -DUSE_NNPACK=%USE_NNPACK% ^
                   -DCUDNN_INCLUDE_DIR="%CUDNN_INCLUDE_DIR%" ^
diff --git a/tools/build_pytorch_libs.sh b/tools/build_pytorch_libs.sh
index 3823e37132d44..61e9eb61befb6 100755
--- a/tools/build_pytorch_libs.sh
+++ b/tools/build_pytorch_libs.sh
@@ -231,6 +231,7 @@ function build_caffe2() {
       -DBUILD_PYTHON=$FULL_CAFFE2 \
       -DBUILD_BINARY=OFF \
       -DBUILD_SHARED_LIBS=ON \
+      -DONNX_NAMESPACE=$ONNX_NAMESPACE \
       -DUSE_CUDA=$WITH_CUDA \
       -DUSE_ROCM=$WITH_ROCM \
       -DUSE_NNPACK=$WITH_NNPACK \
diff --git a/tools/cpp_build/build_caffe2.sh b/tools/cpp_build/build_caffe2.sh
index 4b7d04b5850c9..4c3254e7de66b 100755
--- a/tools/cpp_build/build_caffe2.sh
+++ b/tools/cpp_build/build_caffe2.sh
@@ -18,6 +18,7 @@ cmake -DUSE_CUDA=$USE_CUDA \
       -DBUILD_PYTHON=OFF \
       -DBUILD_BINARY=OFF \
       -DBUILD_SHARED_LIBS=ON \
+      -DONNX_NAMESPACE=$ONNX_NAMESPACE \
       -DCMAKE_BUILD_TYPE:STRING=$BUILD_TYPE \
       -DCMAKE_INSTALL_PREFIX:STRING=$INSTALL_PREFIX \
       -DCMAKE_INSTALL_MESSAGE=NEVER \
diff --git a/tools/cpp_build/build_common.sh b/tools/cpp_build/build_common.sh
index d742c5e1c329e..6a801937a936d 100755
--- a/tools/cpp_build/build_common.sh
+++ b/tools/cpp_build/build_common.sh
@@ -40,3 +40,8 @@ set -e
 if [[ $? -ne 0 ]]; then
   JOBS=4
 fi
+
+# Make sure an ONNX namespace is set
+if [ -z "$ONNX_NAMESPACE" ]; then
+  ONNX_NAMESPACE="onnx_torch"
+fi
diff --git a/tools/cpp_build/build_libtorch.sh b/tools/cpp_build/build_libtorch.sh
index b7ea07da8cd01..8857232afe6d2 100755
--- a/tools/cpp_build/build_libtorch.sh
+++ b/tools/cpp_build/build_libtorch.sh
@@ -16,6 +16,7 @@ cmake -DUSE_CUDA:BOOL=$USE_CUDA \
       -DNO_API:BOOL=${NO_API:0} \
       -DCAFFE2_PATH=$PYTORCHPATH/ \
       -DCAFFE2_BUILD_PATH=$CAFFE2_BUILDPATH \
+      -DONNX_NAMESPACE=$ONNX_NAMESPACE \
       -DNANOPB_BUILD_PATH=$NANOPB_BUILDPATH \
       -DINSTALL_PREFIX=$INSTALL_PREFIX \
       -DCMAKE_BUILD_TYPE:STRING=$BUILD_TYPE \
diff --git a/tools/cpp_build/libtorch/CMakeLists.txt b/tools/cpp_build/libtorch/CMakeLists.txt
index 1a891d61a5c9e..044487f7c55e8 100644
--- a/tools/cpp_build/libtorch/CMakeLists.txt
+++ b/tools/cpp_build/libtorch/CMakeLists.txt
@@ -26,7 +26,7 @@ if (VERBOSE)
 endif()
 
 set(CAFFE2_INCLUDE_DIR "${CAFFE2_PATH}")
-set(CAFFE2_BUILD_INCLUDE_DIR "${CAFFE2_BUILD_PATH}")
+set(CAFFE2_BUILD_LIB_DIR "${CAFFE2_BUILD_PATH}/lib")
 set(CAFFE2_INSTALL_INCLUDE_DIR "${INSTALL_PREFIX}/include")
 set(CAFFE2_INSTALL_SHARE_DIR "${INSTALL_PREFIX}/share")
 set(CAFFE2_INSTALL_LIB_DIR "${INSTALL_PREFIX}/lib")
@@ -38,6 +38,9 @@ find_library(CAFFE2_LIBRARY caffe2
 find_library(CAFFE2_GPU_LIBRARY caffe2_gpu
   NAMES libcaffe2_gpu.so libcaffe2_gpu.dylib caffe2_gpu.lib
   PATHS ${CAFFE2_INSTALL_LIB_DIR} NO_DEFAULT_PATH)
+find_library(PROTOBUF_LIBRARY protobuf
+  NAMES libprotobuf.a libprotobufd.a libprotobuf.lib libprotobufd.lib
+  PATHS ${CAFFE2_BUILD_LIB_DIR} NO_DEFAULT_PATH)
 find_library(NANOPB_LIBRARY protobuf-nanopb
   PATHS ${NANOPB_BUILD_PATH} NO_DEFAULT_PATH)
 
@@ -89,7 +92,7 @@ if(USE_CUDA)
   endif()
 endif()
 
-add_definitions(-DUSE_CATCH -D_FORCE_INLINES)
+add_definitions(-DUSE_CATCH -D_FORCE_INLINES -DONNX_NAMESPACE=${ONNX_NAMESPACE})
 
 if(NOT TORCH_INSTALL_BIN_DIR)
   set(TORCH_INSTALL_BIN_DIR bin)
@@ -286,6 +289,7 @@ endif()
 target_link_libraries(torch
   ${TORCH_CUDA_LIBRARIES}
   ${CAFFE2_LIBRARY}
+  ${PROTOBUF_LIBRARY}
   ${NANOPB_LIBRARY}
 )
 if(USE_CUDA)
@@ -299,7 +303,6 @@ endif()
 target_include_directories(torch
   PUBLIC
   "${CAFFE2_INCLUDE_DIR}"
-  "${CAFFE2_BUILD_INCLUDE_DIR}"
   "${CAFFE2_INSTALL_INCLUDE_DIR}"
   "${CAFFE2_INSTALL_INCLUDE_DIR}/TH"
   "${TORCH_SRC_DIR}/.."
diff --git a/torch/csrc/jit/test_jit.cpp b/torch/csrc/jit/test_jit.cpp
index 3adc87bb580a5..8334e299dcc1a 100644
--- a/torch/csrc/jit/test_jit.cpp
+++ b/torch/csrc/jit/test_jit.cpp
@@ -34,6 +34,8 @@
 #include "torch/csrc/jit/graph_executor.h"
 #include "torch/csrc/jit/script/compiler.h"
 #include "torch/csrc/jit/script/module.h"
+#include "onnx/onnx_pb.h"
+
 
 #include <vector>
 #include <iostream>
@@ -875,6 +877,11 @@ void testControlFlow() {
   REQUIRE(256 == run_binary("while_test",2,0));
 }
 
+void testProto() {
+  ::ONNX_NAMESPACE::ModelProto proto;
+  proto.set_producer_name("foo");
+}
+
 std::string runJITCPPTests() {
   std::stringstream out;
   testControlFlow();
@@ -893,6 +900,7 @@ std::string runJITCPPTests() {
   fromQualStringTests();
   argumentSpecTest();
   shapeAnalysisTest();
+  testProto();
   return out.str();
 }
 

From 6139d1fc84fc648ad3bf0ffff584623d569371f2 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Wed, 13 Jun 2018 12:10:06 -0700
Subject: [PATCH 116/118] Rebase creates some weird situations, revert them
 manually

---
 tools/autograd/gen_python_functions.py | 6 +++++-
 tools/autograd/utils.py                | 7 +++++--
 tools/nnwrap/generate_wrappers.py      | 7 ++++++-
 3 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/tools/autograd/gen_python_functions.py b/tools/autograd/gen_python_functions.py
index c5fcca7b3b0c0..ba58cde552e54 100644
--- a/tools/autograd/gen_python_functions.py
+++ b/tools/autograd/gen_python_functions.py
@@ -9,7 +9,11 @@
 from .gen_variable_type import should_trace
 from .utils import write
 
-CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
+try:
+    from src.ATen.code_template import CodeTemplate
+except ImportError:
+    from tools.shared.module_loader import import_module
+    CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
 
 # These functions require manual Python bindings or are not exposed to Python
 SKIP_PYTHON_BINDINGS = [
diff --git a/tools/autograd/utils.py b/tools/autograd/utils.py
index 608b7ea2d8c38..8a214b89deb42 100644
--- a/tools/autograd/utils.py
+++ b/tools/autograd/utils.py
@@ -9,8 +9,11 @@
     'split_name_params', 'write',
 ]
 
-
-CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
+try:
+    from src.ATen.code_template import CodeTemplate
+except ImportError:
+    from tools.shared.module_loader import import_module
+    CodeTemplate = import_module('code_template', 'aten/src/ATen/code_template.py').CodeTemplate
 
 try:
     # use faster C loader if available
diff --git a/tools/nnwrap/generate_wrappers.py b/tools/nnwrap/generate_wrappers.py
index 6c78fe3b0705d..ea13e22227d7f 100644
--- a/tools/nnwrap/generate_wrappers.py
+++ b/tools/nnwrap/generate_wrappers.py
@@ -109,7 +109,12 @@ def wrap_nn(thnn_h_path, install_dir, template_path):
     for fn in nn_functions:
         for t in ['Float', 'Double']:
             wrapper += wrap_function(fn.name, t, fn.arguments)
-    with open('torch/csrc/nn/THNN.cwrap', 'w') as f:
+    install_dir = install_dir or 'torch/csrc/nn'
+    try:
+        os.makedirs(install_dir)
+    except OSError:
+        pass
+    with open(os.path.join(install_dir, 'THNN.cwrap'), 'w') as f:
         f.write(wrapper)
     cwrap(os.path.join(install_dir, 'THNN.cwrap'),
           plugins=[NNExtension('torch._C._THNN'), NullableArguments()],

From 2f58721de30c748f758f59d2357d3eb924dbd669 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Wed, 13 Jun 2018 12:16:03 -0700
Subject: [PATCH 117/118] Remove more weird changes due to rebase

---
 tools/autograd/utils.py           | 1 -
 tools/nnwrap/generate_wrappers.py | 3 ++-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/autograd/utils.py b/tools/autograd/utils.py
index 8a214b89deb42..6758e71ffc97e 100644
--- a/tools/autograd/utils.py
+++ b/tools/autograd/utils.py
@@ -1,6 +1,5 @@
 import re
 import os
-from tools.shared.module_loader import import_module
 from .nested_dict import nested_dict
 
 
diff --git a/tools/nnwrap/generate_wrappers.py b/tools/nnwrap/generate_wrappers.py
index ea13e22227d7f..1edbca928c17d 100644
--- a/tools/nnwrap/generate_wrappers.py
+++ b/tools/nnwrap/generate_wrappers.py
@@ -128,7 +128,8 @@ def wrap_cunn(thcunn_h_path, install_dir, template_path):
     for fn in cunn_functions:
         for t in ['CudaHalf', 'Cuda', 'CudaDouble']:
             wrapper += wrap_function(fn.name, t, fn.arguments)
-    with open('torch/csrc/nn/THCUNN.cwrap', 'w') as f:
+    install_dir = install_dir or 'torch/csrc/nn'
+    with open(os.path.join(install_dir, 'THCUNN.cwrap'), 'w') as f:
         f.write(wrapper)
     cwrap(os.path.join(install_dir, 'THCUNN.cwrap'),
           plugins=[NNExtension('torch._C._THCUNN'), NullableArguments(), AutoGPU(has_self=False)],

From 030daee04904c3025e4a059de57d259b285e7239 Mon Sep 17 00:00:00 2001
From: Fei Sun <feisun@fb.com>
Date: Wed, 13 Jun 2018 12:23:23 -0700
Subject: [PATCH 118/118] Need to add thread_name.cc after merge

---
 caffe2/utils/CMakeLists.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/caffe2/utils/CMakeLists.txt b/caffe2/utils/CMakeLists.txt
index 5213baafce0e7..a6a7a60fb210b 100644
--- a/caffe2/utils/CMakeLists.txt
+++ b/caffe2/utils/CMakeLists.txt
@@ -18,7 +18,8 @@ list(APPEND Caffe2_CPU_SRCS
   utils/cpuid.cc
   utils/bench_utils.cc
   utils/math_cpu.cc
-  utils/math_utils.cc)
+  utils/math_utils.cc
+  utils/thread_name.cc)
 
 # ---[ threadpool/pthreadpool* is a local modification of the NNPACK
 # pthreadpool with a very similar interface. Neither NNPACK, nor this