# limitations under the License.
# =============================================================================

import keras

import tensorflow.compat.v2 as tf
from tensorflow.python.framework.memory_checker import MemoryChecker



            

Reported by Pylint.

              
import keras

import tensorflow.compat.v2 as tf
from tensorflow.python.framework.memory_checker import MemoryChecker


class MemoryCheckerTest(tf.test.TestCase):


            

Reported by Pylint.

              import keras

import tensorflow.compat.v2 as tf
from tensorflow.python.framework.memory_checker import MemoryChecker


class MemoryCheckerTest(tf.test.TestCase):

  def testKerasBasic(self):

            

Reported by Pylint.

              class MemoryCheckerTest(tf.test.TestCase):

  def testKerasBasic(self):
    # TODO(kkb): Fix the slowness on Forge.
    self.skipTest('This test is too slow on Forge so disabled for now.')

    x = tf.zeros([1, 1])
    y = tf.constant([[3]])
    model = keras.models.Sequential()

            

Reported by Pylint.

                  memory_checker.assert_no_leak_if_all_possibly_except_one()

  def testKerasAdvanced(self):
    # TODO(kkb): Fix the slowness on Forge.
    self.skipTest('This test is too slow on Forge so disabled for now.')

    # A real world example taken from the following.
    # https://github.com/tensorflow/tensorflow/issues/32500
    # b/142150794

            

Reported by Pylint.

              # Copyright 2020 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software

            

Reported by Pylint.

              from tensorflow.python.framework.memory_checker import MemoryChecker


class MemoryCheckerTest(tf.test.TestCase):

  def testKerasBasic(self):
    # TODO(kkb): Fix the slowness on Forge.
    self.skipTest('This test is too slow on Forge so disabled for now.')


            

Reported by Pylint.

              
class MemoryCheckerTest(tf.test.TestCase):

  def testKerasBasic(self):
    # TODO(kkb): Fix the slowness on Forge.
    self.skipTest('This test is too slow on Forge so disabled for now.')

    x = tf.zeros([1, 1])
    y = tf.constant([[3]])

            

Reported by Pylint.

              
class MemoryCheckerTest(tf.test.TestCase):

  def testKerasBasic(self):
    # TODO(kkb): Fix the slowness on Forge.
    self.skipTest('This test is too slow on Forge so disabled for now.')

    x = tf.zeros([1, 1])
    y = tf.constant([[3]])

            

Reported by Pylint.

              
class MemoryCheckerTest(tf.test.TestCase):

  def testKerasBasic(self):
    # TODO(kkb): Fix the slowness on Forge.
    self.skipTest('This test is too slow on Forge so disabled for now.')

    x = tf.zeros([1, 1])
    y = tf.constant([[3]])

            

Reported by Pylint.

              # ==============================================================================
"""Preprocessing stage tests."""

import tensorflow.compat.v2 as tf
# pylint: disable=g-classes-have-attributes

import time
import numpy as np
from keras import keras_parameterized

            

Reported by Pylint.

              """Preprocessing stage tests."""

import tensorflow.compat.v2 as tf
# pylint: disable=g-classes-have-attributes

import time
import numpy as np
from keras import keras_parameterized
from keras.engine import base_preprocessing_layer

            

Reported by Pylint.

              
  def test_adapt(self):

    class PL(base_preprocessing_layer.PreprocessingLayer):

      def __init__(self, **kwargs):
        self.adapt_time = None
        self.adapt_count = 0
        super(PL, self).__init__(**kwargs)

            

Reported by Pylint.

              
  def test_adapt(self):

    class PL(base_preprocessing_layer.PreprocessingLayer):

      def __init__(self, **kwargs):
        self.adapt_time = None
        self.adapt_count = 0
        super(PL, self).__init__(**kwargs)

            

Reported by Pylint.

                      self.adapt_count = 0
        super(PL, self).__init__(**kwargs)

      def adapt(self, data, reset_state=True):
        self.adapt_time = time.time()
        self.adapt_count += 1

      def call(self, inputs):
        return inputs + 1.

            

Reported by Pylint.

                      self.adapt_count = 0
        super(PL, self).__init__(**kwargs)

      def adapt(self, data, reset_state=True):
        self.adapt_time = time.time()
        self.adapt_count += 1

      def call(self, inputs):
        return inputs + 1.

            

Reported by Pylint.

                      self.adapt_time = time.time()
        self.adapt_count += 1

      def call(self, inputs):
        return inputs + 1.

    # Test with NumPy array
    stage = preprocessing_stage.PreprocessingStage([
        PL(),

            

Reported by Pylint.

              import tensorflow.compat.v2 as tf
# pylint: disable=g-classes-have-attributes

import time
import numpy as np
from keras import keras_parameterized
from keras.engine import base_preprocessing_layer
from keras.layers.preprocessing import preprocessing_stage
from keras.layers.preprocessing import preprocessing_test_utils

            

Reported by Pylint.

              

@keras_parameterized.run_all_keras_modes(always_skip_v1=True)
class PreprocessingStageTest(
    keras_parameterized.TestCase,
    preprocessing_test_utils.PreprocessingLayerTest):

  def test_adapt(self):


            

Reported by Pylint.

                  keras_parameterized.TestCase,
    preprocessing_test_utils.PreprocessingLayerTest):

  def test_adapt(self):

    class PL(base_preprocessing_layer.PreprocessingLayer):

      def __init__(self, **kwargs):
        self.adapt_time = None

            

Reported by Pylint.

                PREDICT = 'predict'


# TODO(kathywu): Remove copy in Estimator after nightlies
class EstimatorModeKeys:
  """Standard names for Estimator model modes.

  The following standard keys are defined:


            

Reported by Pylint.

              import collections


class KerasModeKeys:
  """Standard names for model modes.

  The following standard keys are defined:

  * `TRAIN`: training/fitting mode.

            

Reported by Pylint.

              

class KerasModeKeys:
  """Standard names for model modes.

  The following standard keys are defined:

  * `TRAIN`: training/fitting mode.
  * `TEST`: testing/evaluation mode.

            

Reported by Pylint.

                * `PREDICT`: prediction/inference mode.
  """

  TRAIN = 'train'
  TEST = 'test'
  PREDICT = 'predict'


# TODO(kathywu): Remove copy in Estimator after nightlies

            

Reported by Pylint.

                """

  TRAIN = 'train'
  TEST = 'test'
  PREDICT = 'predict'


# TODO(kathywu): Remove copy in Estimator after nightlies
class EstimatorModeKeys:

            

Reported by Pylint.

              
  TRAIN = 'train'
  TEST = 'test'
  PREDICT = 'predict'


# TODO(kathywu): Remove copy in Estimator after nightlies
class EstimatorModeKeys:
  """Standard names for Estimator model modes.

            

Reported by Pylint.

              

# TODO(kathywu): Remove copy in Estimator after nightlies
class EstimatorModeKeys:
  """Standard names for Estimator model modes.

  The following standard keys are defined:

  * `TRAIN`: training/fitting mode.

            

Reported by Pylint.

              
# TODO(kathywu): Remove copy in Estimator after nightlies
class EstimatorModeKeys:
  """Standard names for Estimator model modes.

  The following standard keys are defined:

  * `TRAIN`: training/fitting mode.
  * `EVAL`: testing/evaluation mode.

            

Reported by Pylint.

                * `PREDICT`: predication/inference mode.
  """

  TRAIN = 'train'
  EVAL = 'eval'
  PREDICT = 'infer'


def is_predict(mode):

            

Reported by Pylint.

                """

  TRAIN = 'train'
  EVAL = 'eval'
  PREDICT = 'infer'


def is_predict(mode):
  return mode in [KerasModeKeys.PREDICT, EstimatorModeKeys.PREDICT]

            

Reported by Pylint.

              # limitations under the License.
# ==============================================================================
"""Contains the dropout layer."""
# pylint: disable=g-classes-have-attributes,g-direct-tensorflow-import

from keras import backend as K
from keras.engine.base_layer import Layer
from keras.utils import control_flow_util
import tensorflow.compat.v2 as tf

            

Reported by Pylint.

              # limitations under the License.
# ==============================================================================
"""Contains the dropout layer."""
# pylint: disable=g-classes-have-attributes,g-direct-tensorflow-import

from keras import backend as K
from keras.engine.base_layer import Layer
from keras.utils import control_flow_util
import tensorflow.compat.v2 as tf

            

Reported by Pylint.

              from keras import backend as K
from keras.engine.base_layer import Layer
from keras.utils import control_flow_util
import tensorflow.compat.v2 as tf
from tensorflow.python.util.tf_export import keras_export

# TODO(b/168039935): track dropout rate to decide whether/how to make a
# dropout rate fastpath.
keras_temporary_dropout_rate = tf.__internal__.monitoring.BoolGauge(

            

Reported by Pylint.

              from keras.engine.base_layer import Layer
from keras.utils import control_flow_util
import tensorflow.compat.v2 as tf
from tensorflow.python.util.tf_export import keras_export

# TODO(b/168039935): track dropout rate to decide whether/how to make a
# dropout rate fastpath.
keras_temporary_dropout_rate = tf.__internal__.monitoring.BoolGauge(
    '/tensorflow/api/keras/dropout/temp_rate_is_zero',

            

Reported by Pylint.

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

# TODO(b/168039935): track dropout rate to decide whether/how to make a
# dropout rate fastpath.
keras_temporary_dropout_rate = tf.__internal__.monitoring.BoolGauge(
    '/tensorflow/api/keras/dropout/temp_rate_is_zero',
    'Temporarily record if Keras dropout layer was created w/'
    'constant rate = 0')

            

Reported by Pylint.

                    noise_shape.append(concrete_inputs_shape[i] if value is None else value)
    return tf.convert_to_tensor(noise_shape)

  def call(self, inputs, training=None):
    if training is None:
      training = K.learning_phase()

    def dropped_inputs():
      return tf.nn.dropout(

            

Reported by Pylint.

              
@keras_export('keras.layers.Dropout')
class Dropout(Layer):
  """Applies Dropout to the input.

  The Dropout layer randomly sets input units to 0 with a frequency of `rate`
  at each step during training time, which helps prevent overfitting.
  Inputs not set to 0 are scaled up by 1/(1 - rate) such that the sum over
  all inputs is unchanged.

            

Reported by Pylint.

                    training mode (adding dropout) or in inference mode (doing nothing).
  """

  def __init__(self, rate, noise_shape=None, seed=None, **kwargs):
    super(Dropout, self).__init__(**kwargs)
    if isinstance(rate, (int, float)) and not 0 <= rate <= 1:
      raise ValueError(f'Invalid value {rate} received for '
                       f'`rate`, expected a value between 0 and 1.')
    self.rate = rate

            

Reported by Pylint.

                """

  def __init__(self, rate, noise_shape=None, seed=None, **kwargs):
    super(Dropout, self).__init__(**kwargs)
    if isinstance(rate, (int, float)) and not 0 <= rate <= 1:
      raise ValueError(f'Invalid value {rate} received for '
                       f'`rate`, expected a value between 0 and 1.')
    self.rate = rate
    if isinstance(rate, (int, float)) and not rate:

            

Reported by Pylint.

                """

  def __init__(self, rate, noise_shape=None, seed=None, **kwargs):
    super(Dropout, self).__init__(**kwargs)
    if isinstance(rate, (int, float)) and not 0 <= rate <= 1:
      raise ValueError(f'Invalid value {rate} received for '
                       f'`rate`, expected a value between 0 and 1.')
    self.rate = rate
    if isinstance(rate, (int, float)) and not rate:

            

Reported by Pylint.

              # ==============================================================================
"""This module customizes `test_combinations` for `tf.keras` related tests."""

import tensorflow.compat.v2 as tf

import functools
from keras import testing_utils

KERAS_MODEL_TYPES = ['functional', 'subclass', 'sequential']

            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

import functools
from keras import testing_utils

KERAS_MODEL_TYPES = ['functional', 'subclass', 'sequential']



            

Reported by Pylint.

              

def keras_mode_combinations(mode=None, run_eagerly=None):
  """Returns the default test combinations for tf.keras tests.

  Note that if tf2 is enabled, then v1 session test will be skipped.

  Args:
    mode: List of modes to run the tests. The valid options are 'graph' and

            

Reported by Pylint.

                Returns:
    A list contains all the combinations to be used to generate test cases.
  """
  if mode is None:
    mode = ['eager'] if tf.__internal__.tf2.enabled() else ['graph', 'eager']
  if run_eagerly is None:
    run_eagerly = [True, False]
  result = []
  if 'eager' in mode:

            

Reported by Pylint.

                  A list contains all the combinations to be used to generate test cases.
  """
  if mode is None:
    mode = ['eager'] if tf.__internal__.tf2.enabled() else ['graph', 'eager']
  if run_eagerly is None:
    run_eagerly = [True, False]
  result = []
  if 'eager' in mode:
    result += tf.__internal__.test.combinations.combine(mode=['eager'], run_eagerly=run_eagerly)

            

Reported by Pylint.

                """
  if mode is None:
    mode = ['eager'] if tf.__internal__.tf2.enabled() else ['graph', 'eager']
  if run_eagerly is None:
    run_eagerly = [True, False]
  result = []
  if 'eager' in mode:
    result += tf.__internal__.test.combinations.combine(mode=['eager'], run_eagerly=run_eagerly)
  if 'graph' in mode:

            

Reported by Pylint.

                if mode is None:
    mode = ['eager'] if tf.__internal__.tf2.enabled() else ['graph', 'eager']
  if run_eagerly is None:
    run_eagerly = [True, False]
  result = []
  if 'eager' in mode:
    result += tf.__internal__.test.combinations.combine(mode=['eager'], run_eagerly=run_eagerly)
  if 'graph' in mode:
    result += tf.__internal__.test.combinations.combine(mode=['graph'], run_eagerly=[False])

            

Reported by Pylint.

                  mode = ['eager'] if tf.__internal__.tf2.enabled() else ['graph', 'eager']
  if run_eagerly is None:
    run_eagerly = [True, False]
  result = []
  if 'eager' in mode:
    result += tf.__internal__.test.combinations.combine(mode=['eager'], run_eagerly=run_eagerly)
  if 'graph' in mode:
    result += tf.__internal__.test.combinations.combine(mode=['graph'], run_eagerly=[False])
  return result

            

Reported by Pylint.

                if run_eagerly is None:
    run_eagerly = [True, False]
  result = []
  if 'eager' in mode:
    result += tf.__internal__.test.combinations.combine(mode=['eager'], run_eagerly=run_eagerly)
  if 'graph' in mode:
    result += tf.__internal__.test.combinations.combine(mode=['graph'], run_eagerly=[False])
  return result


            

Reported by Pylint.

                  run_eagerly = [True, False]
  result = []
  if 'eager' in mode:
    result += tf.__internal__.test.combinations.combine(mode=['eager'], run_eagerly=run_eagerly)
  if 'graph' in mode:
    result += tf.__internal__.test.combinations.combine(mode=['graph'], run_eagerly=[False])
  return result



            

Reported by Pylint.

              from __future__ import division
from __future__ import print_function

import tensorflow.compat.v2 as tf

import json
from keras import backend
from keras.feature_column import base_feature_layer as kfc
from keras.saving.saved_model import json_utils

            

Reported by Pylint.

              from keras import backend
from keras.feature_column import base_feature_layer as kfc
from keras.saving.saved_model import json_utils
from tensorflow.python.util.tf_export import keras_export


@keras_export(v1=['keras.layers.DenseFeatures'])
class DenseFeatures(kfc._BaseFeaturesLayer):  # pylint: disable=protected-access
  """A layer that produces a dense `Tensor` based on given `feature_columns`.

            

Reported by Pylint.

              

@keras_export(v1=['keras.layers.DenseFeatures'])
class DenseFeatures(kfc._BaseFeaturesLayer):  # pylint: disable=protected-access
  """A layer that produces a dense `Tensor` based on given `feature_columns`.

  Generally a single example in training data is described with FeatureColumns.
  At the first layer of the model, this column-oriented data should be converted
  to a single `Tensor`.

            

Reported by Pylint.

                def _target_shape(self, input_shape, total_elements):
    return (input_shape[0], total_elements)

  def call(self, features, cols_to_output_tensors=None, training=None):
    """Returns a dense tensor corresponding to the `feature_columns`.

    Example usage:

    >>> t1 = tf.feature_column.embedding_column(

            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

import json
from keras import backend
from keras.feature_column import base_feature_layer as kfc
from keras.saving.saved_model import json_utils
from tensorflow.python.util.tf_export import keras_export


            

Reported by Pylint.

              
@keras_export(v1=['keras.layers.DenseFeatures'])
class DenseFeatures(kfc._BaseFeaturesLayer):  # pylint: disable=protected-access
  """A layer that produces a dense `Tensor` based on given `feature_columns`.

  Generally a single example in training data is described with FeatureColumns.
  At the first layer of the model, this column-oriented data should be converted
  to a single `Tensor`.


            

Reported by Pylint.

                ```
  """

  def __init__(self,
               feature_columns,
               trainable=True,
               name=None,
               partitioner=None,
               **kwargs):

            

Reported by Pylint.

                             name=None,
               partitioner=None,
               **kwargs):
    """Constructs a DenseFeatures layer.

    Args:
      feature_columns: An iterable containing the FeatureColumns to use as
        inputs to your model. All items should be instances of classes derived
        from `DenseColumn` such as `numeric_column`, `embedding_column`,

            

Reported by Pylint.

                  Raises:
      ValueError: if an item in `feature_columns` is not a `DenseColumn`.
    """
    super(DenseFeatures, self).__init__(
        feature_columns=feature_columns,
        trainable=trainable,
        name=name,
        partitioner=partitioner,
        expected_column_type=tf.__internal__.feature_column.DenseColumn,

            

Reported by Pylint.

                  Raises:
      ValueError: if an item in `feature_columns` is not a `DenseColumn`.
    """
    super(DenseFeatures, self).__init__(
        feature_columns=feature_columns,
        trainable=trainable,
        name=name,
        partitioner=partitioner,
        expected_column_type=tf.__internal__.feature_column.DenseColumn,

            

Reported by Pylint.

              # pylint: disable=protected-access
"""Tests the JSON encoder and decoder."""

import tensorflow.compat.v2 as tf

import enum
from keras.saving.saved_model import json_utils



            

Reported by Pylint.

              import tensorflow.compat.v2 as tf

import enum
from keras.saving.saved_model import json_utils


class JsonUtilsTest(tf.test.TestCase):

  def test_encode_decode_tensor_shape(self):

            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

import enum
from keras.saving.saved_model import json_utils


class JsonUtilsTest(tf.test.TestCase):


            

Reported by Pylint.

              from keras.saving.saved_model import json_utils


class JsonUtilsTest(tf.test.TestCase):

  def test_encode_decode_tensor_shape(self):
    metadata = {
        'key1': tf.TensorShape(None),
        'key2': [tf.TensorShape([None]),

            

Reported by Pylint.

              
class JsonUtilsTest(tf.test.TestCase):

  def test_encode_decode_tensor_shape(self):
    metadata = {
        'key1': tf.TensorShape(None),
        'key2': [tf.TensorShape([None]),
                 tf.TensorShape([3, None, 5])]}
    string = json_utils.Encoder().encode(metadata)

            

Reported by Pylint.

              
class JsonUtilsTest(tf.test.TestCase):

  def test_encode_decode_tensor_shape(self):
    metadata = {
        'key1': tf.TensorShape(None),
        'key2': [tf.TensorShape([None]),
                 tf.TensorShape([3, None, 5])]}
    string = json_utils.Encoder().encode(metadata)

            

Reported by Pylint.

              class JsonUtilsTest(tf.test.TestCase):

  def test_encode_decode_tensor_shape(self):
    metadata = {
        'key1': tf.TensorShape(None),
        'key2': [tf.TensorShape([None]),
                 tf.TensorShape([3, None, 5])]}
    string = json_utils.Encoder().encode(metadata)
    loaded = json_utils.decode(string)

            

Reported by Pylint.

                      'key1': tf.TensorShape(None),
        'key2': [tf.TensorShape([None]),
                 tf.TensorShape([3, None, 5])]}
    string = json_utils.Encoder().encode(metadata)
    loaded = json_utils.decode(string)

    self.assertEqual(set(loaded.keys()), {'key1', 'key2'})
    self.assertAllEqual(loaded['key1'].rank, None)
    self.assertAllEqual(loaded['key2'][0].as_list(), [None])

            

Reported by Pylint.

                      'key2': [tf.TensorShape([None]),
                 tf.TensorShape([3, None, 5])]}
    string = json_utils.Encoder().encode(metadata)
    loaded = json_utils.decode(string)

    self.assertEqual(set(loaded.keys()), {'key1', 'key2'})
    self.assertAllEqual(loaded['key1'].rank, None)
    self.assertAllEqual(loaded['key2'][0].as_list(), [None])
    self.assertAllEqual(loaded['key2'][1].as_list(), [3, None, 5])

            

Reported by Pylint.

                  string = json_utils.Encoder().encode(metadata)
    loaded = json_utils.decode(string)

    self.assertEqual(set(loaded.keys()), {'key1', 'key2'})
    self.assertAllEqual(loaded['key1'].rank, None)
    self.assertAllEqual(loaded['key2'][0].as_list(), [None])
    self.assertAllEqual(loaded['key2'][1].as_list(), [3, None, 5])

  def test_encode_decode_tuple(self):

            

Reported by Pylint.

              # ==============================================================================
"""Keras text dataset generation utilities."""

import tensorflow.compat.v2 as tf

import numpy as np
from keras.preprocessing import dataset_utils
from tensorflow.python.util.tf_export import keras_export


            

Reported by Pylint.

              
import numpy as np
from keras.preprocessing import dataset_utils
from tensorflow.python.util.tf_export import keras_export


@keras_export('keras.utils.text_dataset_from_directory',
              'keras.preprocessing.text_dataset_from_directory',
              v1=[])

            

Reported by Pylint.

              @keras_export('keras.utils.text_dataset_from_directory',
              'keras.preprocessing.text_dataset_from_directory',
              v1=[])
def text_dataset_from_directory(directory,
                                labels='inferred',
                                label_mode='int',
                                class_names=None,
                                batch_size=32,
                                max_length=None,

            

Reported by Pylint.

                                              validation_split=None,
                                subset=None,
                                follow_links=False):
  """Generates a `tf.data.Dataset` from text files in a directory.

  If your directory structure is:

  ```
  main_directory/

            

Reported by Pylint.

                    of shape `(batch_size, num_classes)`, representing a one-hot
      encoding of the class index.
  """
  if labels not in ('inferred', None):
    if not isinstance(labels, (list, tuple)):
      raise ValueError(
          '`labels` argument should be a list/tuple of integer labels, of '
          'the same size as the number of text files in the target '
          'directory. If you wish to infer the labels from the subdirectory '

            

Reported by Pylint.

                    encoding of the class index.
  """
  if labels not in ('inferred', None):
    if not isinstance(labels, (list, tuple)):
      raise ValueError(
          '`labels` argument should be a list/tuple of integer labels, of '
          'the same size as the number of text files in the target '
          'directory. If you wish to infer the labels from the subdirectory '
          'names in the target directory, pass `labels="inferred"`. '

            

Reported by Pylint.

                """
  if labels not in ('inferred', None):
    if not isinstance(labels, (list, tuple)):
      raise ValueError(
          '`labels` argument should be a list/tuple of integer labels, of '
          'the same size as the number of text files in the target '
          'directory. If you wish to infer the labels from the subdirectory '
          'names in the target directory, pass `labels="inferred"`. '
          'If you wish to get a dataset that only contains text samples '

            

Reported by Pylint.

                        'names in the target directory, pass `labels="inferred"`. '
          'If you wish to get a dataset that only contains text samples '
          f'(no labels), pass `labels=None`. Received: labels={labels}')
    if class_names:
      raise ValueError('You can only pass `class_names` if '
                       f'`labels="inferred"`. Received: labels={labels}, and '
                       f'class_names={class_names}')
  if label_mode not in {'int', 'categorical', 'binary', None}:
    raise ValueError(

            

Reported by Pylint.

                        'If you wish to get a dataset that only contains text samples '
          f'(no labels), pass `labels=None`. Received: labels={labels}')
    if class_names:
      raise ValueError('You can only pass `class_names` if '
                       f'`labels="inferred"`. Received: labels={labels}, and '
                       f'class_names={class_names}')
  if label_mode not in {'int', 'categorical', 'binary', None}:
    raise ValueError(
        '`label_mode` argument must be one of "int", "categorical", "binary", '

            

Reported by Pylint.

                    raise ValueError('You can only pass `class_names` if '
                       f'`labels="inferred"`. Received: labels={labels}, and '
                       f'class_names={class_names}')
  if label_mode not in {'int', 'categorical', 'binary', None}:
    raise ValueError(
        '`label_mode` argument must be one of "int", "categorical", "binary", '
        f'or None. Received: label_mode={label_mode}')
  if labels is None or label_mode is None:
    labels = None

            

Reported by Pylint.

              introspection (test_util decorators). Please be careful adding new tests here.
"""

import tensorflow.compat.v2 as tf

import keras
from tensorflow.python.eager.memory_tests import memory_test_util



            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

import keras
from tensorflow.python.eager.memory_tests import memory_test_util


class SingleLayerNet(keras.Model):
  """Simple keras model used to ensure that there are no leaks."""

            

Reported by Pylint.

              import tensorflow.compat.v2 as tf

import keras
from tensorflow.python.eager.memory_tests import memory_test_util


class SingleLayerNet(keras.Model):
  """Simple keras model used to ensure that there are no leaks."""


            

Reported by Pylint.

              from tensorflow.python.eager.memory_tests import memory_test_util


class SingleLayerNet(keras.Model):
  """Simple keras model used to ensure that there are no leaks."""

  def __init__(self):
    super(SingleLayerNet, self).__init__()
    self.fc1 = keras.layers.Dense(5)

            

Reported by Pylint.

              

class SingleLayerNet(keras.Model):
  """Simple keras model used to ensure that there are no leaks."""

  def __init__(self):
    super(SingleLayerNet, self).__init__()
    self.fc1 = keras.layers.Dense(5)


            

Reported by Pylint.

              class SingleLayerNet(keras.Model):
  """Simple keras model used to ensure that there are no leaks."""

  def __init__(self):
    super(SingleLayerNet, self).__init__()
    self.fc1 = keras.layers.Dense(5)

  def call(self, x):
    return self.fc1(x)

            

Reported by Pylint.

                """Simple keras model used to ensure that there are no leaks."""

  def __init__(self):
    super(SingleLayerNet, self).__init__()
    self.fc1 = keras.layers.Dense(5)

  def call(self, x):
    return self.fc1(x)


            

Reported by Pylint.

                """Simple keras model used to ensure that there are no leaks."""

  def __init__(self):
    super(SingleLayerNet, self).__init__()
    self.fc1 = keras.layers.Dense(5)

  def call(self, x):
    return self.fc1(x)


            

Reported by Pylint.

              
  def __init__(self):
    super(SingleLayerNet, self).__init__()
    self.fc1 = keras.layers.Dense(5)

  def call(self, x):
    return self.fc1(x)



            

Reported by Pylint.

                  super(SingleLayerNet, self).__init__()
    self.fc1 = keras.layers.Dense(5)

  def call(self, x):
    return self.fc1(x)


class MemoryTest(tf.test.TestCase):


            

Reported by Pylint.

              from __future__ import division
from __future__ import print_function

import tensorflow.compat.v2 as tf

import abc

from keras.saving.saved_model import json_utils
from keras.saving.saved_model import utils

            

Reported by Pylint.

              
import abc

from keras.saving.saved_model import json_utils
from keras.saving.saved_model import utils


class SavedModelSaver(object, metaclass=abc.ABCMeta):
  """Saver defining the methods and properties used to serialize Keras objects.

            

Reported by Pylint.

              import abc

from keras.saving.saved_model import json_utils
from keras.saving.saved_model import utils


class SavedModelSaver(object, metaclass=abc.ABCMeta):
  """Saver defining the methods and properties used to serialize Keras objects.
  """

            

Reported by Pylint.

                  Returns:
      A serialized JSON storing information necessary for recreating this layer.
    """
    # TODO(kathywu): check that serialized JSON can be loaded (e.g., if an
    # object is in the python property)
    return json_utils.Encoder().encode(self.python_properties)

  def list_extra_dependencies_for_serialization(self, serialization_cache):
    """Lists extra dependencies to serialize to SavedModel.

            

Reported by Pylint.

              
import tensorflow.compat.v2 as tf

import abc

from keras.saving.saved_model import json_utils
from keras.saving.saved_model import utils



            

Reported by Pylint.

              from keras.saving.saved_model import utils


class SavedModelSaver(object, metaclass=abc.ABCMeta):
  """Saver defining the methods and properties used to serialize Keras objects.
  """

  def __init__(self, obj):
    self.obj = obj

            

Reported by Pylint.

              

class SavedModelSaver(object, metaclass=abc.ABCMeta):
  """Saver defining the methods and properties used to serialize Keras objects.
  """

  def __init__(self, obj):
    self.obj = obj


            

Reported by Pylint.

                """Saver defining the methods and properties used to serialize Keras objects.
  """

  def __init__(self, obj):
    self.obj = obj

  @abc.abstractproperty
  def object_identifier(self):
    """String stored in object identifier field in the SavedModel proto.

            

Reported by Pylint.

                """

  def __init__(self, obj):
    self.obj = obj

  @abc.abstractproperty
  def object_identifier(self):
    """String stored in object identifier field in the SavedModel proto.


            

Reported by Pylint.

                def __init__(self, obj):
    self.obj = obj

  @abc.abstractproperty
  def object_identifier(self):
    """String stored in object identifier field in the SavedModel proto.

    Returns:
      A string with the object identifier, which is used at load time.

            

Reported by Pylint.