import numpy as np
import unittest

from caffe2.python import core, workspace, test_util


class TestToyRegression(test_util.TestCase):
    def testToyRegression(self):
        """Tests a toy regression end to end.

            

Reported by Pylint.

              import numpy as np
import unittest

from caffe2.python import core, workspace, test_util


class TestToyRegression(test_util.TestCase):
    def testToyRegression(self):
        """Tests a toy regression end to end.

            

Reported by Pylint.

              from caffe2.python import core, workspace, test_util


class TestToyRegression(test_util.TestCase):
    def testToyRegression(self):
        """Tests a toy regression end to end.

        The test code carries a simple toy regression in the form
            y = 2.0 x1 + 1.5 x2 + 0.5

            

Reported by Pylint.

              

class TestToyRegression(test_util.TestCase):
    def testToyRegression(self):
        """Tests a toy regression end to end.

        The test code carries a simple toy regression in the form
            y = 2.0 x1 + 1.5 x2 + 0.5
        by randomly generating gaussian inputs and calculating the ground

            

Reported by Pylint.

              

class TestToyRegression(test_util.TestCase):
    def testToyRegression(self):
        """Tests a toy regression end to end.

        The test code carries a simple toy regression in the form
            y = 2.0 x1 + 1.5 x2 + 0.5
        by randomly generating gaussian inputs and calculating the ground

            

Reported by Pylint.

              

class TestToyRegression(test_util.TestCase):
    def testToyRegression(self):
        """Tests a toy regression end to end.

        The test code carries a simple toy regression in the form
            y = 2.0 x1 + 1.5 x2 + 0.5
        by randomly generating gaussian inputs and calculating the ground

            

Reported by Pylint.

                      """
        workspace.ResetWorkspace()
        init_net = core.Net("init")
        W = init_net.UniformFill([], "W", shape=[1, 2], min=-1., max=1.)
        B = init_net.ConstantFill([], "B", shape=[1], value=0.0)
        W_gt = init_net.GivenTensorFill(
            [], "W_gt", shape=[1, 2], values=[2.0, 1.5])
        B_gt = init_net.GivenTensorFill([], "B_gt", shape=[1], values=[0.5])
        LR = init_net.ConstantFill([], "LR", shape=[1], value=-0.1)

            

Reported by Pylint.

                      workspace.ResetWorkspace()
        init_net = core.Net("init")
        W = init_net.UniformFill([], "W", shape=[1, 2], min=-1., max=1.)
        B = init_net.ConstantFill([], "B", shape=[1], value=0.0)
        W_gt = init_net.GivenTensorFill(
            [], "W_gt", shape=[1, 2], values=[2.0, 1.5])
        B_gt = init_net.GivenTensorFill([], "B_gt", shape=[1], values=[0.5])
        LR = init_net.ConstantFill([], "LR", shape=[1], value=-0.1)
        ONE = init_net.ConstantFill([], "ONE", shape=[1], value=1.)

            

Reported by Pylint.

                      init_net = core.Net("init")
        W = init_net.UniformFill([], "W", shape=[1, 2], min=-1., max=1.)
        B = init_net.ConstantFill([], "B", shape=[1], value=0.0)
        W_gt = init_net.GivenTensorFill(
            [], "W_gt", shape=[1, 2], values=[2.0, 1.5])
        B_gt = init_net.GivenTensorFill([], "B_gt", shape=[1], values=[0.5])
        LR = init_net.ConstantFill([], "LR", shape=[1], value=-0.1)
        ONE = init_net.ConstantFill([], "ONE", shape=[1], value=1.)
        ITER = init_net.ConstantFill([], "ITER", shape=[1], value=0,

            

Reported by Pylint.

                      B = init_net.ConstantFill([], "B", shape=[1], value=0.0)
        W_gt = init_net.GivenTensorFill(
            [], "W_gt", shape=[1, 2], values=[2.0, 1.5])
        B_gt = init_net.GivenTensorFill([], "B_gt", shape=[1], values=[0.5])
        LR = init_net.ConstantFill([], "LR", shape=[1], value=-0.1)
        ONE = init_net.ConstantFill([], "ONE", shape=[1], value=1.)
        ITER = init_net.ConstantFill([], "ITER", shape=[1], value=0,
                                     dtype=core.DataType.INT64)


            

Reported by Pylint.

              from caffe2.python import core
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.serialized_test.serialized_test_util as serial
from hypothesis import given, settings
import hypothesis.strategies as st
import numpy as np

import unittest


            

Reported by Pylint.

              import caffe2.python.hypothesis_test_util as hu
import caffe2.python.serialized_test.serialized_test_util as serial
from hypothesis import given, settings
import hypothesis.strategies as st
import numpy as np

import unittest



            

Reported by Pylint.

                      **hu.gcs
    )
    @settings(deadline=10000)
    def test_glu_old(self, X_axis, gc, dc):
        X, axis = X_axis

        def glu_ref(X):
            x1, x2 = np.split(X, [X.shape[axis] // 2], axis=axis)
            Y = x1 * (1. / (1. + np.exp(-x2)))

            

Reported by Pylint.

                      X, axis = X_axis

        def glu_ref(X):
            x1, x2 = np.split(X, [X.shape[axis] // 2], axis=axis)
            Y = x1 * (1. / (1. + np.exp(-x2)))
            return [Y]

        op = core.CreateOperator("Glu", ["X"], ["Y"], dim=axis)
        self.assertReferenceChecks(gc, op, [X], glu_ref)

            

Reported by Pylint.

              




from caffe2.python import core
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.serialized_test.serialized_test_util as serial
from hypothesis import given, settings

            

Reported by Pylint.

              import hypothesis.strategies as st
import numpy as np

import unittest


@st.composite
def _glu_old_input(draw):
    dims = draw(st.lists(st.integers(min_value=1, max_value=5), min_size=1, max_size=3))

            

Reported by Pylint.

                  # The axis dimension must be divisible by two
    axis_dim = 2 * draw(st.integers(min_value=1, max_value=2))
    dims.insert(axis, axis_dim)
    X = draw(hu.arrays(dims, np.float32, None))
    return (X, axis)


class TestGlu(serial.SerializedTestCase):
    @given(

            

Reported by Pylint.

                  return (X, axis)


class TestGlu(serial.SerializedTestCase):
    @given(
        X_axis=_glu_old_input(),
        **hu.gcs
    )
    @settings(deadline=10000)

            

Reported by Pylint.

                      X_axis=_glu_old_input(),
        **hu.gcs
    )
    @settings(deadline=10000)
    def test_glu_old(self, X_axis, gc, dc):
        X, axis = X_axis

        def glu_ref(X):
            x1, x2 = np.split(X, [X.shape[axis] // 2], axis=axis)

            

Reported by Pylint.

                      X_axis=_glu_old_input(),
        **hu.gcs
    )
    @settings(deadline=10000)
    def test_glu_old(self, X_axis, gc, dc):
        X, axis = X_axis

        def glu_ref(X):
            x1, x2 = np.split(X, [X.shape[axis] // 2], axis=axis)

            

Reported by Pylint.

              import functools

import numpy as np
from hypothesis import given, settings
from caffe2.python import core
import caffe2.python.hypothesis_test_util as hu
import copy



            

Reported by Pylint.

              



import functools

import numpy as np
from hypothesis import given, settings
from caffe2.python import core

            

Reported by Pylint.

              from hypothesis import given, settings
from caffe2.python import core
import caffe2.python.hypothesis_test_util as hu
import copy


class TestNormalizeOp(hu.HypothesisTestCase):
    @given(
        X=hu.tensor(

            

Reported by Pylint.

              import copy


class TestNormalizeOp(hu.HypothesisTestCase):
    @given(
        X=hu.tensor(
            min_dim=1, max_dim=5, elements=hu.floats(min_value=0.5, max_value=1.0)
        ),
        **hu.gcs

            

Reported by Pylint.

                      ),
        **hu.gcs
    )
    @settings(max_examples=10, deadline=None)
    def test_normalize(self, X, gc, dc):
        def ref_normalize(X, axis):
            x_normed = X / np.maximum(
                np.sqrt((X ** 2).sum(axis=axis, keepdims=True)), 1e-12
            )

            

Reported by Pylint.

                      ),
        **hu.gcs
    )
    @settings(max_examples=10, deadline=None)
    def test_normalize(self, X, gc, dc):
        def ref_normalize(X, axis):
            x_normed = X / np.maximum(
                np.sqrt((X ** 2).sum(axis=axis, keepdims=True)), 1e-12
            )

            

Reported by Pylint.

                      ),
        **hu.gcs
    )
    @settings(max_examples=10, deadline=None)
    def test_normalize(self, X, gc, dc):
        def ref_normalize(X, axis):
            x_normed = X / np.maximum(
                np.sqrt((X ** 2).sum(axis=axis, keepdims=True)), 1e-12
            )

            

Reported by Pylint.

                      ),
        **hu.gcs
    )
    @settings(max_examples=10, deadline=None)
    def test_normalize(self, X, gc, dc):
        def ref_normalize(X, axis):
            x_normed = X / np.maximum(
                np.sqrt((X ** 2).sum(axis=axis, keepdims=True)), 1e-12
            )

            

Reported by Pylint.

                  )
    @settings(max_examples=10, deadline=None)
    def test_normalize(self, X, gc, dc):
        def ref_normalize(X, axis):
            x_normed = X / np.maximum(
                np.sqrt((X ** 2).sum(axis=axis, keepdims=True)), 1e-12
            )
            return (x_normed,)


            

Reported by Pylint.

                          return (x_normed,)

        for axis in range(-X.ndim, X.ndim):
            x = copy.copy(X)
            op = core.CreateOperator("Normalize", "X", "Y", axis=axis)
            self.assertReferenceChecks(
                gc, op, [x], functools.partial(ref_normalize, axis=axis)
            )
            self.assertDeviceChecks(dc, op, [x], [0])

            

Reported by Pylint.

              import sys
import test_c10d_spawn
import torch
import torch.distributed as c10d
from torch.testing._internal.common_cuda import TEST_MULTIGPU
from torch.testing._internal.common_utils import TestCase, run_tests, sandcastle_skip_if

NO_NCCL = not hasattr(c10d, "ProcessGroupNCCL")


            

Reported by Pylint.

              import sys
import test_c10d_spawn
import torch
import torch.distributed as c10d
from torch.testing._internal.common_cuda import TEST_MULTIGPU
from torch.testing._internal.common_utils import TestCase, run_tests, sandcastle_skip_if

NO_NCCL = not hasattr(c10d, "ProcessGroupNCCL")


            

Reported by Pylint.

              import test_c10d_spawn
import torch
import torch.distributed as c10d
from torch.testing._internal.common_cuda import TEST_MULTIGPU
from torch.testing._internal.common_utils import TestCase, run_tests, sandcastle_skip_if

NO_NCCL = not hasattr(c10d, "ProcessGroupNCCL")

# Fails on Python-3.9, see https://github.com/pytorch/pytorch/issues/51619

            

Reported by Pylint.

              import torch
import torch.distributed as c10d
from torch.testing._internal.common_cuda import TEST_MULTIGPU
from torch.testing._internal.common_utils import TestCase, run_tests, sandcastle_skip_if

NO_NCCL = not hasattr(c10d, "ProcessGroupNCCL")

# Fails on Python-3.9, see https://github.com/pytorch/pytorch/issues/51619
if sys.version_info < (3, 9):

            

Reported by Pylint.

              import sys
import test_c10d_spawn
import torch
import torch.distributed as c10d
from torch.testing._internal.common_cuda import TEST_MULTIGPU
from torch.testing._internal.common_utils import TestCase, run_tests, sandcastle_skip_if

NO_NCCL = not hasattr(c10d, "ProcessGroupNCCL")


            

Reported by Pylint.

              import sys
import test_c10d_spawn
import torch
import torch.distributed as c10d
from torch.testing._internal.common_cuda import TEST_MULTIGPU
from torch.testing._internal.common_utils import TestCase, run_tests, sandcastle_skip_if

NO_NCCL = not hasattr(c10d, "ProcessGroupNCCL")


            

Reported by Pylint.

              import sys
import test_c10d_spawn
import torch
import torch.distributed as c10d
from torch.testing._internal.common_cuda import TEST_MULTIGPU
from torch.testing._internal.common_utils import TestCase, run_tests, sandcastle_skip_if

NO_NCCL = not hasattr(c10d, "ProcessGroupNCCL")


            

Reported by Pylint.

              import test_c10d_spawn
import torch
import torch.distributed as c10d
from torch.testing._internal.common_cuda import TEST_MULTIGPU
from torch.testing._internal.common_utils import TestCase, run_tests, sandcastle_skip_if

NO_NCCL = not hasattr(c10d, "ProcessGroupNCCL")

# Fails on Python-3.9, see https://github.com/pytorch/pytorch/issues/51619

            

Reported by Pylint.

              import torch
import torch.distributed as c10d
from torch.testing._internal.common_cuda import TEST_MULTIGPU
from torch.testing._internal.common_utils import TestCase, run_tests, sandcastle_skip_if

NO_NCCL = not hasattr(c10d, "ProcessGroupNCCL")

# Fails on Python-3.9, see https://github.com/pytorch/pytorch/issues/51619
if sys.version_info < (3, 9):

            

Reported by Pylint.

              
# Fails on Python-3.9, see https://github.com/pytorch/pytorch/issues/51619
if sys.version_info < (3, 9):
    class ProcessGroupShareTensorTest(test_c10d_spawn.AbstractProcessGroupShareTensorTest, TestCase):

        @classmethod
        def _init_pg_nccl(cls, rank, filename, world_size):
            store = c10d.FileStore(filename, world_size)
            return c10d.ProcessGroupNCCL(store, rank, world_size)

            

Reported by Pylint.

              import operator_benchmark as op_bench
import benchmark_caffe2 as op_bench_c2
from benchmark_caffe2 import Caffe2BenchmarkBase  # noqa: F401
from caffe2.python import core


"""Microbenchmarks for element-wise Add operator. Supports both Caffe2/PyTorch."""

# Configs for C2 add operator

            

Reported by Pylint.

              import operator_benchmark as op_bench
import benchmark_caffe2 as op_bench_c2
from benchmark_caffe2 import Caffe2BenchmarkBase  # noqa: F401
from caffe2.python import core


"""Microbenchmarks for element-wise Add operator. Supports both Caffe2/PyTorch."""

# Configs for C2 add operator

            

Reported by Pylint.

              import operator_benchmark as op_bench
import benchmark_caffe2 as op_bench_c2
from benchmark_caffe2 import Caffe2BenchmarkBase  # noqa: F401
from caffe2.python import core


"""Microbenchmarks for element-wise Add operator. Supports both Caffe2/PyTorch."""

# Configs for C2 add operator

            

Reported by Pylint.

              """Microbenchmarks for element-wise Add operator. Supports both Caffe2/PyTorch."""

# Configs for C2 add operator
add_long_configs = op_bench.cross_product_configs(
    M=[8, 64, 128],
    N=range(2, 10, 3),
    K=[2 ** x for x in range(0, 3)],
    dtype=["int", "float"],
    tags=["long"]

            

Reported by Pylint.

              )


add_short_configs = op_bench.config_list(
    attrs=[
        [8, 16, 32, "int"],
        [16, 16, 64, "float"],
        [64, 64, 128, "int"],
    ],

            

Reported by Pylint.

              import operator_benchmark as op_bench
import benchmark_caffe2 as op_bench_c2
from benchmark_caffe2 import Caffe2BenchmarkBase  # noqa: F401
from caffe2.python import core


"""Microbenchmarks for element-wise Add operator. Supports both Caffe2/PyTorch."""

# Configs for C2 add operator

            

Reported by Pylint.

              from caffe2.python import core


"""Microbenchmarks for element-wise Add operator. Supports both Caffe2/PyTorch."""

# Configs for C2 add operator
add_long_configs = op_bench.cross_product_configs(
    M=[8, 64, 128],
    N=range(2, 10, 3),

            

Reported by Pylint.

              
class AddBenchmark(op_bench_c2.Caffe2BenchmarkBase):
    def init(self, M, N, K, dtype):
        self.input_one = self.tensor([M, N, K], dtype)
        self.input_two = self.tensor([M, N, K], dtype)
        self.output = self.tensor([M, N, K], dtype)
        self.set_module_name("add")

    def forward(self):

            

Reported by Pylint.

              class AddBenchmark(op_bench_c2.Caffe2BenchmarkBase):
    def init(self, M, N, K, dtype):
        self.input_one = self.tensor([M, N, K], dtype)
        self.input_two = self.tensor([M, N, K], dtype)
        self.output = self.tensor([M, N, K], dtype)
        self.set_module_name("add")

    def forward(self):
        op = core.CreateOperator(

            

Reported by Pylint.

                  def init(self, M, N, K, dtype):
        self.input_one = self.tensor([M, N, K], dtype)
        self.input_two = self.tensor([M, N, K], dtype)
        self.output = self.tensor([M, N, K], dtype)
        self.set_module_name("add")

    def forward(self):
        op = core.CreateOperator(
            "Add", [self.input_one, self.input_two], self.output, **self.args

            

Reported by Pylint.

              

def _context_registry():
    global _CONTEXT_REGISTRY
    return _CONTEXT_REGISTRY


def _get_managed_classes(obj):
    return [

            

Reported by Pylint.

                  DefaultManaged is similar to Managed but if there is no parent when
    current() is called it makes a new one.
    """
    pass

            

Reported by Pylint.

              ## @package context
# Module caffe2.python.context

import inspect
import threading
import functools


class _ContextInfo(object):

            

Reported by Pylint.

              import functools


class _ContextInfo(object):
    def __init__(self, cls, allow_default):
        self.cls = cls
        self.allow_default = allow_default
        self._local_stack = threading.local()


            

Reported by Pylint.

                          self._local_stack.obj = []
        return self._local_stack.obj

    def enter(self, value):
        self._stack.append(value)

    def exit(self, value):
        assert len(self._stack) > 0, 'Context %s is empty.' % self.cls
        assert self._stack.pop() == value

            

Reported by Pylint.

                  def enter(self, value):
        self._stack.append(value)

    def exit(self, value):
        assert len(self._stack) > 0, 'Context %s is empty.' % self.cls
        assert self._stack.pop() == value

    def get_active(self, required=True):
        if len(self._stack) == 0:

            

Reported by Pylint.

                      self._stack.append(value)

    def exit(self, value):
        assert len(self._stack) > 0, 'Context %s is empty.' % self.cls
        assert self._stack.pop() == value

    def get_active(self, required=True):
        if len(self._stack) == 0:
            if not required:

            

Reported by Bandit.

              
    def exit(self, value):
        assert len(self._stack) > 0, 'Context %s is empty.' % self.cls
        assert self._stack.pop() == value

    def get_active(self, required=True):
        if len(self._stack) == 0:
            if not required:
                return None

            

Reported by Bandit.

                      assert len(self._stack) > 0, 'Context %s is empty.' % self.cls
        assert self._stack.pop() == value

    def get_active(self, required=True):
        if len(self._stack) == 0:
            if not required:
                return None
            assert self.allow_default, (
                'Context %s is required but none is active.' % self.cls)

            

Reported by Pylint.

                      if len(self._stack) == 0:
            if not required:
                return None
            assert self.allow_default, (
                'Context %s is required but none is active.' % self.cls)
            self.enter(self.cls())
        return self._stack[-1]



            

Reported by Bandit.

              




from caffe2.python.models.seq2seq import seq2seq_model_helper
from caffe2.python import scope, test_util



            

Reported by Pylint.

              from caffe2.python import scope, test_util


class Seq2SeqModelHelperTest(test_util.TestCase):
    def testConstuctor(self):
        model_name = 'TestModel'
        m = seq2seq_model_helper.Seq2SeqModelHelper(name=model_name)

        self.assertEqual(m.name, model_name)

            

Reported by Pylint.

              

class Seq2SeqModelHelperTest(test_util.TestCase):
    def testConstuctor(self):
        model_name = 'TestModel'
        m = seq2seq_model_helper.Seq2SeqModelHelper(name=model_name)

        self.assertEqual(m.name, model_name)
        self.assertEqual(m.init_params, True)

            

Reported by Pylint.

              

class Seq2SeqModelHelperTest(test_util.TestCase):
    def testConstuctor(self):
        model_name = 'TestModel'
        m = seq2seq_model_helper.Seq2SeqModelHelper(name=model_name)

        self.assertEqual(m.name, model_name)
        self.assertEqual(m.init_params, True)

            

Reported by Pylint.

              class Seq2SeqModelHelperTest(test_util.TestCase):
    def testConstuctor(self):
        model_name = 'TestModel'
        m = seq2seq_model_helper.Seq2SeqModelHelper(name=model_name)

        self.assertEqual(m.name, model_name)
        self.assertEqual(m.init_params, True)

        self.assertEqual(m.arg_scope, {

            

Reported by Pylint.

                          'order': 'NHWC'
        })

    def testAddParam(self):
        m = seq2seq_model_helper.Seq2SeqModelHelper()

        param_name = 'test_param'
        param = m.AddParam(param_name, init_value=1)
        self.assertEqual(str(param), param_name)

            

Reported by Pylint.

                          'order': 'NHWC'
        })

    def testAddParam(self):
        m = seq2seq_model_helper.Seq2SeqModelHelper()

        param_name = 'test_param'
        param = m.AddParam(param_name, init_value=1)
        self.assertEqual(str(param), param_name)

            

Reported by Pylint.

                      })

    def testAddParam(self):
        m = seq2seq_model_helper.Seq2SeqModelHelper()

        param_name = 'test_param'
        param = m.AddParam(param_name, init_value=1)
        self.assertEqual(str(param), param_name)


            

Reported by Pylint.

                      param = m.AddParam(param_name, init_value=1)
        self.assertEqual(str(param), param_name)

    def testGetNonTrainableParams(self):
        m = seq2seq_model_helper.Seq2SeqModelHelper()

        m.AddParam('test_param1', init_value=1, trainable=True)
        p2 = m.AddParam('test_param2', init_value=2, trainable=False)


            

Reported by Pylint.

                      param = m.AddParam(param_name, init_value=1)
        self.assertEqual(str(param), param_name)

    def testGetNonTrainableParams(self):
        m = seq2seq_model_helper.Seq2SeqModelHelper()

        m.AddParam('test_param1', init_value=1, trainable=True)
        p2 = m.AddParam('test_param2', init_value=2, trainable=False)


            

Reported by Pylint.

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





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

            

Reported by Pylint.

              import numpy as np


class SparseFeatureHash(ModelLayer):

    def __init__(self, model, input_record, seed=0, modulo=None,
                 use_hashing=True, use_divide_mod=False, divisor=None, name='sparse_feature_hash', **kwargs):
        super(SparseFeatureHash, self).__init__(model, name, input_record, **kwargs)


            

Reported by Pylint.

              
class SparseFeatureHash(ModelLayer):

    def __init__(self, model, input_record, seed=0, modulo=None,
                 use_hashing=True, use_divide_mod=False, divisor=None, name='sparse_feature_hash', **kwargs):
        super(SparseFeatureHash, self).__init__(model, name, input_record, **kwargs)

        assert use_hashing + use_divide_mod < 2, "use_hashing and use_divide_mod cannot be set true at the same time."


            

Reported by Pylint.

              class SparseFeatureHash(ModelLayer):

    def __init__(self, model, input_record, seed=0, modulo=None,
                 use_hashing=True, use_divide_mod=False, divisor=None, name='sparse_feature_hash', **kwargs):
        super(SparseFeatureHash, self).__init__(model, name, input_record, **kwargs)

        assert use_hashing + use_divide_mod < 2, "use_hashing and use_divide_mod cannot be set true at the same time."

        if use_divide_mod:

            

Reported by Pylint.

              
    def __init__(self, model, input_record, seed=0, modulo=None,
                 use_hashing=True, use_divide_mod=False, divisor=None, name='sparse_feature_hash', **kwargs):
        super(SparseFeatureHash, self).__init__(model, name, input_record, **kwargs)

        assert use_hashing + use_divide_mod < 2, "use_hashing and use_divide_mod cannot be set true at the same time."

        if use_divide_mod:
            assert divisor >= 1, 'Unexpected divisor: {}'.format(divisor)

            

Reported by Pylint.

                               use_hashing=True, use_divide_mod=False, divisor=None, name='sparse_feature_hash', **kwargs):
        super(SparseFeatureHash, self).__init__(model, name, input_record, **kwargs)

        assert use_hashing + use_divide_mod < 2, "use_hashing and use_divide_mod cannot be set true at the same time."

        if use_divide_mod:
            assert divisor >= 1, 'Unexpected divisor: {}'.format(divisor)

            self.divisor = self.create_param(param_name='divisor',

            

Reported by Pylint.

                               use_hashing=True, use_divide_mod=False, divisor=None, name='sparse_feature_hash', **kwargs):
        super(SparseFeatureHash, self).__init__(model, name, input_record, **kwargs)

        assert use_hashing + use_divide_mod < 2, "use_hashing and use_divide_mod cannot be set true at the same time."

        if use_divide_mod:
            assert divisor >= 1, 'Unexpected divisor: {}'.format(divisor)

            self.divisor = self.create_param(param_name='divisor',

            

Reported by Bandit.

                      assert use_hashing + use_divide_mod < 2, "use_hashing and use_divide_mod cannot be set true at the same time."

        if use_divide_mod:
            assert divisor >= 1, 'Unexpected divisor: {}'.format(divisor)

            self.divisor = self.create_param(param_name='divisor',
                                             shape=[1],
                                             initializer=('GivenTensorInt64Fill', {'values': np.array([divisor])}),
                                             optimizer=model.NoOptim)

            

Reported by Bandit.

              
            self.divisor = self.create_param(param_name='divisor',
                                             shape=[1],
                                             initializer=('GivenTensorInt64Fill', {'values': np.array([divisor])}),
                                             optimizer=model.NoOptim)

        self.seed = seed
        self.use_hashing = use_hashing
        self.use_divide_mod = use_divide_mod

            

Reported by Pylint.

                          self.modulo = modulo or self.extract_hash_size(input_record.items.metadata)
            metadata = schema.Metadata(
                categorical_limit=self.modulo,
                feature_specs=input_record.items.metadata.feature_specs if input_record.items.metadata else None,
                expected_value=input_record.items.metadata.expected_value if input_record.items.metadata else None
            )
            with core.NameScope(name):
                self.output_schema = schema.NewRecord(model.net, IdList)
            self.output_schema.items.set_metadata(metadata)

            

Reported by Pylint.

              # that all the results look right. In default, it is disabled unless you
# explicitly want to run it.

from google.protobuf import text_format
import numpy as np
import os
import sys

CAFFE_FOUND = False

            

Reported by Pylint.

              
CAFFE_FOUND = False
try:
    from caffe.proto import caffe_pb2
    from caffe2.python import caffe_translator
    CAFFE_FOUND = True
except Exception as e:
    # Safeguard so that we only catch the caffe module not found exception.
    if ("'caffe'" in str(e)):

            

Reported by Pylint.

                  from caffe.proto import caffe_pb2
    from caffe2.python import caffe_translator
    CAFFE_FOUND = True
except Exception as e:
    # Safeguard so that we only catch the caffe module not found exception.
    if ("'caffe'" in str(e)):
        print(
            "PyTorch/Caffe2 now requires a separate installation of caffe. "
            "Right now, this is not found, so we will skip the caffe "

            

Reported by Pylint.

              # This a large test that goes through the translation of the bvlc caffenet
# model, runs an example through the whole model, and verifies numerically
# that all the results look right. In default, it is disabled unless you
# explicitly want to run it.

from google.protobuf import text_format
import numpy as np
import os
import sys

            

Reported by Pylint.

              
from google.protobuf import text_format
import numpy as np
import os
import sys

CAFFE_FOUND = False
try:
    from caffe.proto import caffe_pb2

            

Reported by Pylint.

              from google.protobuf import text_format
import numpy as np
import os
import sys

CAFFE_FOUND = False
try:
    from caffe.proto import caffe_pb2
    from caffe2.python import caffe_translator

            

Reported by Pylint.

                  from caffe.proto import caffe_pb2
    from caffe2.python import caffe_translator
    CAFFE_FOUND = True
except Exception as e:
    # Safeguard so that we only catch the caffe module not found exception.
    if ("'caffe'" in str(e)):
        print(
            "PyTorch/Caffe2 now requires a separate installation of caffe. "
            "Right now, this is not found, so we will skip the caffe "

            

Reported by Pylint.

                  CAFFE_FOUND = True
except Exception as e:
    # Safeguard so that we only catch the caffe module not found exception.
    if ("'caffe'" in str(e)):
        print(
            "PyTorch/Caffe2 now requires a separate installation of caffe. "
            "Right now, this is not found, so we will skip the caffe "
            "translator test.")


            

Reported by Pylint.

                          "Right now, this is not found, so we will skip the caffe "
            "translator test.")

from caffe2.python import utils, workspace, test_util
import unittest

def setUpModule():
    # Do nothing if caffe and test data is not found
    if not (CAFFE_FOUND and os.path.exists('data/testdata/caffe_translator')):

            

Reported by Pylint.

                          "translator test.")

from caffe2.python import utils, workspace, test_util
import unittest

def setUpModule():
    # Do nothing if caffe and test data is not found
    if not (CAFFE_FOUND and os.path.exists('data/testdata/caffe_translator')):
        return

            

Reported by Pylint.

              import operator_benchmark as op_bench
import torch

"""Microbenchmarks for linear_prepack_fp16_ operator. Supports both Caffe2/PyTorch."""

# Configs for PT linear_prepack_fp16 operator
linear_prepack_fp16_long_configs = op_bench.cross_product_configs(
    M=[8, 128],
    N=[32, 64],

            

Reported by Pylint.

              """Microbenchmarks for linear_prepack_fp16_ operator. Supports both Caffe2/PyTorch."""

# Configs for PT linear_prepack_fp16 operator
linear_prepack_fp16_long_configs = op_bench.cross_product_configs(
    M=[8, 128],
    N=[32, 64],
    K=[256, 512],
    device=['cpu'],
    tags=["long"]

            

Reported by Pylint.

                  tags=["long"]
)

linear_prepack_fp16_short_configs = op_bench.config_list(
    attr_names=["M", "N", "K"],
    attrs=[
        [1, 1, 1],
        [64, 64, 64],
        [64, 64, 128],

            

Reported by Pylint.

                  tags=["short"],
)

class LinearPrepackFP16Benchmark(op_bench.TorchBenchmarkBase):
    def init(self, M, N, K, device):
        self.inputs = {
            "input_one": torch.rand(M, N, K, device=device, requires_grad=False, dtype=torch.float32)
        }
        self.set_module_name("linear_prepack_fp16")

            

Reported by Pylint.

              # The generated test names based on linear_prepack_fp16_short_configs will be in the following pattern:
# linear_prepack_fp16_M8_N16_K32_devicecpu

op_bench.generate_pt_test(linear_prepack_fp16_long_configs + linear_prepack_fp16_short_configs, LinearPrepackFP16Benchmark)

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

            

Reported by Pylint.

              import operator_benchmark as op_bench
import torch

"""Microbenchmarks for linear_prepack_fp16_ operator. Supports both Caffe2/PyTorch."""

# Configs for PT linear_prepack_fp16 operator
linear_prepack_fp16_long_configs = op_bench.cross_product_configs(
    M=[8, 128],
    N=[32, 64],

            

Reported by Pylint.

              
class LinearPrepackFP16Benchmark(op_bench.TorchBenchmarkBase):
    def init(self, M, N, K, device):
        self.inputs = {
            "input_one": torch.rand(M, N, K, device=device, requires_grad=False, dtype=torch.float32)
        }
        self.set_module_name("linear_prepack_fp16")

    def forward(self, input_one):

            

Reported by Pylint.

              import operator_benchmark as op_bench
import torch

"""Microbenchmarks for linear_prepack_fp16_ operator. Supports both Caffe2/PyTorch."""

# Configs for PT linear_prepack_fp16 operator
linear_prepack_fp16_long_configs = op_bench.cross_product_configs(
    M=[8, 128],
    N=[32, 64],

            

Reported by Pylint.

                  tags=["short"],
)

class LinearPrepackFP16Benchmark(op_bench.TorchBenchmarkBase):
    def init(self, M, N, K, device):
        self.inputs = {
            "input_one": torch.rand(M, N, K, device=device, requires_grad=False, dtype=torch.float32)
        }
        self.set_module_name("linear_prepack_fp16")

            

Reported by Pylint.

              )

class LinearPrepackFP16Benchmark(op_bench.TorchBenchmarkBase):
    def init(self, M, N, K, device):
        self.inputs = {
            "input_one": torch.rand(M, N, K, device=device, requires_grad=False, dtype=torch.float32)
        }
        self.set_module_name("linear_prepack_fp16")


            

Reported by Pylint.