import collections
import os

from absl import flags
from keras import callbacks
from keras.distribute import distribute_strategy_test
from keras.engine import base_layer
from keras.engine import sequential as sequential_model_lib
from keras.engine import training

            

Reported by Pylint.

              import os

from absl import flags
from keras import callbacks
from keras.distribute import distribute_strategy_test
from keras.engine import base_layer
from keras.engine import sequential as sequential_model_lib
from keras.engine import training
from keras.layers import convolutional as conv_layer_lib

            

Reported by Pylint.

              
from absl import flags
from keras import callbacks
from keras.distribute import distribute_strategy_test
from keras.engine import base_layer
from keras.engine import sequential as sequential_model_lib
from keras.engine import training
from keras.layers import convolutional as conv_layer_lib
from keras.layers import core as layer_lib

            

Reported by Pylint.

              from absl import flags
from keras import callbacks
from keras.distribute import distribute_strategy_test
from keras.engine import base_layer
from keras.engine import sequential as sequential_model_lib
from keras.engine import training
from keras.layers import convolutional as conv_layer_lib
from keras.layers import core as layer_lib
from keras.layers import pooling as pool_layer_lib

            

Reported by Pylint.

              from keras import callbacks
from keras.distribute import distribute_strategy_test
from keras.engine import base_layer
from keras.engine import sequential as sequential_model_lib
from keras.engine import training
from keras.layers import convolutional as conv_layer_lib
from keras.layers import core as layer_lib
from keras.layers import pooling as pool_layer_lib
import numpy as np

            

Reported by Pylint.

              from keras.distribute import distribute_strategy_test
from keras.engine import base_layer
from keras.engine import sequential as sequential_model_lib
from keras.engine import training
from keras.layers import convolutional as conv_layer_lib
from keras.layers import core as layer_lib
from keras.layers import pooling as pool_layer_lib
import numpy as np
import tensorflow.compat.v2 as tf

            

Reported by Pylint.

              from keras.engine import base_layer
from keras.engine import sequential as sequential_model_lib
from keras.engine import training
from keras.layers import convolutional as conv_layer_lib
from keras.layers import core as layer_lib
from keras.layers import pooling as pool_layer_lib
import numpy as np
import tensorflow.compat.v2 as tf


            

Reported by Pylint.

              from keras.engine import sequential as sequential_model_lib
from keras.engine import training
from keras.layers import convolutional as conv_layer_lib
from keras.layers import core as layer_lib
from keras.layers import pooling as pool_layer_lib
import numpy as np
import tensorflow.compat.v2 as tf

from tensorboard.plugins.histogram import summary_v2 as histogram_summary_v2

            

Reported by Pylint.

              from keras.engine import training
from keras.layers import convolutional as conv_layer_lib
from keras.layers import core as layer_lib
from keras.layers import pooling as pool_layer_lib
import numpy as np
import tensorflow.compat.v2 as tf

from tensorboard.plugins.histogram import summary_v2 as histogram_summary_v2
from tensorboard.plugins.image import summary_v2 as image_summary_v2

            

Reported by Pylint.

              from keras.layers import core as layer_lib
from keras.layers import pooling as pool_layer_lib
import numpy as np
import tensorflow.compat.v2 as tf

from tensorboard.plugins.histogram import summary_v2 as histogram_summary_v2
from tensorboard.plugins.image import summary_v2 as image_summary_v2
from tensorboard.plugins.scalar import summary_v2 as scalar_summary_v2
from tensorflow.python.eager.context import set_soft_device_placement  # pylint: disable=g-direct-tensorflow-import

            

Reported by Pylint.

              # ==============================================================================
"""Custom Training Loop correctness test."""

import tensorflow.compat.v2 as tf

from absl.testing import parameterized
import numpy as np

import keras

            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

from absl.testing import parameterized
import numpy as np

import keras
from keras.distribute import optimizer_combinations
from keras.distribute import strategy_combinations

            

Reported by Pylint.

                def test_dnn_correctness_minus_tpus(self, distribution, optimizer_fn,
                                      iteration_type, inside_func,
                                      sync_batchnorm, jit_compile):
    # TODO(anjs): Identify why this particular V1 optimizer needs a higher tol.
    if 'FtrlV1' in optimizer_fn._name and 'TPU' in type(distribution).__name__:
      self.skipTest('Reduced tolerance of the order of 1e-1 required.')
    self.dnn_correctness(distribution, optimizer_fn, iteration_type,
                         inside_func, sync_batchnorm, jit_compile)


            

Reported by Pylint.

                                                    iteration_type, inside_func,
                                      sync_batchnorm, jit_compile):
    # TODO(anjs): Identify why this particular V1 optimizer needs a higher tol.
    if 'FtrlV1' in optimizer_fn._name and 'TPU' in type(distribution).__name__:
      self.skipTest('Reduced tolerance of the order of 1e-1 required.')
    self.dnn_correctness(distribution, optimizer_fn, iteration_type,
                         inside_func, sync_batchnorm, jit_compile)

  def dnn_correctness(self,

            

Reported by Pylint.

              

class MaybeStrategyScope:
  """Provides a context allowing no distribution strategy."""

  def __init__(self, strategy):
    self._strategy = strategy
    self._scope = None


            

Reported by Pylint.

              class MaybeStrategyScope:
  """Provides a context allowing no distribution strategy."""

  def __init__(self, strategy):
    self._strategy = strategy
    self._scope = None

  def __enter__(self):
    if self._strategy:

            

Reported by Pylint.

                """Provides a context allowing no distribution strategy."""

  def __init__(self, strategy):
    self._strategy = strategy
    self._scope = None

  def __enter__(self):
    if self._strategy:
      self._scope = self._strategy.scope()

            

Reported by Pylint.

              
  def __init__(self, strategy):
    self._strategy = strategy
    self._scope = None

  def __enter__(self):
    if self._strategy:
      self._scope = self._strategy.scope()
      self._scope.__enter__()

            

Reported by Pylint.

                  self._strategy = strategy
    self._scope = None

  def __enter__(self):
    if self._strategy:
      self._scope = self._strategy.scope()
      self._scope.__enter__()

  def __exit__(self, exc_type, value, traceback):

            

Reported by Pylint.

                  self._scope = None

  def __enter__(self):
    if self._strategy:
      self._scope = self._strategy.scope()
      self._scope.__enter__()

  def __exit__(self, exc_type, value, traceback):
    if self._strategy:

            

Reported by Pylint.

                    http://arxiv.org/abs/1512.00567) (CVPR 2016)
"""

import tensorflow.compat.v2 as tf

from keras import backend
from keras.applications import imagenet_utils
from keras.engine import training
from keras.layers import VersionAwareLayers

            

Reported by Pylint.

              from keras.layers import VersionAwareLayers
from keras.utils import data_utils
from keras.utils import layer_utils
from tensorflow.python.util.tf_export import keras_export


WEIGHTS_PATH = (
    'https://storage.googleapis.com/tensorflow/keras-applications/'
    'inception_v3/inception_v3_weights_tf_dim_ordering_tf_kernels.h5')

            

Reported by Pylint.

              
@keras_export('keras.applications.inception_v3.InceptionV3',
              'keras.applications.InceptionV3')
def InceptionV3(
    include_top=True,
    weights='imagenet',
    input_tensor=None,
    input_shape=None,
    pooling=None,

            

Reported by Pylint.

              
@keras_export('keras.applications.inception_v3.InceptionV3',
              'keras.applications.InceptionV3')
def InceptionV3(
    include_top=True,
    weights='imagenet',
    input_tensor=None,
    input_shape=None,
    pooling=None,

            

Reported by Pylint.

              
@keras_export('keras.applications.inception_v3.InceptionV3',
              'keras.applications.InceptionV3')
def InceptionV3(
    include_top=True,
    weights='imagenet',
    input_tensor=None,
    input_shape=None,
    pooling=None,

            

Reported by Pylint.

              
@keras_export('keras.applications.inception_v3.InceptionV3',
              'keras.applications.InceptionV3')
def InceptionV3(
    include_top=True,
    weights='imagenet',
    input_tensor=None,
    input_shape=None,
    pooling=None,

            

Reported by Pylint.

                  pooling=None,
    classes=1000,
    classifier_activation='softmax'):
  """Instantiates the Inception v3 architecture.

  Reference:
  - [Rethinking the Inception Architecture for Computer Vision](
      http://arxiv.org/abs/1512.00567) (CVPR 2016)


            

Reported by Pylint.

                Returns:
    A `keras.Model` instance.
  """
  if not (weights in {'imagenet', None} or tf.io.gfile.exists(weights)):
    raise ValueError('The `weights` argument should be either '
                     '`None` (random initialization), `imagenet` '
                     '(pre-training on ImageNet), '
                     'or the path to the weights file to be loaded; '
                     f'Received: weights={weights}')

            

Reported by Pylint.

                  A `keras.Model` instance.
  """
  if not (weights in {'imagenet', None} or tf.io.gfile.exists(weights)):
    raise ValueError('The `weights` argument should be either '
                     '`None` (random initialization), `imagenet` '
                     '(pre-training on ImageNet), '
                     'or the path to the weights file to be loaded; '
                     f'Received: weights={weights}')


            

Reported by Pylint.

                                   'or the path to the weights file to be loaded; '
                     f'Received: weights={weights}')

  if weights == 'imagenet' and include_top and classes != 1000:
    raise ValueError('If using `weights` as `"imagenet"` with `include_top` '
                     'as true, `classes` should be 1000; '
                     f'Received classes={classes}')

  # Determine proper input shape

            

Reported by Pylint.

              # ==============================================================================
"""Tests for SimpleRNN layer."""

import tensorflow.compat.v2 as tf

import copy

from absl.testing import parameterized
import numpy as np

            

Reported by Pylint.

              
import copy

from absl.testing import parameterized
import numpy as np

import keras
from keras import combinations
from keras import testing_utils

            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

import copy

from absl.testing import parameterized
import numpy as np

import keras

            

Reported by Pylint.

              

@combinations.generate(combinations.keras_mode_combinations())
class SimpleRNNLayerTest(tf.test.TestCase, parameterized.TestCase):

  def test_return_sequences_SimpleRNN(self):
    num_samples = 2
    timesteps = 3
    embedding_dim = 4

            

Reported by Pylint.

              @combinations.generate(combinations.keras_mode_combinations())
class SimpleRNNLayerTest(tf.test.TestCase, parameterized.TestCase):

  def test_return_sequences_SimpleRNN(self):
    num_samples = 2
    timesteps = 3
    embedding_dim = 4
    units = 2
    testing_utils.layer_test(

            

Reported by Pylint.

              @combinations.generate(combinations.keras_mode_combinations())
class SimpleRNNLayerTest(tf.test.TestCase, parameterized.TestCase):

  def test_return_sequences_SimpleRNN(self):
    num_samples = 2
    timesteps = 3
    embedding_dim = 4
    units = 2
    testing_utils.layer_test(

            

Reported by Pylint.

              @combinations.generate(combinations.keras_mode_combinations())
class SimpleRNNLayerTest(tf.test.TestCase, parameterized.TestCase):

  def test_return_sequences_SimpleRNN(self):
    num_samples = 2
    timesteps = 3
    embedding_dim = 4
    units = 2
    testing_utils.layer_test(

            

Reported by Pylint.

              @combinations.generate(combinations.keras_mode_combinations())
class SimpleRNNLayerTest(tf.test.TestCase, parameterized.TestCase):

  def test_return_sequences_SimpleRNN(self):
    num_samples = 2
    timesteps = 3
    embedding_dim = 4
    units = 2
    testing_utils.layer_test(

            

Reported by Pylint.

              class SimpleRNNLayerTest(tf.test.TestCase, parameterized.TestCase):

  def test_return_sequences_SimpleRNN(self):
    num_samples = 2
    timesteps = 3
    embedding_dim = 4
    units = 2
    testing_utils.layer_test(
        keras.layers.SimpleRNN,

            

Reported by Pylint.

              
  def test_return_sequences_SimpleRNN(self):
    num_samples = 2
    timesteps = 3
    embedding_dim = 4
    units = 2
    testing_utils.layer_test(
        keras.layers.SimpleRNN,
        kwargs={'units': units,

            

Reported by Pylint.

              # ==============================================================================
"""Layers that act as activation functions."""

import tensorflow.compat.v2 as tf
from keras import backend
from keras import constraints
from keras import initializers
from keras import regularizers
from keras.engine.base_layer import Layer

            

Reported by Pylint.

              from keras.engine.base_layer import Layer
from keras.engine.input_spec import InputSpec
from keras.utils import tf_utils
from tensorflow.python.util.tf_export import keras_export


def get_globals():
  return globals()


            

Reported by Pylint.

                  self.supports_masking = True
    self.alpha = backend.cast_to_floatx(alpha)

  def call(self, inputs):
    return backend.relu(inputs, alpha=self.alpha)

  def get_config(self):
    config = {'alpha': float(self.alpha)}
    base_config = super(LeakyReLU, self).get_config()

            

Reported by Pylint.

                  if self.shared_axes is not None:
      for i in self.shared_axes:
        param_shape[i - 1] = 1
    self.alpha = self.add_weight(
        shape=param_shape,
        name='alpha',
        initializer=self.alpha_initializer,
        regularizer=self.alpha_regularizer,
        constraint=self.alpha_constraint)

            

Reported by Pylint.

                  self.input_spec = InputSpec(ndim=len(input_shape), axes=axes)
    self.built = True

  def call(self, inputs):
    pos = backend.relu(inputs)
    neg = -self.alpha * backend.relu(-inputs)
    return pos + neg

  def get_config(self):

            

Reported by Pylint.

                  self.supports_masking = True
    self.alpha = backend.cast_to_floatx(alpha)

  def call(self, inputs):
    return backend.elu(inputs, self.alpha)

  def get_config(self):
    config = {'alpha': float(self.alpha)}
    base_config = super(ELU, self).get_config()

            

Reported by Pylint.

                  self.supports_masking = True
    self.theta = backend.cast_to_floatx(theta)

  def call(self, inputs):
    theta = tf.cast(self.theta, inputs.dtype)
    return inputs * tf.cast(tf.greater(inputs, theta), inputs.dtype)

  def get_config(self):
    config = {'theta': float(self.theta)}

            

Reported by Pylint.

                  self.supports_masking = True
    self.axis = axis

  def call(self, inputs, mask=None):
    if mask is not None:
      # Since mask is 1.0 for positions we want to keep and 0.0 for
      # masked positions, this operation will create a tensor which is 0.0 for
      # positions we want to attend and -1e.9 for masked positions.
      adder = (1.0 - tf.cast(mask, inputs.dtype)) * (

            

Reported by Pylint.

                  self.negative_slope = backend.cast_to_floatx(negative_slope)
    self.threshold = backend.cast_to_floatx(threshold)

  def call(self, inputs):
    # alpha is used for leaky relu slope in activations instead of
    # negative_slope.
    return backend.relu(inputs,
                        alpha=self.negative_slope,
                        max_value=self.max_value,

            

Reported by Pylint.

              from tensorflow.python.util.tf_export import keras_export


def get_globals():
  return globals()


@keras_export('keras.layers.LeakyReLU')
class LeakyReLU(Layer):

            

Reported by Pylint.

              
from keras import layers
from keras.utils import traceback_utils
import tensorflow.compat.v2 as tf


class TracebackUtilsTest(tf.test.TestCase):

  def test_info_injection_basics(self):

            

Reported by Pylint.

                    fn()
    except Exception as e:  # pylint: disable=broad-except
      # Info should be injected exactly once.
      self.assertEqual(str(e).count('Call arguments received:'), 1)  # pylint: disable=g-assert-in-except

  def test_custom_layer_call_nested(self):

    class InnerLayer(layers.Layer):


            

Reported by Pylint.

              
    class InnerLayer(layers.Layer):

      def call(self, inputs, training=False, mask=None):
        return inputs + tf.zeros((3, 4))

    class OuterLayer(layers.Layer):

      def __init__(self):

            

Reported by Pylint.

              
    class InnerLayer(layers.Layer):

      def call(self, inputs, training=False, mask=None):
        return inputs + tf.zeros((3, 4))

    class OuterLayer(layers.Layer):

      def __init__(self):

            

Reported by Pylint.

              
    class InnerLayer(layers.Layer):

      def call(self, inputs, training=False, mask=None):
        return inputs + tf.zeros((3, 4))

    class OuterLayer(layers.Layer):

      def __init__(self):

            

Reported by Pylint.

                      super().__init__()
        self.inner = InnerLayer()

      def call(self, inputs, training=True):
        return self.inner(inputs)

    def fn():
      layer = OuterLayer()
      layer(tf.zeros((3, 5)), training=False)

            

Reported by Pylint.

                      super().__init__()
        self.inner = InnerLayer()

      def call(self, inputs, training=True):
        return self.inner(inputs)

    def fn():
      layer = OuterLayer()
      layer(tf.zeros((3, 5)), training=False)

            

Reported by Pylint.

              
    class MyLayer(layers.Layer):

      def call(self, inputs, training=False, mask=None):
        return inputs + tf.zeros((3, 4))

    def fn():
      layer = MyLayer()
      layer(tf.zeros((3, 5)), training=False)

            

Reported by Pylint.

              
    class MyLayer(layers.Layer):

      def call(self, inputs, training=False, mask=None):
        return inputs + tf.zeros((3, 4))

    def fn():
      layer = MyLayer()
      layer(tf.zeros((3, 5)), training=False)

            

Reported by Pylint.

              
    class MyLayer(layers.Layer):

      def call(self, inputs, training=False, mask=None):
        return inputs + tf.zeros((3, 4))

    def fn():
      layer = MyLayer()
      layer(tf.zeros((3, 5)), training=False)

            

Reported by Pylint.

              # limitations under the License.
# ==============================================================================
# pylint: disable=protected-access
# pylint: disable=g-classes-have-attributes
"""Contains the `Node` class."""

import tensorflow.compat.v2 as tf

import collections

            

Reported by Pylint.

              # pylint: disable=g-classes-have-attributes
"""Contains the `Node` class."""

import tensorflow.compat.v2 as tf

import collections
import copy
import json
import numpy as np

            

Reported by Pylint.

                    json.dumps(kwargs, default=json_utils.get_json_type)
    except TypeError:
      kwarg_types = tf.nest.map_structure(type, kwargs)
      raise TypeError('Layer ' + self.layer.name +
                      ' was passed non-JSON-serializable arguments. ' +
                      'Arguments had types: ' +
                      str(kwarg_types) + '. They cannot be serialized out '
                      'when saving the model.')


            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

import collections
import copy
import json
import numpy as np
from keras import backend
from keras.engine import base_layer_utils

            

Reported by Pylint.

              import tensorflow.compat.v2 as tf

import collections
import copy
import json
import numpy as np
from keras import backend
from keras.engine import base_layer_utils
from keras.saving.saved_model import json_utils

            

Reported by Pylint.

              
import collections
import copy
import json
import numpy as np
from keras import backend
from keras.engine import base_layer_utils
from keras.saving.saved_model import json_utils
from keras.utils import tf_utils

            

Reported by Pylint.

              _CONSTANT_VALUE = '_CONSTANT_VALUE'


class Node:
  """A `Node` describes a layer `__call__()` event.

  A Functional model is a DAG with `Node` instances as nodes, and `KerasTensor`
  instances as edges. Nodes aren't `Layer` instances, because a single layer
  could be called multiple times, which would result in graph cycles.

            

Reported by Pylint.

              

class Node:
  """A `Node` describes a layer `__call__()` event.

  A Functional model is a DAG with `Node` instances as nodes, and `KerasTensor`
  instances as edges. Nodes aren't `Layer` instances, because a single layer
  could be called multiple times, which would result in graph cycles.


            

Reported by Pylint.

                    outputs: The output tensors of the `Layer.__call__()`
  """

  def __init__(self,
               layer,
               call_args=None,
               call_kwargs=None,
               outputs=None):
    call_args = [] if call_args is None else call_args

            

Reported by Pylint.

                             call_args=None,
               call_kwargs=None,
               outputs=None):
    call_args = [] if call_args is None else call_args
    call_kwargs = {} if call_kwargs is None else call_kwargs
    outputs = [] if outputs is None else outputs

    self.layer = layer
    self.is_input = not call_args and not call_kwargs

            

Reported by Pylint.

              # ==============================================================================
"""Tests for conv_utils."""

import tensorflow.compat.v2 as tf

import itertools

from absl.testing import parameterized
import numpy as np

            

Reported by Pylint.

              
import itertools

from absl.testing import parameterized
import numpy as np

from keras.utils import conv_utils



            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

import itertools

from absl.testing import parameterized
import numpy as np

from keras.utils import conv_utils

            

Reported by Pylint.

              

def _get_const_output_shape(input_shape, dim):
  return tuple([min(d, dim) for d in input_shape])


input_shapes = [
    (0,),
    (0, 0),

            

Reported by Pylint.

              

def _get_const_output_shape(input_shape, dim):
  return tuple([min(d, dim) for d in input_shape])


input_shapes = [
    (0,),
    (0, 0),

            

Reported by Pylint.

              ]


class TestBasicConvUtilsTest(tf.test.TestCase):

  def test_convert_data_format(self):
    self.assertEqual('NCDHW', conv_utils.convert_data_format(
        'channels_first', 5))
    self.assertEqual('NCHW', conv_utils.convert_data_format(

            

Reported by Pylint.

              
class TestBasicConvUtilsTest(tf.test.TestCase):

  def test_convert_data_format(self):
    self.assertEqual('NCDHW', conv_utils.convert_data_format(
        'channels_first', 5))
    self.assertEqual('NCHW', conv_utils.convert_data_format(
        'channels_first', 4))
    self.assertEqual('NCW', conv_utils.convert_data_format('channels_first', 3))

            

Reported by Pylint.

              
class TestBasicConvUtilsTest(tf.test.TestCase):

  def test_convert_data_format(self):
    self.assertEqual('NCDHW', conv_utils.convert_data_format(
        'channels_first', 5))
    self.assertEqual('NCHW', conv_utils.convert_data_format(
        'channels_first', 4))
    self.assertEqual('NCW', conv_utils.convert_data_format('channels_first', 3))

            

Reported by Pylint.

              class TestBasicConvUtilsTest(tf.test.TestCase):

  def test_convert_data_format(self):
    self.assertEqual('NCDHW', conv_utils.convert_data_format(
        'channels_first', 5))
    self.assertEqual('NCHW', conv_utils.convert_data_format(
        'channels_first', 4))
    self.assertEqual('NCW', conv_utils.convert_data_format('channels_first', 3))
    self.assertEqual('NHWC', conv_utils.convert_data_format('channels_last', 4))

            

Reported by Pylint.

                def test_convert_data_format(self):
    self.assertEqual('NCDHW', conv_utils.convert_data_format(
        'channels_first', 5))
    self.assertEqual('NCHW', conv_utils.convert_data_format(
        'channels_first', 4))
    self.assertEqual('NCW', conv_utils.convert_data_format('channels_first', 3))
    self.assertEqual('NHWC', conv_utils.convert_data_format('channels_last', 4))
    self.assertEqual('NWC', conv_utils.convert_data_format('channels_last', 3))
    self.assertEqual('NDHWC', conv_utils.convert_data_format(

            

Reported by Pylint.

              import os
import random
import tempfile
from absl.testing import parameterized
import numpy as np
import portpicker
import tensorflow as tf



            

Reported by Pylint.

              import tempfile
from absl.testing import parameterized
import numpy as np
import portpicker
import tensorflow as tf


# These vocabularies usually come from TFT or a Beam pipeline.
FEATURE_VOCAB = [

            

Reported by Pylint.

              from absl.testing import parameterized
import numpy as np
import portpicker
import tensorflow as tf


# These vocabularies usually come from TFT or a Beam pipeline.
FEATURE_VOCAB = [
    "avenger", "ironman", "batman", "hulk", "spiderman", "kingkong",

            

Reported by Pylint.

                              "label": tf.TensorSpec([1], tf.string)
            }).shuffle(100).batch(32)

        train_dataset = raw_dataset.map(lambda x: (  # pylint: disable=g-long-lambda
            {
                "features": feature_ps(x["features"])
            }, label_ps(x["label"])))
        return train_dataset


            

Reported by Pylint.

              

def create_in_process_cluster(num_workers, num_ps):
  """Creates and starts local servers and returns the cluster_resolver."""

  worker_ports = [portpicker.pick_unused_port() for _ in range(num_workers)]
  ps_ports = [portpicker.pick_unused_port() for _ in range(num_ps)]

  cluster_dict = {}

            

Reported by Pylint.

              def create_in_process_cluster(num_workers, num_ps):
  """Creates and starts local servers and returns the cluster_resolver."""

  worker_ports = [portpicker.pick_unused_port() for _ in range(num_workers)]
  ps_ports = [portpicker.pick_unused_port() for _ in range(num_ps)]

  cluster_dict = {}
  cluster_dict["worker"] = ["localhost:%s" % port for port in worker_ports]
  if num_ps > 0:

            

Reported by Pylint.

                """Creates and starts local servers and returns the cluster_resolver."""

  worker_ports = [portpicker.pick_unused_port() for _ in range(num_workers)]
  ps_ports = [portpicker.pick_unused_port() for _ in range(num_ps)]

  cluster_dict = {}
  cluster_dict["worker"] = ["localhost:%s" % port for port in worker_ports]
  if num_ps > 0:
    cluster_dict["ps"] = ["localhost:%s" % port for port in ps_ports]

            

Reported by Pylint.

                worker_ports = [portpicker.pick_unused_port() for _ in range(num_workers)]
  ps_ports = [portpicker.pick_unused_port() for _ in range(num_ps)]

  cluster_dict = {}
  cluster_dict["worker"] = ["localhost:%s" % port for port in worker_ports]
  if num_ps > 0:
    cluster_dict["ps"] = ["localhost:%s" % port for port in ps_ports]

  cluster_spec = tf.train.ClusterSpec(cluster_dict)

            

Reported by Pylint.

                ps_ports = [portpicker.pick_unused_port() for _ in range(num_ps)]

  cluster_dict = {}
  cluster_dict["worker"] = ["localhost:%s" % port for port in worker_ports]
  if num_ps > 0:
    cluster_dict["ps"] = ["localhost:%s" % port for port in ps_ports]

  cluster_spec = tf.train.ClusterSpec(cluster_dict)


            

Reported by Pylint.

              
  cluster_dict = {}
  cluster_dict["worker"] = ["localhost:%s" % port for port in worker_ports]
  if num_ps > 0:
    cluster_dict["ps"] = ["localhost:%s" % port for port in ps_ports]

  cluster_spec = tf.train.ClusterSpec(cluster_dict)

  # Workers need some inter_ops threads to work properly.

            

Reported by Pylint.

              # ==============================================================================
"""Tests for Keras optimizers."""

import tensorflow.compat.v2 as tf

import gc
import weakref

import numpy as np

            

Reported by Pylint.

              from keras import optimizer_v1
from keras import testing_utils
from keras.utils import np_utils
from tensorflow.python.training.adam import AdamOptimizer
from tensorflow.python.training.experimental.loss_scale_optimizer import MixedPrecisionLossScaleOptimizer


def _get_model(input_dim, num_hidden, output_dim):
  model = keras.models.Sequential()

            

Reported by Pylint.

              from keras import testing_utils
from keras.utils import np_utils
from tensorflow.python.training.adam import AdamOptimizer
from tensorflow.python.training.experimental.loss_scale_optimizer import MixedPrecisionLossScaleOptimizer


def _get_model(input_dim, num_hidden, output_dim):
  model = keras.models.Sequential()
  model.add(keras.layers.Dense(num_hidden,

            

Reported by Pylint.

                  with self.cached_session():
      self._test_optimizer(optimizer_v1.Adam())
      # Accuracy seems dependent on the seed initialization.
      # TODO(b/121051441): fix test flakiness.
      self._test_optimizer(optimizer_v1.Adam(decay=1e-3), target=0.73)
      self._test_optimizer(optimizer_v1.Adam(amsgrad=True))

  def test_adamax(self):
    with self.cached_session():

            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

import gc
import weakref

import numpy as np

import keras

            

Reported by Pylint.

              import tensorflow.compat.v2 as tf

import gc
import weakref

import numpy as np

import keras
from keras import keras_parameterized

            

Reported by Pylint.

              from keras import optimizer_v1
from keras import testing_utils
from keras.utils import np_utils
from tensorflow.python.training.adam import AdamOptimizer
from tensorflow.python.training.experimental.loss_scale_optimizer import MixedPrecisionLossScaleOptimizer


def _get_model(input_dim, num_hidden, output_dim):
  model = keras.models.Sequential()

            

Reported by Pylint.

              from keras import testing_utils
from keras.utils import np_utils
from tensorflow.python.training.adam import AdamOptimizer
from tensorflow.python.training.experimental.loss_scale_optimizer import MixedPrecisionLossScaleOptimizer


def _get_model(input_dim, num_hidden, output_dim):
  model = keras.models.Sequential()
  model.add(keras.layers.Dense(num_hidden,

            

Reported by Pylint.

              from keras import testing_utils
from keras.utils import np_utils
from tensorflow.python.training.adam import AdamOptimizer
from tensorflow.python.training.experimental.loss_scale_optimizer import MixedPrecisionLossScaleOptimizer


def _get_model(input_dim, num_hidden, output_dim):
  model = keras.models.Sequential()
  model.add(keras.layers.Dense(num_hidden,

            

Reported by Pylint.

              

def _get_model(input_dim, num_hidden, output_dim):
  model = keras.models.Sequential()
  model.add(keras.layers.Dense(num_hidden,
                               activation='relu',
                               input_shape=(input_dim,)))
  model.add(keras.layers.Dense(output_dim, activation='softmax'))
  return model

            

Reported by Pylint.