Sign upLogin

tensorflow/tensorflow

View on GitHub
Star
tensorflow/python/keras/engine/training_v1.py

Summary

Maintainability
F
3 wks
Test Coverage

File training_v1.py has 2536 lines of code (exceeds 250 allowed). Consider refactoring.
Open

# Copyright 2015 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
Severity: Major
Found in tensorflow/python/keras/engine/training_v1.py - About 1 wk to fix

    Model has 75 functions (exceeds 20 allowed). Consider refactoring.
    Open

    class Model(training_lib.Model):
  """`Model` groups layers into an object with training and inference features.

  There are two ways to instantiate a `Model`:
    Severity: Major
    Found in tensorflow/python/keras/engine/training_v1.py - About 1 day to fix

      Function _validate_or_infer_batch_size has a Cognitive Complexity of 44 (exceeds 5 allowed). Consider refactoring.
      Open

        def _validate_or_infer_batch_size(self, batch_size, steps, x):
    """Validates that the `batch_size` provided is consistent with InputLayer.

    It's possible that the user specified a static batch size in their
    InputLayer. If so, this method checks the provided `batch_size` and `x`
      Severity: Minor
      Found in tensorflow/python/keras/engine/training_v1.py - About 6 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function compile has a Cognitive Complexity of 37 (exceeds 5 allowed). Consider refactoring.
      Open

        def compile(self,
              optimizer='rmsprop',
              loss=None,
              metrics=None,
              loss_weights=None,
      Severity: Minor
      Found in tensorflow/python/keras/engine/training_v1.py - About 5 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function _standardize_tensors has a Cognitive Complexity of 32 (exceeds 5 allowed). Consider refactoring.
      Open

        def _standardize_tensors(self, x, y, sample_weight, run_eagerly, dict_inputs,
                           is_dataset, class_weight=None, batch_size=None):
    if run_eagerly:
      # In eager mode, do not do shape validation
      # since the network has no input nodes (placeholders) to be fed.
      Severity: Minor
      Found in tensorflow/python/keras/engine/training_v1.py - About 4 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function _distribution_standardize_user_data has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.
      Open

        def _distribution_standardize_user_data(self,
                                          x,
                                          y=None,
                                          sample_weight=None,
                                          class_weight=None,
      Severity: Minor
      Found in tensorflow/python/keras/engine/training_v1.py - About 3 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function _prepare_total_loss has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
      Open

        def _prepare_total_loss(self, masks):
    """Computes total loss from loss functions.

    Args:
        masks: List of mask values corresponding to each model output.
      Severity: Minor
      Found in tensorflow/python/keras/engine/training_v1.py - About 3 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      _TrainingEndpoint has 24 functions (exceeds 20 allowed). Consider refactoring.
      Open

      class _TrainingEndpoint(object):
  """A container for the training output/target and related entities.

  In the case of model with multiple outputs, there is a one-to-one mapping
  between model output (y_pred), model target (y_true), loss, metrics etc.
      Severity: Minor
      Found in tensorflow/python/keras/engine/training_v1.py - About 2 hrs to fix

        Function _process_target_tensor_for_compile has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
        Open

          def _process_target_tensor_for_compile(self, target_tensors):
    if self.run_eagerly:
      # target tensor is not supported with run_eagerly. Create a list with None
      # as placeholder for each output.
      return [None for _ in self.output_names]
        Severity: Minor
        Found in tensorflow/python/keras/engine/training_v1.py - About 2 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function _handle_metrics has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
        Open

          def _handle_metrics(self,
                      outputs,
                      targets=None,
                      skip_target_masks=None,
                      sample_weights=None,
        Severity: Minor
        Found in tensorflow/python/keras/engine/training_v1.py - About 2 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function _compile_from_inputs has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
        Open

          def _compile_from_inputs(self, all_inputs, target, orig_inputs, orig_target):
    if target is not None:
      # We need to use `y` to set the model targets.
      if training_utils_v1.has_tensors(target):
        target = training_utils_v1.cast_if_floating_dtype_and_mismatch(
        Severity: Minor
        Found in tensorflow/python/keras/engine/training_v1.py - About 2 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function fit has 19 arguments (exceeds 4 allowed). Consider refactoring.
        Open

          def fit(self,
        Severity: Major
        Found in tensorflow/python/keras/engine/training_v1.py - About 2 hrs to fix

          Function fit_generator has 14 arguments (exceeds 4 allowed). Consider refactoring.
          Open

            def fit_generator(self,
          Severity: Major
          Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

            Function _set_optimizer has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
            Open

              def _set_optimizer(self, optimizer):
    """Sets self.optimizer.

    Sets self.optimizer to `optimizer`, potentially wrapping it with a
    LossScaleOptimizer.
            Severity: Minor
            Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function _validate_compile_param_for_distribution_strategy has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
            Open

              def _validate_compile_param_for_distribution_strategy(
      self, run_eagerly, sample_weight_mode, target_tensors, weighted_metrics):
    # Validate that arguments passed by the user to `compile` are supported by
    # tf.distribute.Strategy.
    if self._distribution_strategy:
            Severity: Minor
            Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function _set_input_attrs has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
            Open

              def _set_input_attrs(self, inputs):
    """Sets attributes related to the inputs of the Model."""
    if self.inputs:
      raise ValueError('Model inputs are already set.')
            Severity: Minor
            Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function _standardize_user_data has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
            Open

              def _standardize_user_data(self,
                             x,
                             y=None,
                             sample_weight=None,
                             class_weight=None,
            Severity: Minor
            Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function _build_model_with_inputs has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
            Open

              def _build_model_with_inputs(self, inputs, targets):
    """Build the model (set model inputs/outputs), mainly for subclass model."""
    processed_inputs = []
    is_dict_inputs = False
    orig_inputs = inputs
            Severity: Minor
            Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function _set_inputs has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
            Open

              def _set_inputs(self, inputs, outputs=None, training=None):
    """Set model's input and output specs based on the input data received.

    This is to be used for Model subclasses, which do not know at instantiation
    time what their inputs look like.
            Severity: Minor
            Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            Function _standardize_user_data has 11 arguments (exceeds 4 allowed). Consider refactoring.
            Open

              def _standardize_user_data(self,
            Severity: Major
            Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

              Function compile has 34 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                def compile(self,
              optimizer='rmsprop',
              loss=None,
              metrics=None,
              loss_weights=None,
              Severity: Minor
              Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

                Function evaluate has 10 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                  def evaluate(self,
                Severity: Major
                Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

                  Function feed_output_shape has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
                  Open

                    def feed_output_shape(self):
    """The output shape for the feedable target."""
    if not self.has_feedable_training_target():
      return None
                  Severity: Minor
                  Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

                  Function compile has 9 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                    def compile(self,
                  Severity: Major
                  Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

                    Function _distribution_standardize_user_data has 9 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                      def _distribution_standardize_user_data(self,
                    Severity: Major
                    Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

                      Function train_on_batch has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                      Open

                        def train_on_batch(self,
                     x,
                     y=None,
                     sample_weight=None,
                     class_weight=None,
                      Severity: Minor
                      Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function run_eagerly has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                      Open

                        def run_eagerly(self):
    """Settable attribute indicating whether the model should run eagerly.

    Running eagerly means that your model will be run step by step,
    like Python code. Your model might run slower, but it should become easier
                      Severity: Minor
                      Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function predict_on_batch has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                      Open

                        def predict_on_batch(self, x):
    """Returns predictions for a single batch of samples.

    Args:
        x: Input data. It could be:
                      Severity: Minor
                      Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      Function __init__ has 8 arguments (exceeds 4 allowed). Consider refactoring.
                      Open

                        def __init__(self,
                      Severity: Major
                      Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

                        Function predict has 8 arguments (exceeds 4 allowed). Consider refactoring.
                        Open

                          def predict(self,
                        Severity: Major
                        Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

                          Function _standardize_tensors has 8 arguments (exceeds 4 allowed). Consider refactoring.
                          Open

                            def _standardize_tensors(self, x, y, sample_weight, run_eagerly, dict_inputs,
                          Severity: Major
                          Found in tensorflow/python/keras/engine/training_v1.py - About 1 hr to fix

                            Function _set_metric_attributes has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                            Open

                              def _set_metric_attributes(self):
    """Sets the metric attributes on the model for all the model outputs."""
    updated_per_output_metrics = []
    updated_per_output_weighted_metrics = []
    for i, endpoint in enumerate(self._training_endpoints):
                            Severity: Minor
                            Found in tensorflow/python/keras/engine/training_v1.py - About 55 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Function populate_sample_weight has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                            Open

                              def populate_sample_weight(self, sample_weight, sample_weight_mode):
    """Populate the sample weight and based on the sample weight mode."""
    if (sample_weight is None and
        (self.should_skip_target_weights() or sample_weight_mode is None or
         context.executing_eagerly())):
                            Severity: Minor
                            Found in tensorflow/python/keras/engine/training_v1.py - About 55 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Function _convert_scipy_sparse_tensor has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                            Open

                            def _convert_scipy_sparse_tensor(value, expected_input):
  """Handle scipy sparse tensor conversions.

  This method takes a value 'value' and returns the proper conversion. If
  value is a scipy sparse tensor and the expected input is a dense tensor,
                            Severity: Minor
                            Found in tensorflow/python/keras/engine/training_v1.py - About 55 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Function _select_training_loop has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                            Open

                              def _select_training_loop(self, inputs):
    """Select training loop for fit/eval/predict based on the inputs."""
    # TODO(kaftan) or TODO(scottzhu): This check should eventually be nicely
    #  integrated into the data adapters in the v2 loop. We can't do this yet
    #  because we currently have to fall back for unhandled data types.
                            Severity: Minor
                            Found in tensorflow/python/keras/engine/training_v1.py - About 55 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Function create_training_target has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                            Open

                              def create_training_target(self, target, run_eagerly=False):
    """Create training_target instance and update the self.training_target.

    Note that the input target should just be a tensor or None, and
    corresponding training target will be created based on the output and
                            Severity: Minor
                            Found in tensorflow/python/keras/engine/training_v1.py - About 55 mins to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Function predict_generator has 7 arguments (exceeds 4 allowed). Consider refactoring.
                            Open

                              def predict_generator(self,
                            Severity: Major
                            Found in tensorflow/python/keras/engine/training_v1.py - About 50 mins to fix

                              Function _handle_metrics has 7 arguments (exceeds 4 allowed). Consider refactoring.
                              Open

                                def _handle_metrics(self,
                              Severity: Major
                              Found in tensorflow/python/keras/engine/training_v1.py - About 50 mins to fix

                                Function evaluate_generator has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                Open

                                  def evaluate_generator(self,
                                Severity: Major
                                Found in tensorflow/python/keras/engine/training_v1.py - About 50 mins to fix

                                  Avoid deeply nested control flow statements.
                                  Open

                                              if ds_batch_size % num_splits_for_ds != 0:
              raise ValueError(
                  'The batch output shape of your `Dataset` {} '
                  'cannot be divisible by number of replicas {}'.format(
                      ds_batch_size, num_splits_for_ds))
                                  Severity: Major
                                  Found in tensorflow/python/keras/engine/training_v1.py - About 45 mins to fix

                                    Avoid deeply nested control flow statements.
                                    Open

                                                if sample_weight is None:
              sample_weight = mask
            else:
              # Update dimensions of weights to match with mask if possible.
              mask, _, sample_weight = (
                                    Severity: Major
                                    Found in tensorflow/python/keras/engine/training_v1.py - About 45 mins to fix

                                      Avoid deeply nested control flow statements.
                                      Open

                                                  if loss_reduction == losses_utils.ReductionV2.AUTO:
              loss_reduction = losses_utils.ReductionV2.SUM_OVER_BATCH_SIZE

            # Compute the stateless loss value.
            output_loss = losses_utils.reduce_weighted_loss(
                                      Severity: Major
                                      Found in tensorflow/python/keras/engine/training_v1.py - About 45 mins to fix

                                        Avoid deeply nested control flow statements.
                                        Open

                                                    if ds_per_replica_batch_size != static_batch_size:
              raise ValueError('The batch output shape of your `Dataset` is '
                               '{}, which is incompatible with the specified '
                               'batch size of your Input Layer: {}'.format(
                                   ds_per_replica_batch_size,
                                        Severity: Major
                                        Found in tensorflow/python/keras/engine/training_v1.py - About 45 mins to fix

                                          Function test_on_batch has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                                          Open

                                            def test_on_batch(self, x, y=None, sample_weight=None, reset_metrics=True):
    """Test the model on a single batch of samples.

    Args:
        x: Input data. It could be:
                                          Severity: Minor
                                          Found in tensorflow/python/keras/engine/training_v1.py - About 45 mins to fix

                                          Cognitive Complexity

                                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                          A method's cognitive complexity is based on a few simple rules:

                                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                          • Code is considered more complex for each "break in the linear flow of the code"
                                          • Code is considered more complex when "flow breaking structures are nested"

                                          Further reading

                                          Function _update_sample_weight_modes has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                                          Open

                                            def _update_sample_weight_modes(self, sample_weights=None):
    """Updates sample weight modes based on training/eval inputs.

    Sample weight placeholders will be created for all or no outputs
    based on whether sample_weight is provided for any output.
                                          Severity: Minor
                                          Found in tensorflow/python/keras/engine/training_v1.py - About 45 mins to fix

                                          Cognitive Complexity

                                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                          A method's cognitive complexity is based on a few simple rules:

                                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                          • Code is considered more complex for each "break in the linear flow of the code"
                                          • Code is considered more complex when "flow breaking structures are nested"

                                          Further reading

                                          Function train_on_batch has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                          Open

                                            def train_on_batch(self,
                                          Severity: Minor
                                          Found in tensorflow/python/keras/engine/training_v1.py - About 35 mins to fix

                                            Function _handle_per_output_metrics has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                            Open

                                              def _handle_per_output_metrics(self,
                                            Severity: Minor
                                            Found in tensorflow/python/keras/engine/training_v1.py - About 35 mins to fix

                                              Avoid too many return statements within this function.
                                              Open

                                                    return training_generator_v1.GeneratorLikeTrainingLoop()
                                              Severity: Major
                                              Found in tensorflow/python/keras/engine/training_v1.py - About 30 mins to fix

                                                Avoid too many return statements within this function.
                                                Open

                                                      return training_arrays_v1.ArrayLikeTrainingLoop()
                                                Severity: Major
                                                Found in tensorflow/python/keras/engine/training_v1.py - About 30 mins to fix

                                                  Avoid too many return statements within this function.
                                                  Open

                                                        return self.shape
                                                  Severity: Major
                                                  Found in tensorflow/python/keras/engine/training_v1.py - About 30 mins to fix

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                      def _check_call_args(self, method_name):
    """Check that `call` has only one positional arg."""
    # Always allow first arg, regardless of arg name.
    fullargspec = self._call_full_argspec
    if fullargspec.defaults:
                                                    Severity: Major
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 1 day to fix
                                                    tensorflow/python/keras/engine/training.py on lines 2608..2625

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 133.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                      def fit_generator(self,
                    generator,
                    steps_per_epoch=None,
                    epochs=1,
                    verbose=1,
                                                    Severity: Major
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 5 hrs to fix
                                                    tensorflow/python/keras/engine/training.py on lines 1940..1964

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 95.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                            if batch_size is not None:
          if batch_size % num_splits_for_ds != 0:
            raise ValueError('The `batch_size` argument ({}) must be divisible '
                             'the by number of replicas ({})'.format(
                                 batch_size, num_splits_for_ds))
                                                    Severity: Major
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 4 hrs to fix
                                                    tensorflow/python/keras/engine/training_v1.py on lines 1749..1762

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 75.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        if self.run_eagerly or self._distribution_strategy:
      output_dict = training_eager_v1.test_on_batch(
          self,
          x,
          y,
                                                    Severity: Major
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 4 hrs to fix
                                                    tensorflow/python/keras/engine/training_v1.py on lines 1072..1081

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 75.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        if self.run_eagerly or self._distribution_strategy:
      output_dict = training_eager_v1.train_on_batch(
          self,
          x,
          y,
                                                    Severity: Major
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 4 hrs to fix
                                                    tensorflow/python/keras/engine/training_v1.py on lines 1151..1160

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 75.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                              if ds_batch_size is not None:
            if ds_batch_size % num_splits_for_ds != 0:
              raise ValueError(
                  'The batch output shape of your `Dataset` {} '
                  'cannot be divisible by number of replicas {}'.format(
                                                    Severity: Major
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 4 hrs to fix
                                                    tensorflow/python/keras/engine/training_v1.py on lines 1731..1742

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 75.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                      def evaluate_generator(self,
                         generator,
                         steps=None,
                         callbacks=None,
                         max_queue_size=10,
                                                    Severity: Major
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 3 hrs to fix
                                                    tensorflow/python/keras/engine/training.py on lines 1980..1999

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 69.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                      def predict_generator(self,
                        generator,
                        steps=None,
                        callbacks=None,
                        max_queue_size=10,
                                                    Severity: Major
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 2 hrs to fix
                                                    tensorflow/python/keras/engine/training.py on lines 2008..2025

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 60.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        if backend.is_tpu_strategy(self._distribution_strategy):
      if (self._distribution_strategy.extended.steps_per_run > 1 and
          (not saving_utils.is_hdf5_filepath(filepath))):  # pylint: disable=protected-access
        raise ValueError('Load weights is not yet supported with TPUStrategy '
                                                    Severity: Major
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 2 hrs to fix
                                                    tensorflow/python/keras/engine/training.py on lines 2305..2308

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 50.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        if isinstance(self._dtype_policy, policy.PolicyV1):
      loss_scale = self._dtype_policy.loss_scale
    elif self._dtype_policy.name == 'mixed_float16':
      loss_scale = 'dynamic'
    else:
                                                    Severity: Major
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 1 hr to fix
                                                    tensorflow/python/keras/engine/training.py on lines 589..594

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 48.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                            if hasattr(value, 'shape') and hasattr(value, 'dtype'):
          return tensor_spec.TensorSpec(value.shape, value.dtype)
        else:
          return type_spec.type_spec_from_value(value)
                                                    Severity: Major
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 1 hr to fix
                                                    tensorflow/python/keras/utils/tf_utils.py on lines 378..381

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 43.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                          ins = x + list(y or []) + list(sample_weights or [])
                                                    Severity: Minor
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 45 mins to fix
                                                    tensorflow/python/keras/engine/training_v1.py on lines 1163..1163

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 35.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                          inputs = x + list(y or []) + list(sample_weights or [])
                                                    Severity: Minor
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 45 mins to fix
                                                    tensorflow/python/keras/engine/training_v1.py on lines 1084..1084

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 35.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                    Open

                                                          if not all(tensor_util.is_tf_type(v) for v in all_inputs):
        raise ValueError('Do not pass inputs that mix Numpy arrays and '
                         'TensorFlow tensors. '
                         'You passed: x=' + str(orig_inputs) +
                         '; y=' + str(orig_target))
                                                    Severity: Minor
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 2 other locations - About 35 mins to fix
                                                    tensorflow/python/keras/backend.py on lines 4490..4495
                                                    tensorflow/python/keras/layers/merge.py on lines 78..81

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 33.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                            fn = backend.function(
            inputs, [self.total_loss] + metrics_tensors,
            updates=updates,
            name='train_function',
            **self._function_kwargs)
                                                    Severity: Minor
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 35 mins to fix
                                                    tensorflow/python/keras/engine/training_v1.py on lines 2067..2071

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 33.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                            fn = backend.function(
            inputs, [self.total_loss] + metrics_tensors,
            updates=updates,
            name='test_function',
            **self._function_kwargs)
                                                    Severity: Minor
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 35 mins to fix
                                                    tensorflow/python/keras/engine/training_v1.py on lines 2037..2041

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 33.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        return func.predict(
                                                    Severity: Minor
                                                    Found in tensorflow/python/keras/engine/training_v1.py and 1 other location - About 30 mins to fix
                                                    tensorflow/lite/experimental/microfrontend/python/kernel_tests/audio_microfrontend_op_test.py on lines 42..42

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 32.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    There are no issues that match your filters.

                                                    Category
                                                    Status