Sign upLogin

tensorflow/models

View on GitHub
Star
research/efficient-hrl/context/rewards_functions.py

Summary

Maintainability
F
5 days
Test Coverage

File rewards_functions.py has 656 lines of code (exceeds 250 allowed). Consider refactoring.
Open

# Copyright 2018 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 research/efficient-hrl/context/rewards_functions.py - About 1 day to fix

    Function negative_distance has 22 arguments (exceeds 4 allowed). Consider refactoring.
    Open

    def negative_distance(states,
    Severity: Major
    Found in research/efficient-hrl/context/rewards_functions.py - About 2 hrs to fix

      Function diff_distance has 16 arguments (exceeds 4 allowed). Consider refactoring.
      Open

      def diff_distance(states,
      Severity: Major
      Found in research/efficient-hrl/context/rewards_functions.py - About 2 hrs to fix

        Function cosine_similarity has 16 arguments (exceeds 4 allowed). Consider refactoring.
        Open

        def cosine_similarity(states,
        Severity: Major
        Found in research/efficient-hrl/context/rewards_functions.py - About 2 hrs to fix

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

          def negative_distance(states,
                      actions,
                      rewards,
                      next_states,
                      contexts,
          Severity: Minor
          Found in research/efficient-hrl/context/rewards_functions.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 state_rewards has 10 arguments (exceeds 4 allowed). Consider refactoring.
          Open

          def state_rewards(states,
          Severity: Major
          Found in research/efficient-hrl/context/rewards_functions.py - About 1 hr to fix

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

            def reset_rewards(states,
            Severity: Major
            Found in research/efficient-hrl/context/rewards_functions.py - About 1 hr to fix

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

              def binary_indicator(states,
              Severity: Major
              Found in research/efficient-hrl/context/rewards_functions.py - About 1 hr to fix

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

                def tanh_similarity(states,
                Severity: Major
                Found in research/efficient-hrl/context/rewards_functions.py - About 1 hr to fix

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

                  def timed_rewards(states,
                  Severity: Major
                  Found in research/efficient-hrl/context/rewards_functions.py - About 1 hr to fix

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

                    def negative_mse(states,
                    Severity: Major
                    Found in research/efficient-hrl/context/rewards_functions.py - About 1 hr to fix

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

                      def potential_rewards(states,
                      Severity: Major
                      Found in research/efficient-hrl/context/rewards_functions.py - About 50 mins to fix

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

                        def diff_rewards(
                        Severity: Major
                        Found in research/efficient-hrl/context/rewards_functions.py - About 50 mins to fix

                          Function ctrl_rewards has 6 arguments (exceeds 4 allowed). Consider refactoring.
                          Open

                          def ctrl_rewards(states,
                          Severity: Minor
                          Found in research/efficient-hrl/context/rewards_functions.py - About 45 mins to fix

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

                            def plain_rewards(states, actions, rewards, next_states, contexts):
                            Severity: Minor
                            Found in research/efficient-hrl/context/rewards_functions.py - About 35 mins to fix

                              Function diff_distance has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                              Open

                              def diff_distance(states,
                  actions,
                  rewards,
                  next_states,
                  contexts,
                              Severity: Minor
                              Found in research/efficient-hrl/context/rewards_functions.py - About 25 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 reset_rewards has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                              Open

                              def reset_rewards(states,
                  actions,
                  rewards,
                  next_states,
                  contexts,
                              Severity: Minor
                              Found in research/efficient-hrl/context/rewards_functions.py - About 25 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

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

                                if summarize:
    with tf.name_scope('RewardFn/'):
      tf.summary.scalar('mean_dist', tf.reduce_mean(dist))
      tf.summary.histogram('dist', dist)
      summarize_stats(stats)
                              Severity: Major
                              Found in research/efficient-hrl/context/rewards_functions.py and 1 other location - About 2 hrs to fix
                              research/efficient-hrl/context/rewards_functions.py on lines 563..567

                              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 51.

                              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 summarize:
    with tf.name_scope('RewardFn/'):
      tf.summary.scalar('mean_dist', tf.reduce_mean(dist))
      tf.summary.histogram('dist', dist)
      summarize_stats(stats)
                              Severity: Major
                              Found in research/efficient-hrl/context/rewards_functions.py and 1 other location - About 2 hrs to fix
                              research/efficient-hrl/context/rewards_functions.py on lines 395..399

                              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 51.

                              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 weight_vector is not None:
    sq_dists *= tf.convert_to_tensor(weight_vector, dtype=next_states.dtype)
    old_sq_dists *= tf.convert_to_tensor(weight_vector, dtype=next_states.dtype)
                              Severity: Major
                              Found in research/efficient-hrl/context/rewards_functions.py and 1 other location - About 1 hr to fix
                              research/efficient-hrl/context/rewards_functions.py on lines 544..546

                              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 weight_vector is not None:
    next_sq_dists *= tf.convert_to_tensor(weight_vector, dtype=next_states.dtype)
    sq_dists *= tf.convert_to_tensor(weight_vector, dtype=next_states.dtype)
                              Severity: Major
                              Found in research/efficient-hrl/context/rewards_functions.py and 1 other location - About 1 hr to fix
                              research/efficient-hrl/context/rewards_functions.py on lines 368..370

                              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

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

                                mse = tf.reduce_mean(tf.squared_difference(next_states * state_scales,
                                             contexts[0] * goal_scales), -1)
                              Severity: Minor
                              Found in research/efficient-hrl/context/rewards_functions.py and 1 other location - About 55 mins to fix
                              research/efficient-hrl/context/rewards_functions.py on lines 290..291

                              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 37.

                              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

                                mse = tf.reduce_mean(tf.squared_difference(next_states * state_scales,
                                             contexts[0] * goal_scales), -1)
                              Severity: Minor
                              Found in research/efficient-hrl/context/rewards_functions.py and 1 other location - About 55 mins to fix
                              research/efficient-hrl/context/rewards_functions.py on lines 245..246

                              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 37.

                              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