# pylint: disable=protected-access
"""Utilities related to loss functions."""

import tensorflow.compat.v2 as tf
from keras import backend
from keras.engine import keras_tensor
from tensorflow.python.util.tf_export import keras_export



            

Reported by Pylint.

              import tensorflow.compat.v2 as tf
from keras import backend
from keras.engine import keras_tensor
from tensorflow.python.util.tf_export import keras_export


@keras_export('keras.losses.Reduction', v1=[])
class ReductionV2:
  """Types of loss reduction.

            

Reported by Pylint.

                  else:
      # Use dynamic rank.
      rank_diff = tf.rank(y_pred) - tf.rank(y_true)
      squeeze_dims = lambda: remove_squeezable_dimensions(  # pylint: disable=g-long-lambda
          y_true, y_pred)
      is_last_dim_1 = tf.equal(1, tf.shape(y_pred)[-1])
      maybe_squeeze_dims = lambda: tf.cond(  # pylint: disable=g-long-lambda
          is_last_dim_1, squeeze_dims, lambda: (y_true, y_pred))
      y_true, y_pred = tf.cond(

            

Reported by Pylint.

                    squeeze_dims = lambda: remove_squeezable_dimensions(  # pylint: disable=g-long-lambda
          y_true, y_pred)
      is_last_dim_1 = tf.equal(1, tf.shape(y_pred)[-1])
      maybe_squeeze_dims = lambda: tf.cond(  # pylint: disable=g-long-lambda
          is_last_dim_1, squeeze_dims, lambda: (y_true, y_pred))
      y_true, y_pred = tf.cond(
          tf.equal(1, rank_diff), maybe_squeeze_dims, squeeze_dims)

  if sample_weight is None:

            

Reported by Pylint.

                                    (keras_tensor.KerasTensor, tf.RaggedTensor)):
      sample_weight = tf.convert_to_tensor(sample_weight)

    # TODO(psv): Handle casting here in a better way, eg. if losses is float64
    # we do not want to lose precision.
    losses = tf.cast(losses, 'float32')
    sample_weight = tf.cast(sample_weight, 'float32')
    # Update dimensions of `sample_weight` to match with `losses` if possible.
    losses, _, sample_weight = squeeze_or_expand_dimensions(  # pylint: disable=unbalanced-tuple-unpacking

            

Reported by Pylint.

              
@keras_export('keras.losses.Reduction', v1=[])
class ReductionV2:
  """Types of loss reduction.

  Contains the following values:

  * `AUTO`: Indicates that the reduction option will be determined by the usage
     context. For almost all cases this defaults to `SUM_OVER_BATCH_SIZE`. When

            

Reported by Pylint.

                details on this.
  """

  AUTO = 'auto'
  NONE = 'none'
  SUM = 'sum'
  SUM_OVER_BATCH_SIZE = 'sum_over_batch_size'

  @classmethod

            

Reported by Pylint.

                """

  AUTO = 'auto'
  NONE = 'none'
  SUM = 'sum'
  SUM_OVER_BATCH_SIZE = 'sum_over_batch_size'

  @classmethod
  def all(cls):

            

Reported by Pylint.

              
  AUTO = 'auto'
  NONE = 'none'
  SUM = 'sum'
  SUM_OVER_BATCH_SIZE = 'sum_over_batch_size'

  @classmethod
  def all(cls):
    return (cls.AUTO, cls.NONE, cls.SUM, cls.SUM_OVER_BATCH_SIZE)

            

Reported by Pylint.

                AUTO = 'auto'
  NONE = 'none'
  SUM = 'sum'
  SUM_OVER_BATCH_SIZE = 'sum_over_batch_size'

  @classmethod
  def all(cls):
    return (cls.AUTO, cls.NONE, cls.SUM, cls.SUM_OVER_BATCH_SIZE)


            

Reported by Pylint.

                    https://arxiv.org/abs/1704.04861)
"""

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.platform import tf_logging as logging
from tensorflow.python.util.tf_export import keras_export

BASE_WEIGHT_PATH = ('https://storage.googleapis.com/tensorflow/'
                    'keras-applications/mobilenet/')
layers = None

            

Reported by Pylint.

              from keras.utils import data_utils
from keras.utils import layer_utils
from tensorflow.python.platform import tf_logging as logging
from tensorflow.python.util.tf_export import keras_export

BASE_WEIGHT_PATH = ('https://storage.googleapis.com/tensorflow/'
                    'keras-applications/mobilenet/')
layers = None


            

Reported by Pylint.

                Returns:
    A `keras.Model` instance.
  """
  global layers
  if 'layers' in kwargs:
    layers = kwargs.pop('layers')
  else:
    layers = VersionAwareLayers()
  if kwargs:

            

Reported by Pylint.

              
@keras_export('keras.applications.mobilenet.MobileNet',
              'keras.applications.MobileNet')
def MobileNet(input_shape=None,
              alpha=1.0,
              depth_multiplier=1,
              dropout=1e-3,
              include_top=True,
              weights='imagenet',

            

Reported by Pylint.

              
@keras_export('keras.applications.mobilenet.MobileNet',
              'keras.applications.MobileNet')
def MobileNet(input_shape=None,
              alpha=1.0,
              depth_multiplier=1,
              dropout=1e-3,
              include_top=True,
              weights='imagenet',

            

Reported by Pylint.

              
@keras_export('keras.applications.mobilenet.MobileNet',
              'keras.applications.MobileNet')
def MobileNet(input_shape=None,
              alpha=1.0,
              depth_multiplier=1,
              dropout=1e-3,
              include_top=True,
              weights='imagenet',

            

Reported by Pylint.

              
@keras_export('keras.applications.mobilenet.MobileNet',
              'keras.applications.MobileNet')
def MobileNet(input_shape=None,
              alpha=1.0,
              depth_multiplier=1,
              dropout=1e-3,
              include_top=True,
              weights='imagenet',

            

Reported by Pylint.

                            classes=1000,
              classifier_activation='softmax',
              **kwargs):
  """Instantiates the MobileNet architecture.

  Reference:
  - [MobileNets: Efficient Convolutional Neural Networks
     for Mobile Vision Applications](
      https://arxiv.org/abs/1704.04861)

            

Reported by Pylint.

                Returns:
    A `keras.Model` instance.
  """
  global layers
  if 'layers' in kwargs:
    layers = kwargs.pop('layers')
  else:
    layers = VersionAwareLayers()
  if kwargs:

            

Reported by Pylint.

              # ==============================================================================
"""Keras models for use in Model subclassing tests."""

import keras
from keras import testing_utils


# pylint: disable=missing-docstring,not-callable
class SimpleConvTestModel(keras.Model):

            

Reported by Pylint.

              """Keras models for use in Model subclassing tests."""

import keras
from keras import testing_utils


# pylint: disable=missing-docstring,not-callable
class SimpleConvTestModel(keras.Model):


            

Reported by Pylint.

                  self.dense1 = keras.layers.Dense(1, activation='relu')
    self.dense2 = keras.layers.Dense(1, activation='softmax')

  def call(self, first, second, fiddle_with_output='no', training=True):
    combined = self.dense1(first) + self.dense2(second)
    if fiddle_with_output == 'yes':
      return 10. * combined
    else:
      return combined

            

Reported by Pylint.

                  super(TrainingNoDefaultModel, self).__init__()
    self.dense1 = keras.layers.Dense(1)

  def call(self, x, training):
    return self.dense1(x)


class TrainingMaskingModel(keras.Model):


            

Reported by Pylint.

                  super(TrainingMaskingModel, self).__init__()
    self.dense1 = keras.layers.Dense(1)

  def call(self, x, training=False, mask=None):
    return self.dense1(x)

            

Reported by Pylint.

                  super(TrainingMaskingModel, self).__init__()
    self.dense1 = keras.layers.Dense(1)

  def call(self, x, training=False, mask=None):
    return self.dense1(x)

            

Reported by Pylint.

              

# pylint: disable=missing-docstring,not-callable
class SimpleConvTestModel(keras.Model):

  def __init__(self, num_classes=10):
    super(SimpleConvTestModel, self).__init__(name='test_model')
    self.num_classes = num_classes


            

Reported by Pylint.

              # pylint: disable=missing-docstring,not-callable
class SimpleConvTestModel(keras.Model):

  def __init__(self, num_classes=10):
    super(SimpleConvTestModel, self).__init__(name='test_model')
    self.num_classes = num_classes

    self.conv1 = keras.layers.Conv2D(32, (3, 3), activation='relu')
    self.flatten = keras.layers.Flatten()

            

Reported by Pylint.

              class SimpleConvTestModel(keras.Model):

  def __init__(self, num_classes=10):
    super(SimpleConvTestModel, self).__init__(name='test_model')
    self.num_classes = num_classes

    self.conv1 = keras.layers.Conv2D(32, (3, 3), activation='relu')
    self.flatten = keras.layers.Flatten()
    self.dense1 = keras.layers.Dense(num_classes, activation='softmax')

            

Reported by Pylint.

              class SimpleConvTestModel(keras.Model):

  def __init__(self, num_classes=10):
    super(SimpleConvTestModel, self).__init__(name='test_model')
    self.num_classes = num_classes

    self.conv1 = keras.layers.Conv2D(32, (3, 3), activation='relu')
    self.flatten = keras.layers.Flatten()
    self.dense1 = keras.layers.Dense(num_classes, activation='softmax')

            

Reported by Pylint.

                def __contains__(self, key):
    return self._wrap_key(key) in self._storage

  def discard(self, key):
    self._storage.discard(self._wrap_key(key))

  def add(self, key):
    self._storage.add(self._wrap_key(key))


            

Reported by Pylint.

                def discard(self, key):
    self._storage.discard(self._wrap_key(key))

  def add(self, key):
    self._storage.add(self._wrap_key(key))

  def update(self, items):
    self._storage.update([self._wrap_key(item) for item in items])


            

Reported by Pylint.

              
# LINT.IfChange
class _ObjectIdentityWrapper:
  """Wraps an object, mapping __eq__ on wrapper to "is" on wrapped.

  Since __eq__ is based on object identity, it's safe to also define __hash__
  based on object ids. This lets us add unhashable types like trackable
  _ListWrapper objects to object-identity collections.
  """

            

Reported by Pylint.

                _ListWrapper objects to object-identity collections.
  """

  __slots__ = ["_wrapped", "__weakref__"]

  def __init__(self, wrapped):
    self._wrapped = wrapped

  @property

            

Reported by Pylint.

              
  __slots__ = ["_wrapped", "__weakref__"]

  def __init__(self, wrapped):
    self._wrapped = wrapped

  @property
  def unwrapped(self):
    return self._wrapped

            

Reported by Pylint.

                __slots__ = ["_wrapped", "__weakref__"]

  def __init__(self, wrapped):
    self._wrapped = wrapped

  @property
  def unwrapped(self):
    return self._wrapped


            

Reported by Pylint.

                def __init__(self, wrapped):
    self._wrapped = wrapped

  @property
  def unwrapped(self):
    return self._wrapped

  def _assert_type(self, other):
    if not isinstance(other, _ObjectIdentityWrapper):

            

Reported by Pylint.

                  self._wrapped = wrapped

  @property
  def unwrapped(self):
    return self._wrapped

  def _assert_type(self, other):
    if not isinstance(other, _ObjectIdentityWrapper):
      raise TypeError(

            

Reported by Pylint.

                  self._wrapped = wrapped

  @property
  def unwrapped(self):
    return self._wrapped

  def _assert_type(self, other):
    if not isinstance(other, _ObjectIdentityWrapper):
      raise TypeError(

            

Reported by Pylint.

              
  @property
  def unwrapped(self):
    return self._wrapped

  def _assert_type(self, other):
    if not isinstance(other, _ObjectIdentityWrapper):
      raise TypeError(
          "Cannot compare wrapped object with unwrapped object. "

            

Reported by Pylint.

              # ==============================================================================
"""Test covering sidecar_evaluator.py."""

import tensorflow.compat.v2 as tf

import enum
import os

from absl import logging

            

Reported by Pylint.

              import enum
import os

from absl import logging
from absl.testing import parameterized
import numpy as np

import keras
from keras.distribute import sidecar_evaluator as sidecar_evaluator_lib

            

Reported by Pylint.

              import os

from absl import logging
from absl.testing import parameterized
import numpy as np

import keras
from keras.distribute import sidecar_evaluator as sidecar_evaluator_lib
from keras.optimizer_v2 import gradient_descent

            

Reported by Pylint.

              _BATCH_SIZE = 32


class TestModel(keras.Model):

  def __init__(self):
    super().__init__(name='test_model')
    self.dense = keras.layers.Dense(10)


            

Reported by Pylint.

                  super().__init__(name='test_model')
    self.dense = keras.layers.Dense(10)

  def call(self, inputs):
    return self.dense(inputs)


class DictMetric(keras.metrics.MeanSquaredError):


            

Reported by Pylint.

                  self.assertModelsSameVariables(model, eval_model)

    # check the iterations is restored.
    self.assertEqual(sidecar_evaluator._iterations.numpy(), _BATCH_SIZE)

    self.assertSummaryEventsWritten(os.path.join(log_dir, 'validation'))


if __name__ == '__main__':

            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

import enum
import os

from absl import logging
from absl.testing import parameterized
import numpy as np

            

Reported by Pylint.

              import tensorflow.compat.v2 as tf

import enum
import os

from absl import logging
from absl.testing import parameterized
import numpy as np


            

Reported by Pylint.

              _BATCH_SIZE = 32


class TestModel(keras.Model):

  def __init__(self):
    super().__init__(name='test_model')
    self.dense = keras.layers.Dense(10)


            

Reported by Pylint.

              
class TestModel(keras.Model):

  def __init__(self):
    super().__init__(name='test_model')
    self.dense = keras.layers.Dense(10)

  def call(self, inputs):
    return self.dense(inputs)

            

Reported by Pylint.

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

import tensorflow.compat.v2 as tf
from keras import backend
from tensorflow.python.util.tf_export import keras_export

            

Reported by Pylint.

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

import tensorflow.compat.v2 as tf
from keras import backend
from tensorflow.python.util.tf_export import keras_export
from tensorflow.python.util.tf_export import tf_export



            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf
from keras import backend
from tensorflow.python.util.tf_export import keras_export
from tensorflow.python.util.tf_export import tf_export


@keras_export('keras.layers.InputSpec',
              v1=['keras.layers.InputSpec',

            

Reported by Pylint.

              import tensorflow.compat.v2 as tf
from keras import backend
from tensorflow.python.util.tf_export import keras_export
from tensorflow.python.util.tf_export import tf_export


@keras_export('keras.layers.InputSpec',
              v1=['keras.layers.InputSpec',
                  'keras.__internal__.legacy.layers.InputSpec'])

            

Reported by Pylint.

                    axes = axes or {}
      self.axes = {int(k): axes[k] for k in axes}
    except (ValueError, TypeError):
      raise TypeError('The keys in axes must be integers.')

    if self.axes and (self.ndim is not None or self.max_ndim is not None):
      max_dim = (self.ndim if self.ndim else self.max_ndim) - 1
      max_axis = max(self.axes)
      if max_axis > max_dim:

            

Reported by Pylint.

                            v1=['keras.layers.InputSpec',
                  'keras.__internal__.legacy.layers.InputSpec'])
@tf_export(v1=['layers.InputSpec'])
class InputSpec:
  """Specifies the rank, dtype and shape of every input to a layer.

  Layers can expose (if appropriate) an `input_spec` attribute:
  an instance of `InputSpec`, or a nested structure of `InputSpec` instances
  (one per input tensor). These objects enable the layer to run input

            

Reported by Pylint.

                                'keras.__internal__.legacy.layers.InputSpec'])
@tf_export(v1=['layers.InputSpec'])
class InputSpec:
  """Specifies the rank, dtype and shape of every input to a layer.

  Layers can expose (if appropriate) an `input_spec` attribute:
  an instance of `InputSpec`, or a nested structure of `InputSpec` instances
  (one per input tensor). These objects enable the layer to run input
  compatibility checks for input structure, input rank, input shape, and

            

Reported by Pylint.

                ```
  """

  def __init__(self,
               dtype=None,
               shape=None,
               ndim=None,
               max_ndim=None,
               min_ndim=None,

            

Reported by Pylint.

                ```
  """

  def __init__(self,
               dtype=None,
               shape=None,
               ndim=None,
               max_ndim=None,
               min_ndim=None,

            

Reported by Pylint.

                             axes=None,
               allow_last_axis_squeeze=False,
               name=None):
    self.dtype = tf.as_dtype(dtype).name if dtype is not None else None
    shape = tf.TensorShape(shape)
    if shape.rank is None:
      shape = None
    else:
      shape = tuple(shape.as_list())

            

Reported by Pylint.

              #,============================================================================
"""Tests for layer graphs construction & handling."""

import tensorflow.compat.v2 as tf

from keras import keras_parameterized
from keras.engine import base_layer
from keras.engine import node as node_module


            

Reported by Pylint.

                  node_module.Node(layer=concat_layer, call_args=([a_2, b_2],),
                     outputs=merged)

    merge_layer, merge_node_index, merge_tensor_index = merged._keras_history

    self.assertEqual(merge_node_index, 0)
    self.assertEqual(merge_tensor_index, 0)

    self.assertLen(merge_layer._inbound_nodes, 1)

            

Reported by Pylint.

                                          call_kwargs={'x': kwarg_x, 'y': kwarg_y},
                            outputs=merged)

    merge_layer, merge_node_index, merge_tensor_index = merged._keras_history

    # Check the saved call args/kwargs
    self.assertEqual(([a, b], arg_2, arg_3), node.call_args)
    self.assertEqual({'x': kwarg_x, 'y': kwarg_y}, node.call_kwargs)


            

Reported by Pylint.

                  self.assertEqual(node_a.outputs, a_2)

    # Test the layer wiring
    self.assertLen(dense._inbound_nodes, 2)
    self.assertLen(dense._outbound_nodes, 0)
    self.assertEqual(dense._inbound_nodes, [node_a, node_b])
    self.assertEqual(dense._inbound_nodes[0].inbound_layers, a_layer)
    self.assertEqual(dense._inbound_nodes[0].outbound_layer, dense)
    self.assertEqual(dense._inbound_nodes[1].inbound_layers, b_layer)

            

Reported by Pylint.

              
    # Test the layer wiring
    self.assertLen(dense._inbound_nodes, 2)
    self.assertLen(dense._outbound_nodes, 0)
    self.assertEqual(dense._inbound_nodes, [node_a, node_b])
    self.assertEqual(dense._inbound_nodes[0].inbound_layers, a_layer)
    self.assertEqual(dense._inbound_nodes[0].outbound_layer, dense)
    self.assertEqual(dense._inbound_nodes[1].inbound_layers, b_layer)
    self.assertEqual(dense._inbound_nodes[1].outbound_layer, dense)

            

Reported by Pylint.

                  # Test the layer wiring
    self.assertLen(dense._inbound_nodes, 2)
    self.assertLen(dense._outbound_nodes, 0)
    self.assertEqual(dense._inbound_nodes, [node_a, node_b])
    self.assertEqual(dense._inbound_nodes[0].inbound_layers, a_layer)
    self.assertEqual(dense._inbound_nodes[0].outbound_layer, dense)
    self.assertEqual(dense._inbound_nodes[1].inbound_layers, b_layer)
    self.assertEqual(dense._inbound_nodes[1].outbound_layer, dense)
    self.assertIs(dense._inbound_nodes[0].input_tensors, a)

            

Reported by Pylint.

                  self.assertLen(dense._inbound_nodes, 2)
    self.assertLen(dense._outbound_nodes, 0)
    self.assertEqual(dense._inbound_nodes, [node_a, node_b])
    self.assertEqual(dense._inbound_nodes[0].inbound_layers, a_layer)
    self.assertEqual(dense._inbound_nodes[0].outbound_layer, dense)
    self.assertEqual(dense._inbound_nodes[1].inbound_layers, b_layer)
    self.assertEqual(dense._inbound_nodes[1].outbound_layer, dense)
    self.assertIs(dense._inbound_nodes[0].input_tensors, a)
    self.assertIs(dense._inbound_nodes[1].input_tensors, b)

            

Reported by Pylint.

                  self.assertLen(dense._outbound_nodes, 0)
    self.assertEqual(dense._inbound_nodes, [node_a, node_b])
    self.assertEqual(dense._inbound_nodes[0].inbound_layers, a_layer)
    self.assertEqual(dense._inbound_nodes[0].outbound_layer, dense)
    self.assertEqual(dense._inbound_nodes[1].inbound_layers, b_layer)
    self.assertEqual(dense._inbound_nodes[1].outbound_layer, dense)
    self.assertIs(dense._inbound_nodes[0].input_tensors, a)
    self.assertIs(dense._inbound_nodes[1].input_tensors, b)


            

Reported by Pylint.

                  self.assertEqual(dense._inbound_nodes, [node_a, node_b])
    self.assertEqual(dense._inbound_nodes[0].inbound_layers, a_layer)
    self.assertEqual(dense._inbound_nodes[0].outbound_layer, dense)
    self.assertEqual(dense._inbound_nodes[1].inbound_layers, b_layer)
    self.assertEqual(dense._inbound_nodes[1].outbound_layer, dense)
    self.assertIs(dense._inbound_nodes[0].input_tensors, a)
    self.assertIs(dense._inbound_nodes[1].input_tensors, b)

  def test_multi_input_node(self):

            

Reported by Pylint.

                  self.assertEqual(dense._inbound_nodes[0].inbound_layers, a_layer)
    self.assertEqual(dense._inbound_nodes[0].outbound_layer, dense)
    self.assertEqual(dense._inbound_nodes[1].inbound_layers, b_layer)
    self.assertEqual(dense._inbound_nodes[1].outbound_layer, dense)
    self.assertIs(dense._inbound_nodes[0].input_tensors, a)
    self.assertIs(dense._inbound_nodes[1].input_tensors, b)

  def test_multi_input_node(self):
    # test multi-input layer

            

Reported by Pylint.

              # ==============================================================================
"""Base class for testing saving/loading with DS."""

import tensorflow.compat.v2 as tf

import os

from absl.testing import parameterized
import numpy as np

            

Reported by Pylint.

              
import os

from absl.testing import parameterized
import numpy as np
from keras import backend
from keras.distribute import model_combinations

_RANDOM_SEED = 1337

            

Reported by Pylint.

                  # Train the model for 1 epoch
    model.fit(x=training_dataset, epochs=1, steps_per_epoch=100)

  def _predict_with_model(self, distribution, model, predict_dataset):
    return model.predict(predict_dataset, steps=PREDICT_STEPS)

  def _get_predict_dataset(self, x_predict, batch_size):
    predict_dataset = tf.data.Dataset.from_tensor_slices(x_predict)
    predict_dataset = predict_dataset.repeat()

            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

import os

from absl.testing import parameterized
import numpy as np
from keras import backend
from keras.distribute import model_combinations

            

Reported by Pylint.

              ]


def get_tolerance(save_distribution, restore_distribution):
  if backend.is_tpu_strategy(save_distribution) or backend.is_tpu_strategy(
      restore_distribution):
    return _TPU_TOLERANCE
  return _TOLERANCE


            

Reported by Pylint.

              

def get_tolerance(save_distribution, restore_distribution):
  if backend.is_tpu_strategy(save_distribution) or backend.is_tpu_strategy(
      restore_distribution):
    return _TPU_TOLERANCE
  return _TOLERANCE



            

Reported by Pylint.

              def get_tolerance(save_distribution, restore_distribution):
  if backend.is_tpu_strategy(save_distribution) or backend.is_tpu_strategy(
      restore_distribution):
    return _TPU_TOLERANCE
  return _TOLERANCE


def simple_models_with_strategies():
  return tf.__internal__.test.combinations.combine(

            

Reported by Pylint.

                if backend.is_tpu_strategy(save_distribution) or backend.is_tpu_strategy(
      restore_distribution):
    return _TPU_TOLERANCE
  return _TOLERANCE


def simple_models_with_strategies():
  return tf.__internal__.test.combinations.combine(
      model_and_input=simple_models,

            

Reported by Pylint.

                return _TOLERANCE


def simple_models_with_strategies():
  return tf.__internal__.test.combinations.combine(
      model_and_input=simple_models,
      distribution=strategies,
      mode=['eager'])


            

Reported by Pylint.

              

def simple_models_with_strategies():
  return tf.__internal__.test.combinations.combine(
      model_and_input=simple_models,
      distribution=strategies,
      mode=['eager'])



            

Reported by Pylint.

              
import warnings

import tensorflow.compat.v2 as tf

import numpy as np

import keras
from keras import testing_utils

            

Reported by Pylint.

              EPOCHS = 1


def build_fn_clf(hidden_dim):
  model = keras.models.Sequential()
  model.add(keras.layers.Dense(INPUT_DIM, input_shape=(INPUT_DIM,)))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(hidden_dim))
  model.add(keras.layers.Activation('relu'))

            

Reported by Pylint.

              

def build_fn_clf(hidden_dim):
  model = keras.models.Sequential()
  model.add(keras.layers.Dense(INPUT_DIM, input_shape=(INPUT_DIM,)))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(hidden_dim))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(NUM_CLASSES))

            

Reported by Pylint.

              
def build_fn_clf(hidden_dim):
  model = keras.models.Sequential()
  model.add(keras.layers.Dense(INPUT_DIM, input_shape=(INPUT_DIM,)))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(hidden_dim))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(NUM_CLASSES))
  model.add(keras.layers.Activation('softmax'))

            

Reported by Pylint.

              def build_fn_clf(hidden_dim):
  model = keras.models.Sequential()
  model.add(keras.layers.Dense(INPUT_DIM, input_shape=(INPUT_DIM,)))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(hidden_dim))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(NUM_CLASSES))
  model.add(keras.layers.Activation('softmax'))
  model.compile(

            

Reported by Pylint.

                model = keras.models.Sequential()
  model.add(keras.layers.Dense(INPUT_DIM, input_shape=(INPUT_DIM,)))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(hidden_dim))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(NUM_CLASSES))
  model.add(keras.layers.Activation('softmax'))
  model.compile(
      optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])

            

Reported by Pylint.

                model.add(keras.layers.Dense(INPUT_DIM, input_shape=(INPUT_DIM,)))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(hidden_dim))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(NUM_CLASSES))
  model.add(keras.layers.Activation('softmax'))
  model.compile(
      optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])
  return model

            

Reported by Pylint.

                model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(hidden_dim))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(NUM_CLASSES))
  model.add(keras.layers.Activation('softmax'))
  model.compile(
      optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])
  return model


            

Reported by Pylint.

                model.add(keras.layers.Dense(hidden_dim))
  model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(NUM_CLASSES))
  model.add(keras.layers.Activation('softmax'))
  model.compile(
      optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])
  return model



            

Reported by Pylint.

                model.add(keras.layers.Activation('relu'))
  model.add(keras.layers.Dense(NUM_CLASSES))
  model.add(keras.layers.Activation('softmax'))
  model.compile(
      optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])
  return model


def assert_classification_works(clf):

            

Reported by Pylint.

              # ==============================================================================
"""Tests for Keras Vis utils."""

import tensorflow.compat.v2 as tf

from absl.testing import parameterized

import keras
from keras.applications import efficientnet

            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

from absl.testing import parameterized

import keras
from keras.applications import efficientnet
from keras.utils import vis_utils


            

Reported by Pylint.

              from keras.utils import vis_utils


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

  def test_plot_model_cnn(self):
    model = keras.Sequential()
    model.add(
        keras.layers.Conv2D(

            

Reported by Pylint.

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

  def test_plot_model_cnn(self):
    model = keras.Sequential()
    model.add(
        keras.layers.Conv2D(
            filters=2, kernel_size=(2, 3), input_shape=(3, 5, 5), name='conv'))
    model.add(keras.layers.Flatten(name='flat'))

            

Reported by Pylint.

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

  def test_plot_model_cnn(self):
    model = keras.Sequential()
    model.add(
        keras.layers.Conv2D(
            filters=2, kernel_size=(2, 3), input_shape=(3, 5, 5), name='conv'))
    model.add(keras.layers.Flatten(name='flat'))

            

Reported by Pylint.

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

  def test_plot_model_cnn(self):
    model = keras.Sequential()
    model.add(
        keras.layers.Conv2D(
            filters=2, kernel_size=(2, 3), input_shape=(3, 5, 5), name='conv'))
    model.add(keras.layers.Flatten(name='flat'))
    model.add(keras.layers.Dense(5, name='dense'))

            

Reported by Pylint.

              
  def test_plot_model_cnn(self):
    model = keras.Sequential()
    model.add(
        keras.layers.Conv2D(
            filters=2, kernel_size=(2, 3), input_shape=(3, 5, 5), name='conv'))
    model.add(keras.layers.Flatten(name='flat'))
    model.add(keras.layers.Dense(5, name='dense'))
    dot_img_file = 'model_1.png'

            

Reported by Pylint.

                  model.add(
        keras.layers.Conv2D(
            filters=2, kernel_size=(2, 3), input_shape=(3, 5, 5), name='conv'))
    model.add(keras.layers.Flatten(name='flat'))
    model.add(keras.layers.Dense(5, name='dense'))
    dot_img_file = 'model_1.png'
    try:
      vis_utils.plot_model(
          model, to_file=dot_img_file, show_shapes=True, show_dtype=True)

            

Reported by Pylint.

                      keras.layers.Conv2D(
            filters=2, kernel_size=(2, 3), input_shape=(3, 5, 5), name='conv'))
    model.add(keras.layers.Flatten(name='flat'))
    model.add(keras.layers.Dense(5, name='dense'))
    dot_img_file = 'model_1.png'
    try:
      vis_utils.plot_model(
          model, to_file=dot_img_file, show_shapes=True, show_dtype=True)
      self.assertTrue(tf.io.gfile.exists(dot_img_file))

            

Reported by Pylint.

                          filters=2, kernel_size=(2, 3), input_shape=(3, 5, 5), name='conv'))
    model.add(keras.layers.Flatten(name='flat'))
    model.add(keras.layers.Dense(5, name='dense'))
    dot_img_file = 'model_1.png'
    try:
      vis_utils.plot_model(
          model, to_file=dot_img_file, show_shapes=True, show_dtype=True)
      self.assertTrue(tf.io.gfile.exists(dot_img_file))
      tf.io.gfile.remove(dot_img_file)

            

Reported by Pylint.