from caffe2.python import workspace, scope
from caffe2.python.model_helper import ModelHelper

import numpy as np

            

Reported by Pylint.

              import numpy as np


def sigmoid(x):
    return 1.0 / (1.0 + np.exp(-x))


def tanh(x):
    return 2.0 * sigmoid(2.0 * x) - 1

            

Reported by Pylint.

              import numpy as np


def sigmoid(x):
    return 1.0 / (1.0 + np.exp(-x))


def tanh(x):
    return 2.0 * sigmoid(2.0 * x) - 1

            

Reported by Pylint.

                  return 1.0 / (1.0 + np.exp(-x))


def tanh(x):
    return 2.0 * sigmoid(2.0 * x) - 1


def _prepare_rnn(
    t, n, dim_in, create_rnn, outputs_with_grads,

            

Reported by Pylint.

                  return 1.0 / (1.0 + np.exp(-x))


def tanh(x):
    return 2.0 * sigmoid(2.0 * x) - 1


def _prepare_rnn(
    t, n, dim_in, create_rnn, outputs_with_grads,

            

Reported by Pylint.

                  return 2.0 * sigmoid(2.0 * x) - 1


def _prepare_rnn(
    t, n, dim_in, create_rnn, outputs_with_grads,
    forget_bias, memory_optim=False,
    forward_only=False, drop_states=False, T=None,
    two_d_initial_states=None, dim_out=None,
    num_states=2,

            

Reported by Pylint.

                  return 2.0 * sigmoid(2.0 * x) - 1


def _prepare_rnn(
    t, n, dim_in, create_rnn, outputs_with_grads,
    forget_bias, memory_optim=False,
    forward_only=False, drop_states=False, T=None,
    two_d_initial_states=None, dim_out=None,
    num_states=2,

            

Reported by Pylint.

                  return 2.0 * sigmoid(2.0 * x) - 1


def _prepare_rnn(
    t, n, dim_in, create_rnn, outputs_with_grads,
    forget_bias, memory_optim=False,
    forward_only=False, drop_states=False, T=None,
    two_d_initial_states=None, dim_out=None,
    num_states=2,

            

Reported by Pylint.

                  return 2.0 * sigmoid(2.0 * x) - 1


def _prepare_rnn(
    t, n, dim_in, create_rnn, outputs_with_grads,
    forget_bias, memory_optim=False,
    forward_only=False, drop_states=False, T=None,
    two_d_initial_states=None, dim_out=None,
    num_states=2,

            

Reported by Pylint.

                  return 2.0 * sigmoid(2.0 * x) - 1


def _prepare_rnn(
    t, n, dim_in, create_rnn, outputs_with_grads,
    forget_bias, memory_optim=False,
    forward_only=False, drop_states=False, T=None,
    two_d_initial_states=None, dim_out=None,
    num_states=2,

            

Reported by Pylint.

              

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



            

Reported by Pylint.

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


class TestAssert(hu.HypothesisTestCase):

            

Reported by Pylint.

                      shape=st.lists(elements=st.integers(1, 10), min_size=1, max_size=4),
        **hu.gcs)
    @settings(deadline=10000)
    def test_assert(self, dtype, shape, gc, dc):
        test_tensor = np.random.rand(*shape).astype(np.dtype(dtype))

        op = core.CreateOperator('Assert', ['X'], [])

        def assert_ref(X):

            

Reported by Pylint.

              
        op = core.CreateOperator('Assert', ['X'], [])

        def assert_ref(X):
            return []

        try:
            self.assertReferenceChecks(gc, op, [test_tensor], assert_ref)
        except Exception:

            

Reported by Pylint.

              
        try:
            self.assertReferenceChecks(gc, op, [test_tensor], assert_ref)
        except Exception:
            assert(not np.all(test_tensor))

            

Reported by Pylint.

              



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

            

Reported by Pylint.

              import caffe2.python.hypothesis_test_util as hu


class TestAssert(hu.HypothesisTestCase):
    @given(
        dtype=st.sampled_from(['bool_', 'int32', 'int64']),
        shape=st.lists(elements=st.integers(1, 10), min_size=1, max_size=4),
        **hu.gcs)
    @settings(deadline=10000)

            

Reported by Pylint.

                      shape=st.lists(elements=st.integers(1, 10), min_size=1, max_size=4),
        **hu.gcs)
    @settings(deadline=10000)
    def test_assert(self, dtype, shape, gc, dc):
        test_tensor = np.random.rand(*shape).astype(np.dtype(dtype))

        op = core.CreateOperator('Assert', ['X'], [])

        def assert_ref(X):

            

Reported by Pylint.

                      shape=st.lists(elements=st.integers(1, 10), min_size=1, max_size=4),
        **hu.gcs)
    @settings(deadline=10000)
    def test_assert(self, dtype, shape, gc, dc):
        test_tensor = np.random.rand(*shape).astype(np.dtype(dtype))

        op = core.CreateOperator('Assert', ['X'], [])

        def assert_ref(X):

            

Reported by Pylint.

                      shape=st.lists(elements=st.integers(1, 10), min_size=1, max_size=4),
        **hu.gcs)
    @settings(deadline=10000)
    def test_assert(self, dtype, shape, gc, dc):
        test_tensor = np.random.rand(*shape).astype(np.dtype(dtype))

        op = core.CreateOperator('Assert', ['X'], [])

        def assert_ref(X):

            

Reported by Pylint.

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

class PythonOpTest(hu.HypothesisTestCase):

            

Reported by Pylint.

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

class PythonOpTest(hu.HypothesisTestCase):
    @given(x=hu.tensor(),

            

Reported by Pylint.

              

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

            

Reported by Pylint.

              



from caffe2.python import core, workspace
from caffe2.python.core import CreatePythonOperator
import caffe2.python.hypothesis_test_util as hu
from hypothesis import given, settings
import hypothesis.strategies as st

            

Reported by Pylint.

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

class PythonOpTest(hu.HypothesisTestCase):
    @given(x=hu.tensor(),
           n=st.integers(min_value=1, max_value=20),
           w=st.integers(min_value=1, max_value=20))

            

Reported by Pylint.

              import numpy as np
import unittest

class PythonOpTest(hu.HypothesisTestCase):
    @given(x=hu.tensor(),
           n=st.integers(min_value=1, max_value=20),
           w=st.integers(min_value=1, max_value=20))
    @settings(deadline=10000)
    def test_simple_python_op(self, x, n, w):

            

Reported by Pylint.

                         n=st.integers(min_value=1, max_value=20),
           w=st.integers(min_value=1, max_value=20))
    @settings(deadline=10000)
    def test_simple_python_op(self, x, n, w):
        def g(input_, output):
            output[...] = input_

        def f(inputs, outputs):
            outputs[0].reshape(inputs[0].shape)

            

Reported by Pylint.

                         n=st.integers(min_value=1, max_value=20),
           w=st.integers(min_value=1, max_value=20))
    @settings(deadline=10000)
    def test_simple_python_op(self, x, n, w):
        def g(input_, output):
            output[...] = input_

        def f(inputs, outputs):
            outputs[0].reshape(inputs[0].shape)

            

Reported by Pylint.

                         n=st.integers(min_value=1, max_value=20),
           w=st.integers(min_value=1, max_value=20))
    @settings(deadline=10000)
    def test_simple_python_op(self, x, n, w):
        def g(input_, output):
            output[...] = input_

        def f(inputs, outputs):
            outputs[0].reshape(inputs[0].shape)

            

Reported by Pylint.

                         n=st.integers(min_value=1, max_value=20),
           w=st.integers(min_value=1, max_value=20))
    @settings(deadline=10000)
    def test_simple_python_op(self, x, n, w):
        def g(input_, output):
            output[...] = input_

        def f(inputs, outputs):
            outputs[0].reshape(inputs[0].shape)

            

Reported by Pylint.

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


class TestIndexHashOps(serial.SerializedTestCase):

            

Reported by Pylint.

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


class TestIndexHashOps(serial.SerializedTestCase):
    @given(

            

Reported by Pylint.

              




from caffe2.python import core, workspace
import caffe2.python.hypothesis_test_util as hu
import caffe2.python.serialized_test.serialized_test_util as serial
import hypothesis.strategies as st

            

Reported by Pylint.

              import numpy as np


class TestIndexHashOps(serial.SerializedTestCase):
    @given(
        indices=st.sampled_from([
            np.int32, np.int64
        ]).flatmap(lambda dtype: hu.tensor(min_dim=1, max_dim=1, dtype=dtype)),
        seed=st.integers(min_value=0, max_value=10),

            

Reported by Pylint.

                      modulo=st.integers(min_value=100000, max_value=200000),
        **hu.gcs_cpu_only
    )
    @settings(deadline=10000)
    def test_index_hash_ops(self, indices, seed, modulo, gc, dc):
        def index_hash(indices):
            dtype = np.array(indices).dtype
            assert dtype == np.int32 or dtype == np.int64
            hashed_indices = []

            

Reported by Pylint.

                      modulo=st.integers(min_value=100000, max_value=200000),
        **hu.gcs_cpu_only
    )
    @settings(deadline=10000)
    def test_index_hash_ops(self, indices, seed, modulo, gc, dc):
        def index_hash(indices):
            dtype = np.array(indices).dtype
            assert dtype == np.int32 or dtype == np.int64
            hashed_indices = []

            

Reported by Pylint.

                      modulo=st.integers(min_value=100000, max_value=200000),
        **hu.gcs_cpu_only
    )
    @settings(deadline=10000)
    def test_index_hash_ops(self, indices, seed, modulo, gc, dc):
        def index_hash(indices):
            dtype = np.array(indices).dtype
            assert dtype == np.int32 or dtype == np.int64
            hashed_indices = []

            

Reported by Pylint.

                      modulo=st.integers(min_value=100000, max_value=200000),
        **hu.gcs_cpu_only
    )
    @settings(deadline=10000)
    def test_index_hash_ops(self, indices, seed, modulo, gc, dc):
        def index_hash(indices):
            dtype = np.array(indices).dtype
            assert dtype == np.int32 or dtype == np.int64
            hashed_indices = []

            

Reported by Pylint.

                  def test_index_hash_ops(self, indices, seed, modulo, gc, dc):
        def index_hash(indices):
            dtype = np.array(indices).dtype
            assert dtype == np.int32 or dtype == np.int64
            hashed_indices = []
            for index in indices:
                hashed = dtype.type(0xDEADBEEF * seed)
                indices_bytes = np.array([index], dtype).view(np.int8)
                for b in indices_bytes:

            

Reported by Pylint.

                  def test_index_hash_ops(self, indices, seed, modulo, gc, dc):
        def index_hash(indices):
            dtype = np.array(indices).dtype
            assert dtype == np.int32 or dtype == np.int64
            hashed_indices = []
            for index in indices:
                hashed = dtype.type(0xDEADBEEF * seed)
                indices_bytes = np.array([index], dtype).view(np.int8)
                for b in indices_bytes:

            

Reported by Bandit.

                          out2 = pipe(out1, processor=proc2)
            pipe(out2, dst_ds.writer())

        ws = workspace.C.Workspace()
        FeedRecord(src_blobs, src_values, ws)
        session = LocalSession(ws)
        session.run(init_net)
        session.run(tg)
        output = FetchRecord(dst_blobs, ws=ws)

            

Reported by Pylint.

                      output = FetchRecord(dst_blobs, ws=ws)
        num_dequeues = ws.blobs[str(counter)].fetch()

        self.assertEquals(
            num_dequeues, int(math.ceil(float(N) / NUM_DEQUEUE_RECORDS)))

        for a, b in zip(output.field_blobs(), expected_dst.field_blobs()):
            np.testing.assert_array_equal(a, b)

            

Reported by Pylint.

              




from caffe2.python.schema import (
    Struct, FetchRecord, NewRecord, FeedRecord, InitEmptyRecord)
from caffe2.python import core, workspace
from caffe2.python.session import LocalSession

            

Reported by Pylint.

              from caffe2.python.test_util import TestCase
from caffe2.python.net_builder import ops
import numpy as np
import math


class TestPipeline(TestCase):
    def test_dequeue_many(self):
        init_net = core.Net('init')

            

Reported by Pylint.

              import math


class TestPipeline(TestCase):
    def test_dequeue_many(self):
        init_net = core.Net('init')
        N = 17
        NUM_DEQUEUE_RECORDS = 3
        src_values = Struct(

            

Reported by Pylint.

              

class TestPipeline(TestCase):
    def test_dequeue_many(self):
        init_net = core.Net('init')
        N = 17
        NUM_DEQUEUE_RECORDS = 3
        src_values = Struct(
            ('uid', np.array(range(N))),

            

Reported by Pylint.

              

class TestPipeline(TestCase):
    def test_dequeue_many(self):
        init_net = core.Net('init')
        N = 17
        NUM_DEQUEUE_RECORDS = 3
        src_values = Struct(
            ('uid', np.array(range(N))),

            

Reported by Pylint.

              class TestPipeline(TestCase):
    def test_dequeue_many(self):
        init_net = core.Net('init')
        N = 17
        NUM_DEQUEUE_RECORDS = 3
        src_values = Struct(
            ('uid', np.array(range(N))),
            ('value', 0.1 * np.array(range(N))))
        expected_dst = Struct(

            

Reported by Pylint.

                  def test_dequeue_many(self):
        init_net = core.Net('init')
        N = 17
        NUM_DEQUEUE_RECORDS = 3
        src_values = Struct(
            ('uid', np.array(range(N))),
            ('value', 0.1 * np.array(range(N))))
        expected_dst = Struct(
            ('uid', 2 * np.array(range(N))),

            

Reported by Pylint.

                          src_blobs = NewRecord(init_net, src_values)
            dst_blobs = InitEmptyRecord(init_net, src_values.clone_schema())
            counter = init_net.Const(0)
            ONE = init_net.Const(1)

        def proc1(rec):
            with core.NameScope('proc1'):
                out = NewRecord(ops, rec)
            ops.Add([rec.uid(), rec.uid()], [out.uid()])

            

Reported by Pylint.

              import time

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



            

Reported by Pylint.

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


np.set_printoptions(precision=6)



            

Reported by Pylint.

                      **hu.gcs
    )
    @settings(deadline=10000)
    def test_speed_of_rand_quantization(self, bitwidth_, random_, data_shape_, gc, dc):
        X1 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)
        X2 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)

        sub_scale_sum_net = core.Net("sub_scale_sum")
        sub_op = core.CreateOperator("Sub", ["X1", "X2"], ["dX"])

            

Reported by Pylint.

                      **hu.gcs
    )
    @settings(deadline=10000)
    def test_speed_of_rand_quantization(self, bitwidth_, random_, data_shape_, gc, dc):
        X1 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)
        X2 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)

        sub_scale_sum_net = core.Net("sub_scale_sum")
        sub_op = core.CreateOperator("Sub", ["X1", "X2"], ["dX"])

            

Reported by Pylint.

              

import time

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

            

Reported by Pylint.

              np.set_printoptions(precision=6)


class TestSpeedFloatToFusedRandRowwiseQuantized(hu.HypothesisTestCase):
    @given(
        bitwidth_=st.sampled_from([1, 2, 4, 8]),
        random_=st.sampled_from([True, False]),
        data_shape_=st.sampled_from(
            [

            

Reported by Pylint.

                      ),
        **hu.gcs
    )
    @settings(deadline=10000)
    def test_speed_of_rand_quantization(self, bitwidth_, random_, data_shape_, gc, dc):
        X1 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)
        X2 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)

        sub_scale_sum_net = core.Net("sub_scale_sum")

            

Reported by Pylint.

                      ),
        **hu.gcs
    )
    @settings(deadline=10000)
    def test_speed_of_rand_quantization(self, bitwidth_, random_, data_shape_, gc, dc):
        X1 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)
        X2 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)

        sub_scale_sum_net = core.Net("sub_scale_sum")

            

Reported by Pylint.

                      ),
        **hu.gcs
    )
    @settings(deadline=10000)
    def test_speed_of_rand_quantization(self, bitwidth_, random_, data_shape_, gc, dc):
        X1 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)
        X2 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)

        sub_scale_sum_net = core.Net("sub_scale_sum")

            

Reported by Pylint.

                      ),
        **hu.gcs
    )
    @settings(deadline=10000)
    def test_speed_of_rand_quantization(self, bitwidth_, random_, data_shape_, gc, dc):
        X1 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)
        X2 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)

        sub_scale_sum_net = core.Net("sub_scale_sum")

            

Reported by Pylint.

              


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

from caffe2.python import core

            

Reported by Pylint.

              

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

from caffe2.python import core
import caffe2.python.hypothesis_test_util as hu

            

Reported by Pylint.

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

from caffe2.python import core
import caffe2.python.hypothesis_test_util as hu


            

Reported by Pylint.

                         reg_lambda=st.floats(min_value=1e-4, max_value=1e-1),
           data_strategy=st.data(),
           **hu.gcs_cpu_only)
    def test_sparse_lpnorm(self, inputs, p, reg_lambda, data_strategy, gc, dc):

        param, = inputs
        param += 0.02 * np.sign(param)
        param[param == 0.0] += 0.02


            

Reported by Pylint.

                          reg_lambda=reg_lambda,
        )

        def ref_sparse_lp_regularizer(param, indices, grad=None):
            param_out = np.copy(param)
            for _, index in enumerate(indices):
                param_out[index] = self.ref_lpnorm(
                    param[index],
                    p=p,

            

Reported by Pylint.

              




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

            

Reported by Pylint.

              import caffe2.python.hypothesis_test_util as hu


class TestSparseLpNorm(hu.HypothesisTestCase):

    @staticmethod
    def ref_lpnorm(param_in, p, reg_lambda):
        """Reference function that should be matched by the Caffe2 operator."""
        if p == 2.0:

            

Reported by Pylint.

              class TestSparseLpNorm(hu.HypothesisTestCase):

    @staticmethod
    def ref_lpnorm(param_in, p, reg_lambda):
        """Reference function that should be matched by the Caffe2 operator."""
        if p == 2.0:
            return param_in * (1 - reg_lambda)
        if p == 1.0:
            reg_term = np.ones_like(param_in) * reg_lambda * np.sign(param_in)

            

Reported by Pylint.

                         reg_lambda=st.floats(min_value=1e-4, max_value=1e-1),
           data_strategy=st.data(),
           **hu.gcs_cpu_only)
    def test_sparse_lpnorm(self, inputs, p, reg_lambda, data_strategy, gc, dc):

        param, = inputs
        param += 0.02 * np.sign(param)
        param[param == 0.0] += 0.02


            

Reported by Pylint.

                         reg_lambda=st.floats(min_value=1e-4, max_value=1e-1),
           data_strategy=st.data(),
           **hu.gcs_cpu_only)
    def test_sparse_lpnorm(self, inputs, p, reg_lambda, data_strategy, gc, dc):

        param, = inputs
        param += 0.02 * np.sign(param)
        param[param == 0.0] += 0.02


            

Reported by Pylint.

              

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

import unittest

            

Reported by Pylint.

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

import unittest



            

Reported by Pylint.

                      s=st.integers(10, 500),
        **hu.gcs_cpu_only
    )
    def test_unique_uniform_int_fill(self, r, avoid, dtypes, s, gc, dc):
        net = core.Net("net")
        workspace.FeedBlob("X", np.array([s], dtype=np.int64))
        workspace.FeedBlob("AVOID", np.array(avoid, dtype=dtypes[0]))
        net.UniqueUniformFill(
            ["X", "AVOID"], ["Y"],

            

Reported by Pylint.

                      s=st.integers(10, 500),
        **hu.gcs_cpu_only
    )
    def test_unique_uniform_int_fill(self, r, avoid, dtypes, s, gc, dc):
        net = core.Net("net")
        workspace.FeedBlob("X", np.array([s], dtype=np.int64))
        workspace.FeedBlob("AVOID", np.array(avoid, dtype=dtypes[0]))
        net.UniqueUniformFill(
            ["X", "AVOID"], ["Y"],

            

Reported by Pylint.

              



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

            

Reported by Pylint.

              import hypothesis.strategies as st
import numpy as np

import unittest


class TestUniqueUniformFillOp(hu.HypothesisTestCase):
    @given(
        r=st.integers(1000, 10000),

            

Reported by Pylint.

              import unittest


class TestUniqueUniformFillOp(hu.HypothesisTestCase):
    @given(
        r=st.integers(1000, 10000),
        avoid=st.lists(
            st.integers(1, 1000),
            min_size=1,

            

Reported by Pylint.

                      ),
        s=st.integers(10, 500),
        **hu.gcs_cpu_only
    )
    def test_unique_uniform_int_fill(self, r, avoid, dtypes, s, gc, dc):
        net = core.Net("net")
        workspace.FeedBlob("X", np.array([s], dtype=np.int64))
        workspace.FeedBlob("AVOID", np.array(avoid, dtype=dtypes[0]))
        net.UniqueUniformFill(

            

Reported by Pylint.

                      ),
        s=st.integers(10, 500),
        **hu.gcs_cpu_only
    )
    def test_unique_uniform_int_fill(self, r, avoid, dtypes, s, gc, dc):
        net = core.Net("net")
        workspace.FeedBlob("X", np.array([s], dtype=np.int64))
        workspace.FeedBlob("AVOID", np.array(avoid, dtype=dtypes[0]))
        net.UniqueUniformFill(

            

Reported by Pylint.

                      ),
        s=st.integers(10, 500),
        **hu.gcs_cpu_only
    )
    def test_unique_uniform_int_fill(self, r, avoid, dtypes, s, gc, dc):
        net = core.Net("net")
        workspace.FeedBlob("X", np.array([s], dtype=np.int64))
        workspace.FeedBlob("AVOID", np.array(avoid, dtype=dtypes[0]))
        net.UniqueUniformFill(

            

Reported by Pylint.

              import argparse
import os.path
import sys
import torch


def get_custom_backend_library_path():
    """
    Get the path to the library containing the custom backend.

            

Reported by Pylint.

                  Returns:
        The module, lowered so that it can run on TestBackend.
    """
    lowered_module = torch._C._jit_to_backend("custom_backend", module, {"forward": {"": ""}})
    return lowered_module


class Model(torch.nn.Module):
    """

            

Reported by Pylint.

                  Returns:
        The module, lowered so that it can run on TestBackend.
    """
    lowered_module = torch._C._jit_to_backend("custom_backend", module, {"forward": {"": ""}})
    return lowered_module


class Model(torch.nn.Module):
    """

            

Reported by Pylint.

                  and executing in C++.
    """

    def __init__(self):
        super(Model, self).__init__()

    def forward(self, a, b):
        return (a + b, a - b)


            

Reported by Pylint.

              import argparse
import os.path
import sys
import torch


def get_custom_backend_library_path():
    """
    Get the path to the library containing the custom backend.

            

Reported by Pylint.

                  else:
        library_filename = "libcustom_backend.so"
    path = os.path.abspath("build/{}".format(library_filename))
    assert os.path.exists(path), path
    return path


def to_custom_backend(module):
    """

            

Reported by Bandit.

                  return lowered_module


class Model(torch.nn.Module):
    """
    Simple model used for testing that to_backend API supports saving, loading,
    and executing in C++.
    """


            

Reported by Pylint.

                  """

    def __init__(self):
        super(Model, self).__init__()

    def forward(self, a, b):
        return (a + b, a - b)



            

Reported by Pylint.

                  def __init__(self):
        super(Model, self).__init__()

    def forward(self, a, b):
        return (a + b, a - b)


def main():
    parser = argparse.ArgumentParser(

            

Reported by Pylint.

                  def __init__(self):
        super(Model, self).__init__()

    def forward(self, a, b):
        return (a + b, a - b)


def main():
    parser = argparse.ArgumentParser(

            

Reported by Pylint.

              

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

            

Reported by Pylint.

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

MAX_TEST_EMBEDDING_SIZE = 20
MAX_TEST_SEQUENCE_LENGTH = 10

            

Reported by Pylint.

                  )
    @settings(deadline=10000)
    def test_sinusoid_embedding(
        self, positions_vec, embedding_size, batch_size, alpha, amplitude, gc, dc
    ):
        positions = np.tile(positions_vec, [batch_size, 1]).transpose()

        op = core.CreateOperator(
            "SinusoidPositionEncoding",

            

Reported by Pylint.

              




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

            

Reported by Pylint.

              import caffe2.python.serialized_test.serialized_test_util as serial
import hypothesis.strategies as st
import numpy as np
import math

MAX_TEST_EMBEDDING_SIZE = 20
MAX_TEST_SEQUENCE_LENGTH = 10
MAX_TEST_BATCH_SIZE = 5
MIN_TEST_ALPHA = 5000.0

            

Reported by Pylint.

              MAX_TEST_AMPLITUDE = 10.0


class TestSinusoidPositionEncodingOp(serial.SerializedTestCase):
    @given(
        positions_vec=hu.arrays(
            dims=[MAX_TEST_SEQUENCE_LENGTH],
            dtype=np.int32,
            elements=st.integers(1, MAX_TEST_SEQUENCE_LENGTH)

            

Reported by Pylint.

                      amplitude=st.floats(MIN_TEST_AMPLITUDE, MAX_TEST_AMPLITUDE),
        **hu.gcs_cpu_only
    )
    @settings(deadline=10000)
    def test_sinusoid_embedding(
        self, positions_vec, embedding_size, batch_size, alpha, amplitude, gc, dc
    ):
        positions = np.tile(positions_vec, [batch_size, 1]).transpose()


            

Reported by Pylint.

                      amplitude=st.floats(MIN_TEST_AMPLITUDE, MAX_TEST_AMPLITUDE),
        **hu.gcs_cpu_only
    )
    @settings(deadline=10000)
    def test_sinusoid_embedding(
        self, positions_vec, embedding_size, batch_size, alpha, amplitude, gc, dc
    ):
        positions = np.tile(positions_vec, [batch_size, 1]).transpose()


            

Reported by Pylint.

                      amplitude=st.floats(MIN_TEST_AMPLITUDE, MAX_TEST_AMPLITUDE),
        **hu.gcs_cpu_only
    )
    @settings(deadline=10000)
    def test_sinusoid_embedding(
        self, positions_vec, embedding_size, batch_size, alpha, amplitude, gc, dc
    ):
        positions = np.tile(positions_vec, [batch_size, 1]).transpose()


            

Reported by Pylint.

                      amplitude=st.floats(MIN_TEST_AMPLITUDE, MAX_TEST_AMPLITUDE),
        **hu.gcs_cpu_only
    )
    @settings(deadline=10000)
    def test_sinusoid_embedding(
        self, positions_vec, embedding_size, batch_size, alpha, amplitude, gc, dc
    ):
        positions = np.tile(positions_vec, [batch_size, 1]).transpose()


            

Reported by Pylint.