import operator_benchmark as op_bench
import torch
import torch.nn.functional as F


"""Microbenchmarks for instancenorm operator."""

instancenorm_configs_short = op_bench.cross_product_configs(

            

Reported by Pylint.

              
import operator_benchmark as op_bench
import torch
import torch.nn.functional as F


"""Microbenchmarks for instancenorm operator."""

instancenorm_configs_short = op_bench.cross_product_configs(

            

Reported by Pylint.

              
"""Microbenchmarks for instancenorm operator."""

instancenorm_configs_short = op_bench.cross_product_configs(
    dims=(
        (32, 8, 16),
        (32, 8, 56, 56),
    ),
    tags=["short"],

            

Reported by Pylint.

              )


class InstanceNormBenchmark(op_bench.TorchBenchmarkBase):
    def init(self, dims):
        num_channels = dims[1]
        self.inputs = {
            "input": (torch.rand(*dims) - 0.5) * 256,
            "weight": torch.rand(num_channels, dtype=torch.float),

            

Reported by Pylint.

                          input, weight=weight, bias=bias, eps=eps)


op_bench.generate_pt_test(instancenorm_configs_short, InstanceNormBenchmark)


if __name__ == "__main__":
    op_bench.benchmark_runner.main()

            

Reported by Pylint.

              import torch.nn.functional as F


"""Microbenchmarks for instancenorm operator."""

instancenorm_configs_short = op_bench.cross_product_configs(
    dims=(
        (32, 8, 16),
        (32, 8, 56, 56),

            

Reported by Pylint.

              class InstanceNormBenchmark(op_bench.TorchBenchmarkBase):
    def init(self, dims):
        num_channels = dims[1]
        self.inputs = {
            "input": (torch.rand(*dims) - 0.5) * 256,
            "weight": torch.rand(num_channels, dtype=torch.float),
            "bias": torch.rand(num_channels, dtype=torch.float),
            "eps": 1e-5
        }

            

Reported by Pylint.

                          "eps": 1e-5
        }

    def forward(self, input, weight, bias, eps: float):
        return F.instance_norm(
            input, weight=weight, bias=bias, eps=eps)


op_bench.generate_pt_test(instancenorm_configs_short, InstanceNormBenchmark)

            

Reported by Pylint.

              
import operator_benchmark as op_bench
import torch
import torch.nn.functional as F


"""Microbenchmarks for instancenorm operator."""

instancenorm_configs_short = op_bench.cross_product_configs(

            

Reported by Pylint.

              )


class InstanceNormBenchmark(op_bench.TorchBenchmarkBase):
    def init(self, dims):
        num_channels = dims[1]
        self.inputs = {
            "input": (torch.rand(*dims) - 0.5) * 256,
            "weight": torch.rand(num_channels, dtype=torch.float),

            

Reported by Pylint.

              

import unittest
import hypothesis.strategies as st
from hypothesis import given, settings, assume
import numpy as np
from caffe2.python import core, workspace
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.mkl_test_util as mu

            

Reported by Pylint.

              
import unittest
import hypothesis.strategies as st
from hypothesis import given, settings, assume
import numpy as np
from caffe2.python import core, workspace
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.mkl_test_util as mu


            

Reported by Pylint.

              import caffe2.python.mkl_test_util as mu


@unittest.skipIf(not workspace.C.has_mkldnn,
                 "Skipping as we do not have mkldnn.")
class MKLPoolTest(hu.HypothesisTestCase):
    @given(stride=st.integers(1, 3),
           pad=st.integers(0, 3),
           kernel=st.integers(3, 5),

            

Reported by Pylint.

                  @settings(max_examples=2, deadline=100)
    def test_mkl_pooling(self, stride, pad, kernel, size,
                         input_channels, batch_size,
                         method, gc, dc):
        assume(pad < kernel)
        op = core.CreateOperator(
            method,
            ["X"],
            ["Y"],

            

Reported by Pylint.

              

if __name__ == "__main__":
    import unittest
    unittest.main()

            

Reported by Pylint.

              




import unittest
import hypothesis.strategies as st
from hypothesis import given, settings, assume
import numpy as np

            

Reported by Pylint.

              
@unittest.skipIf(not workspace.C.has_mkldnn,
                 "Skipping as we do not have mkldnn.")
class MKLPoolTest(hu.HypothesisTestCase):
    @given(stride=st.integers(1, 3),
           pad=st.integers(0, 3),
           kernel=st.integers(3, 5),
           size=st.integers(7, 9),
           input_channels=st.integers(1, 3),

            

Reported by Pylint.

                         method=st.sampled_from(["MaxPool", "AveragePool"]),
           **mu.gcs)
    @settings(max_examples=2, deadline=100)
    def test_mkl_pooling(self, stride, pad, kernel, size,
                         input_channels, batch_size,
                         method, gc, dc):
        assume(pad < kernel)
        op = core.CreateOperator(
            method,

            

Reported by Pylint.

                         method=st.sampled_from(["MaxPool", "AveragePool"]),
           **mu.gcs)
    @settings(max_examples=2, deadline=100)
    def test_mkl_pooling(self, stride, pad, kernel, size,
                         input_channels, batch_size,
                         method, gc, dc):
        assume(pad < kernel)
        op = core.CreateOperator(
            method,

            

Reported by Pylint.

                         method=st.sampled_from(["MaxPool", "AveragePool"]),
           **mu.gcs)
    @settings(max_examples=2, deadline=100)
    def test_mkl_pooling(self, stride, pad, kernel, size,
                         input_channels, batch_size,
                         method, gc, dc):
        assume(pad < kernel)
        op = core.CreateOperator(
            method,

            

Reported by Pylint.

              

import unittest
import hypothesis.strategies as st
from hypothesis import given
import numpy as np
from caffe2.python import core, workspace
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.mkl_test_util as mu

            

Reported by Pylint.

              
import unittest
import hypothesis.strategies as st
from hypothesis import given
import numpy as np
from caffe2.python import core, workspace
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.mkl_test_util as mu


            

Reported by Pylint.

              import caffe2.python.mkl_test_util as mu


@unittest.skipIf(not workspace.C.has_mkldnn,
                 "Skipping as we do not have mkldnn.")
class MKLElementwiseSumTest(hu.HypothesisTestCase):
    @given(size=st.integers(7, 9),
           input_channels=st.integers(1, 3),
           batch_size=st.integers(1, 3),

            

Reported by Pylint.

                                               batch_size,
                                 inputs,
                                 inplace,
                                 gc,
                                 dc):
        op = core.CreateOperator(
            "Sum",
            ["X_{}".format(i) for i in range(inputs)],
            ["X_0" if inplace else "Y"],

            

Reported by Pylint.

              

if __name__ == "__main__":
    import unittest
    unittest.main()

            

Reported by Pylint.

              




import unittest
import hypothesis.strategies as st
from hypothesis import given
import numpy as np

            

Reported by Pylint.

              
@unittest.skipIf(not workspace.C.has_mkldnn,
                 "Skipping as we do not have mkldnn.")
class MKLElementwiseSumTest(hu.HypothesisTestCase):
    @given(size=st.integers(7, 9),
           input_channels=st.integers(1, 3),
           batch_size=st.integers(1, 3),
           inputs=st.integers(1, 3),
           inplace=st.booleans(),

            

Reported by Pylint.

                         inputs=st.integers(1, 3),
           inplace=st.booleans(),
           **mu.gcs)
    def test_mkl_elementwise_sum(self,
                                 size,
                                 input_channels,
                                 batch_size,
                                 inputs,
                                 inplace,

            

Reported by Pylint.

                         inputs=st.integers(1, 3),
           inplace=st.booleans(),
           **mu.gcs)
    def test_mkl_elementwise_sum(self,
                                 size,
                                 input_channels,
                                 batch_size,
                                 inputs,
                                 inplace,

            

Reported by Pylint.

                         inputs=st.integers(1, 3),
           inplace=st.booleans(),
           **mu.gcs)
    def test_mkl_elementwise_sum(self,
                                 size,
                                 input_channels,
                                 batch_size,
                                 inputs,
                                 inplace,

            

Reported by Pylint.

                      return
    for name in list(_LAZY_IMPORTED_DYNDEPS):
        try:
            dyndep.InitOpLibrary(name, trigger_lazy=False)
        except BaseException as e:
            if _error_handler:
                _error_handler(e)
        finally:
            _LAZY_IMPORTED_DYNDEPS.remove(name)

            

Reported by Pylint.

                      # time when an actual call is made.
        print('Ignoring {} as it is not a valid file.'.format(name))
        return
    global _LAZY_IMPORTED_DYNDEPS
    _LAZY_IMPORTED_DYNDEPS.add(name)


_LAZY_IMPORTED_DYNDEPS = set()
_error_handler = None

            

Reported by Pylint.

                      None
    """

    global _error_handler
    _error_handler = handler


def GetImportedOpsLibraries():
    _import_lazy()

            

Reported by Pylint.

              

def _import_lazy():
    global _LAZY_IMPORTED_DYNDEPS
    if not _LAZY_IMPORTED_DYNDEPS:
        return
    for name in list(_LAZY_IMPORTED_DYNDEPS):
        try:
            dyndep.InitOpLibrary(name, trigger_lazy=False)

            

Reported by Pylint.

                  for name in list(_LAZY_IMPORTED_DYNDEPS):
        try:
            dyndep.InitOpLibrary(name, trigger_lazy=False)
        except BaseException as e:
            if _error_handler:
                _error_handler(e)
        finally:
            _LAZY_IMPORTED_DYNDEPS.remove(name)


            

Reported by Pylint.

              ## @package lazy_dyndep
# Module caffe2.python.lazy_dyndep





import os
from caffe2.python import dyndep, lazy

            

Reported by Pylint.

              from caffe2.python import dyndep, lazy


def RegisterOpsLibrary(name):
    """Registers a dynamic library that contains custom operators into Caffe2.

    Since Caffe2 uses static variable registration, you can optionally load a
    separate .so file that contains custom operators and registers that into
    the caffe2 core binary. In C++, this is usually done by either declaring

            

Reported by Pylint.

              

_LAZY_IMPORTED_DYNDEPS = set()
_error_handler = None


def SetErrorHandler(handler):
    """Registers an error handler for errors from registering operators


            

Reported by Pylint.

              _error_handler = None


def SetErrorHandler(handler):
    """Registers an error handler for errors from registering operators

    Since the lazy registration may happen at a much later time, having a dedicated
    error handler allows for custom error handling logic. It is highly
    recomended to set this to prevent errors from bubbling up in weird parts of the

            

Reported by Pylint.

                      None
    """

    global _error_handler
    _error_handler = handler


def GetImportedOpsLibraries():
    _import_lazy()

            

Reported by Pylint.

              

import unittest
import hypothesis.strategies as st
from hypothesis import given
import numpy as np
from caffe2.python import core, workspace
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.ideep_test_util as mu

            

Reported by Pylint.

              
import unittest
import hypothesis.strategies as st
from hypothesis import given
import numpy as np
from caffe2.python import core, workspace
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.ideep_test_util as mu


            

Reported by Pylint.

              import caffe2.python.hypothesis_test_util as hu
import caffe2.python.ideep_test_util as mu

@unittest.skipIf(not workspace.C.use_mkldnn, "No MKLDNN support.")
class SoftmaxTest(hu.HypothesisTestCase):
    @given(size=st.integers(8, 20),
           input_channels=st.integers(1, 3),
           batch_size=st.integers(1, 3),
           inplace=st.booleans(),

            

Reported by Pylint.

                         batch_size=st.integers(1, 3),
           inplace=st.booleans(),
           **mu.gcs)
    def test_softmax(self, size, input_channels, batch_size, inplace, gc, dc):
        op = core.CreateOperator(
            "Softmax",
            ["X"],
            ["Y"],
            axis=1,

            

Reported by Pylint.

                         batch_size=st.integers(1, 3),
           inplace=st.booleans(),
           **mu.gcs)
    def test_softmax(self, size, input_channels, batch_size, inplace, gc, dc):
        op = core.CreateOperator(
            "Softmax",
            ["X"],
            ["Y"],
            axis=1,

            

Reported by Pylint.

              




import unittest
import hypothesis.strategies as st
from hypothesis import given
import numpy as np

            

Reported by Pylint.

              import caffe2.python.ideep_test_util as mu

@unittest.skipIf(not workspace.C.use_mkldnn, "No MKLDNN support.")
class SoftmaxTest(hu.HypothesisTestCase):
    @given(size=st.integers(8, 20),
           input_channels=st.integers(1, 3),
           batch_size=st.integers(1, 3),
           inplace=st.booleans(),
           **mu.gcs)

            

Reported by Pylint.

                         batch_size=st.integers(1, 3),
           inplace=st.booleans(),
           **mu.gcs)
    def test_softmax(self, size, input_channels, batch_size, inplace, gc, dc):
        op = core.CreateOperator(
            "Softmax",
            ["X"],
            ["Y"],
            axis=1,

            

Reported by Pylint.

                         batch_size=st.integers(1, 3),
           inplace=st.booleans(),
           **mu.gcs)
    def test_softmax(self, size, input_channels, batch_size, inplace, gc, dc):
        op = core.CreateOperator(
            "Softmax",
            ["X"],
            ["Y"],
            axis=1,

            

Reported by Pylint.

                         batch_size=st.integers(1, 3),
           inplace=st.booleans(),
           **mu.gcs)
    def test_softmax(self, size, input_channels, batch_size, inplace, gc, dc):
        op = core.CreateOperator(
            "Softmax",
            ["X"],
            ["Y"],
            axis=1,

            

Reported by Pylint.

                          )
            net.BatchGather(
                [flattened, self.indices_to_gather()],
                self.output_schema(),
            )
        else:
            net.Flatten(Y, self.output_schema())

            

Reported by Pylint.

                              self.output_schema(),
            )
        else:
            net.Flatten(Y, self.output_schema())

            

Reported by Pylint.

              ## @package dot_product
# Module caffe2.python.layers.dot_product





from caffe2.python import schema
from caffe2.python.layers.layers import (

            

Reported by Pylint.

              )


class PairwiseSimilarity(ModelLayer):

    def __init__(self, model, input_record, output_dim, pairwise_similarity_func='dot',
                 name='pairwise_similarity', **kwargs):
        super(PairwiseSimilarity, self).__init__(model, name, input_record, **kwargs)
        assert isinstance(input_record, schema.Struct), (

            

Reported by Pylint.

              
class PairwiseSimilarity(ModelLayer):

    def __init__(self, model, input_record, output_dim, pairwise_similarity_func='dot',
                 name='pairwise_similarity', **kwargs):
        super(PairwiseSimilarity, self).__init__(model, name, input_record, **kwargs)
        assert isinstance(input_record, schema.Struct), (
            "Incorrect input type. Expected Struct, but received: {0}".
            format(input_record))

            

Reported by Pylint.

              
    def __init__(self, model, input_record, output_dim, pairwise_similarity_func='dot',
                 name='pairwise_similarity', **kwargs):
        super(PairwiseSimilarity, self).__init__(model, name, input_record, **kwargs)
        assert isinstance(input_record, schema.Struct), (
            "Incorrect input type. Expected Struct, but received: {0}".
            format(input_record))
        assert (
            ('all_embeddings' in input_record) ^

            

Reported by Pylint.

                  def __init__(self, model, input_record, output_dim, pairwise_similarity_func='dot',
                 name='pairwise_similarity', **kwargs):
        super(PairwiseSimilarity, self).__init__(model, name, input_record, **kwargs)
        assert isinstance(input_record, schema.Struct), (
            "Incorrect input type. Expected Struct, but received: {0}".
            format(input_record))
        assert (
            ('all_embeddings' in input_record) ^
            ('x_embeddings' in input_record and 'y_embeddings' in input_record)

            

Reported by Bandit.

                      assert isinstance(input_record, schema.Struct), (
            "Incorrect input type. Expected Struct, but received: {0}".
            format(input_record))
        assert (
            ('all_embeddings' in input_record) ^
            ('x_embeddings' in input_record and 'y_embeddings' in input_record)
        ), (
            "either (all_embeddings) xor (x_embeddings and y_embeddings) " +
            "should be given."

            

Reported by Bandit.

                          x_embeddings = input_record['x_embeddings']
            y_embeddings = input_record['y_embeddings']

        assert isinstance(x_embeddings, schema.Scalar), (
            "Incorrect input type for x. Expected Scalar, " +
            "but received: {0}".format(x_embeddings))
        assert isinstance(y_embeddings, schema.Scalar), (
            "Incorrect input type for y. Expected Scalar, " +
            "but received: {0}".format(y_embeddings)

            

Reported by Bandit.

                      assert isinstance(x_embeddings, schema.Scalar), (
            "Incorrect input type for x. Expected Scalar, " +
            "but received: {0}".format(x_embeddings))
        assert isinstance(y_embeddings, schema.Scalar), (
            "Incorrect input type for y. Expected Scalar, " +
            "but received: {0}".format(y_embeddings)
        )

        if 'indices_to_gather' in input_record:

            

Reported by Bandit.

              

import unittest
import hypothesis.strategies as st
from hypothesis import given, settings
import numpy as np
from caffe2.python import core, workspace
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.ideep_test_util as mu

            

Reported by Pylint.

              
import unittest
import hypothesis.strategies as st
from hypothesis import given, settings
import numpy as np
from caffe2.python import core, workspace
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.ideep_test_util as mu


            

Reported by Pylint.

              import caffe2.python.ideep_test_util as mu


@unittest.skipIf(not workspace.C.use_mkldnn, "No MKLDNN support.")
class LRNTest(hu.HypothesisTestCase):
    @given(input_channels=st.integers(1, 3),
           batch_size=st.integers(1, 3),
           im_size=st.integers(1, 10),
           order=st.sampled_from(["NCHW"]),

            

Reported by Pylint.

              




import unittest
import hypothesis.strategies as st
from hypothesis import given, settings
import numpy as np

            

Reported by Pylint.

              




import unittest
import hypothesis.strategies as st
from hypothesis import given, settings
import numpy as np

            

Reported by Pylint.

              

@unittest.skipIf(not workspace.C.use_mkldnn, "No MKLDNN support.")
class LRNTest(hu.HypothesisTestCase):
    @given(input_channels=st.integers(1, 3),
           batch_size=st.integers(1, 3),
           im_size=st.integers(1, 10),
           order=st.sampled_from(["NCHW"]),
           **mu.gcs)

            

Reported by Pylint.

                         order=st.sampled_from(["NCHW"]),
           **mu.gcs)
    @settings(deadline=10000)
    def test_LRN(self, input_channels,
                            batch_size, im_size, order,
                             gc, dc):
        op = core.CreateOperator(
            "LRN",
            ["X"],

            

Reported by Pylint.

                         order=st.sampled_from(["NCHW"]),
           **mu.gcs)
    @settings(deadline=10000)
    def test_LRN(self, input_channels,
                            batch_size, im_size, order,
                             gc, dc):
        op = core.CreateOperator(
            "LRN",
            ["X"],

            

Reported by Pylint.

                         order=st.sampled_from(["NCHW"]),
           **mu.gcs)
    @settings(deadline=10000)
    def test_LRN(self, input_channels,
                            batch_size, im_size, order,
                             gc, dc):
        op = core.CreateOperator(
            "LRN",
            ["X"],

            

Reported by Pylint.

                         order=st.sampled_from(["NCHW"]),
           **mu.gcs)
    @settings(deadline=10000)
    def test_LRN(self, input_channels,
                            batch_size, im_size, order,
                             gc, dc):
        op = core.CreateOperator(
            "LRN",
            ["X"],

            

Reported by Pylint.

              WORKFLOWS = REPO_ROOT / ".github" / "workflows"


def concurrency_key(filename: Path) -> str:
    workflow_name = filename.with_suffix("").name.replace("_", "-")
    if workflow_name.startswith("generated-"):
        workflow_name = workflow_name[len("generated-"):]
    return f"{workflow_name}-${{{{ github.event.pull_request.number || github.sha }}}}"


            

Reported by Pylint.

                  return f"{workflow_name}-${{{{ github.event.pull_request.number || github.sha }}}}"


def should_check(filename: Path) -> bool:
    with open(filename, "r") as f:
        content = f.read()

    data = yaml.safe_load(content)
    on = data.get("on", data.get(True, {}))

            

Reported by Pylint.

              

def should_check(filename: Path) -> bool:
    with open(filename, "r") as f:
        content = f.read()

    data = yaml.safe_load(content)
    on = data.get("on", data.get(True, {}))
    return "pull_request" in on

            

Reported by Pylint.

                  with open(filename, "r") as f:
        content = f.read()

    data = yaml.safe_load(content)
    on = data.get("on", data.get(True, {}))
    return "pull_request" in on


if __name__ == "__main__":

            

Reported by Pylint.

              #!/usr/bin/env python3

import argparse
import sys
import yaml

from pathlib import Path



            

Reported by Pylint.

              import sys
import yaml

from pathlib import Path


REPO_ROOT = Path(__file__).resolve().parent.parent.parent
WORKFLOWS = REPO_ROOT / ".github" / "workflows"


            

Reported by Pylint.

              WORKFLOWS = REPO_ROOT / ".github" / "workflows"


def concurrency_key(filename: Path) -> str:
    workflow_name = filename.with_suffix("").name.replace("_", "-")
    if workflow_name.startswith("generated-"):
        workflow_name = workflow_name[len("generated-"):]
    return f"{workflow_name}-${{{{ github.event.pull_request.number || github.sha }}}}"


            

Reported by Pylint.

                  return f"{workflow_name}-${{{{ github.event.pull_request.number || github.sha }}}}"


def should_check(filename: Path) -> bool:
    with open(filename, "r") as f:
        content = f.read()

    data = yaml.safe_load(content)
    on = data.get("on", data.get(True, {}))

            

Reported by Pylint.

              

def should_check(filename: Path) -> bool:
    with open(filename, "r") as f:
        content = f.read()

    data = yaml.safe_load(content)
    on = data.get("on", data.get(True, {}))
    return "pull_request" in on

            

Reported by Pylint.

                      content = f.read()

    data = yaml.safe_load(content)
    on = data.get("on", data.get(True, {}))
    return "pull_request" in on


if __name__ == "__main__":
    parser = argparse.ArgumentParser(

            

Reported by Pylint.

              

import unittest
import hypothesis.strategies as st
from hypothesis import given, settings
import numpy as np
from caffe2.python import core, workspace
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.ideep_test_util as mu

            

Reported by Pylint.

              
import unittest
import hypothesis.strategies as st
from hypothesis import given, settings
import numpy as np
from caffe2.python import core, workspace
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.ideep_test_util as mu


            

Reported by Pylint.

              import caffe2.python.hypothesis_test_util as hu
import caffe2.python.ideep_test_util as mu

@unittest.skipIf(not workspace.C.use_mkldnn, "No MKLDNN support.")
class TransposeTest(hu.HypothesisTestCase):
    @given(
        X=hu.tensor(min_dim=1, max_dim=5, dtype=np.float32), use_axes=st.booleans(), **mu.gcs)
    @settings(deadline=None, max_examples=50)
    def test_transpose(self, X, use_axes, gc, dc):

            

Reported by Pylint.

              




import unittest
import hypothesis.strategies as st
from hypothesis import given, settings
import numpy as np

            

Reported by Pylint.

              import caffe2.python.ideep_test_util as mu

@unittest.skipIf(not workspace.C.use_mkldnn, "No MKLDNN support.")
class TransposeTest(hu.HypothesisTestCase):
    @given(
        X=hu.tensor(min_dim=1, max_dim=5, dtype=np.float32), use_axes=st.booleans(), **mu.gcs)
    @settings(deadline=None, max_examples=50)
    def test_transpose(self, X, use_axes, gc, dc):
        ndim = len(X.shape)

            

Reported by Pylint.

                  @given(
        X=hu.tensor(min_dim=1, max_dim=5, dtype=np.float32), use_axes=st.booleans(), **mu.gcs)
    @settings(deadline=None, max_examples=50)
    def test_transpose(self, X, use_axes, gc, dc):
        ndim = len(X.shape)
        axes = np.arange(ndim)
        np.random.shuffle(axes)

        if use_axes:

            

Reported by Pylint.

                  @given(
        X=hu.tensor(min_dim=1, max_dim=5, dtype=np.float32), use_axes=st.booleans(), **mu.gcs)
    @settings(deadline=None, max_examples=50)
    def test_transpose(self, X, use_axes, gc, dc):
        ndim = len(X.shape)
        axes = np.arange(ndim)
        np.random.shuffle(axes)

        if use_axes:

            

Reported by Pylint.

                  @given(
        X=hu.tensor(min_dim=1, max_dim=5, dtype=np.float32), use_axes=st.booleans(), **mu.gcs)
    @settings(deadline=None, max_examples=50)
    def test_transpose(self, X, use_axes, gc, dc):
        ndim = len(X.shape)
        axes = np.arange(ndim)
        np.random.shuffle(axes)

        if use_axes:

            

Reported by Pylint.

                  @given(
        X=hu.tensor(min_dim=1, max_dim=5, dtype=np.float32), use_axes=st.booleans(), **mu.gcs)
    @settings(deadline=None, max_examples=50)
    def test_transpose(self, X, use_axes, gc, dc):
        ndim = len(X.shape)
        axes = np.arange(ndim)
        np.random.shuffle(axes)

        if use_axes:

            

Reported by Pylint.

                      np.random.shuffle(axes)

        if use_axes:
            op = core.CreateOperator(
                "Transpose", ["X"], ["Y"], axes=axes, device_option=gc)
        else:
            op = core.CreateOperator(
                "Transpose", ["X"], ["Y"], device_option=gc)


            

Reported by Pylint.

              

# Input
import caffe2.contrib.playground.resnetdemo.\
    gfs_IN1k as gfs_IN1k  # noqa

# model
import caffe2.contrib.playground.resnetdemo.\
    IN1k_resnet as IN1k_resnet # noqa

            

Reported by Pylint.

                  gfs_IN1k as gfs_IN1k  # noqa

# model
import caffe2.contrib.playground.resnetdemo.\
    IN1k_resnet as IN1k_resnet # noqa

import caffe2.contrib.playground.resnetdemo.\
    IN1k_resnet_no_test_model as IN1k_resnet_no_test_model # noqa


            

Reported by Pylint.

              import caffe2.contrib.playground.resnetdemo.\
    IN1k_resnet as IN1k_resnet # noqa

import caffe2.contrib.playground.resnetdemo.\
    IN1k_resnet_no_test_model as IN1k_resnet_no_test_model # noqa

# Additional override
import caffe2.contrib.playground.resnetdemo.\
    override_no_test_model_no_checkpoint as override_no_test_model_no_checkpoint # noqa

            

Reported by Pylint.

                  IN1k_resnet_no_test_model as IN1k_resnet_no_test_model # noqa

# Additional override
import caffe2.contrib.playground.resnetdemo.\
    override_no_test_model_no_checkpoint as override_no_test_model_no_checkpoint # noqa

# FORWARD_PASS
import caffe2.contrib.playground.resnetdemo.\
    caffe2_resnet50_default_forward as caffe2_resnet50_default_forward # noqa

            

Reported by Pylint.

                  override_no_test_model_no_checkpoint as override_no_test_model_no_checkpoint # noqa

# FORWARD_PASS
import caffe2.contrib.playground.resnetdemo.\
    caffe2_resnet50_default_forward as caffe2_resnet50_default_forward # noqa

import caffe2.contrib.playground.resnetdemo.\
    explicit_resnet_forward as explicit_resnet_forward # noqa


            

Reported by Pylint.

              import caffe2.contrib.playground.resnetdemo.\
    caffe2_resnet50_default_forward as caffe2_resnet50_default_forward # noqa

import caffe2.contrib.playground.resnetdemo.\
    explicit_resnet_forward as explicit_resnet_forward # noqa

# PARAMETER_UPDATE
import caffe2.contrib.playground.resnetdemo.\
    caffe2_resnet50_default_param_update as caffe2_resnet50_default_param_update # noqa

            

Reported by Pylint.

                  explicit_resnet_forward as explicit_resnet_forward # noqa

# PARAMETER_UPDATE
import caffe2.contrib.playground.resnetdemo.\
    caffe2_resnet50_default_param_update as caffe2_resnet50_default_param_update # noqa

import caffe2.contrib.playground.resnetdemo.\
    explicit_resnet_param_update as explicit_resnet_param_update # noqa


            

Reported by Pylint.

              import caffe2.contrib.playground.resnetdemo.\
    caffe2_resnet50_default_param_update as caffe2_resnet50_default_param_update # noqa

import caffe2.contrib.playground.resnetdemo.\
    explicit_resnet_param_update as explicit_resnet_param_update # noqa

# RENDEZVOUS
import caffe2.contrib.playground.resnetdemo.\
    rendezvous_filestore as rendezvous_filestore # noqa

            

Reported by Pylint.

                  explicit_resnet_param_update as explicit_resnet_param_update # noqa

# RENDEZVOUS
import caffe2.contrib.playground.resnetdemo.\
    rendezvous_filestore as rendezvous_filestore # noqa

# OUTPUT
import caffe2.contrib.playground.\
    output_generator as output_generator # noqa

            

Reported by Pylint.

                  rendezvous_filestore as rendezvous_filestore # noqa

# OUTPUT
import caffe2.contrib.playground.\
    output_generator as output_generator # noqa

# METERS
# for meters, use the class name as your module name in this map
import caffe2.contrib.playground.\

            

Reported by Pylint.