Repository: RasaHQ/rasa
Pull request: Remove Policy deprecations and set max_history default to None.
**Proposed changes**:

- Remove the following deprecated policy classes:
  - `FormPolicy`
  - `MappingPolicy`
  - `FallbackPolicy`
  - `TwoStageFallbackPolicy`  
  - `SklearnPolicy`
- Update the max history defaults in `MemoizationPolicy`.
- Remove/edit tests that depended on deprecated modules.
- Remove deprecated policies from docs.
- Remove any soon-to-be-broken links from CHANGELOG.mdx to docs sections for these policies. 
  
**Status (please check what you already did)**:
- [X] Remove deprecated policy classes.
- [x] Update the max history defaults in policies
- [x] Remove/edit tests that depended on these modules
- [X] Remove deprecated policies from docs
- [x] Remove any soon-to-be-broken links from CHANGELOG.mdx to docs sections for these policies. 
- [x] updated the changelog (please check [changelog](https://github.com/RasaHQ/rasa/tree/main/changelog) for instructions)
- [x] reformat files using `black` (please check [Readme](https://github.com/RasaHQ/rasa#code-style) for instructions)


Problem statement:
3.0 Deprecation Warnings: Remove Policy deprecations
**Background**
These warnings were found in:
- rasa.core.policies.fallback.py:L66
```
"f""'{self.__class__.__name__}' is deprecated and will be removed ""
""in the future. It is recommended to use the 'RulePolicy' instead."""
```
- rasa.core.policies.form_policy.py:L51
```
"f""'{FormPolicy.__name__}' is deprecated and will be removed in ""
 ""in the future. It is recommended to use the 'RulePolicy' instead."""
```
- rasa.core.policies.mapping_policy.py:L49
```
"f""'{MappingPolicy.__name__}' is deprecated and will be removed in ""
""the future. It is recommended to use the 'RulePolicy' instead."""
```
- rasa.core.policies.memoization.py:L87
```
"f""Please configure the max history in your configuration file, ""
f""currently 'max_history' is set to old default value of ""
f""'{max_history}'. If you want to have infinite max history ""
f""set it to 'None' explicitly. We will change the default value of ""
 f""'max_history' in the future to 'None'."","
```
- rasa.core.policies.sklearn_policy.py:L124
```
"f""'{SklearnPolicy.__name__}' is deprecated and will be removed in ""
""the future. It is recommended to use the 'TEDPolicy' instead."""
```

**Definition of Done**
- [x] resolve warnings in 3.0 version
- [x] Removed the deprecated policies from the codebase.
- [x] Added a changelog entry for 3.0 saying we've removed the previously deprecated policies
- [x] Removed the references in the docs

Hints from issue discussion:
@ancalita @JEM-Mosig @TyDunn  `TwoStageFallbackPolicy` is listed as deprecated in our [docs page](https://rasa.com/docs/rasa/policies#two-stage-fallback-policy), but does not have a deprecation warning in its constructor. Is this an oversight and should we also remove it from the code base along with these other deprecated policies?
Also it turns out `TwoStageFallbackPolicy` is a subclass of `FallbackPolicy` so I guess it has to go.
> Is this an oversight?

I'd guess it was or maybe since it was subclass of `FallbackPolicy`, someone did not think it was necessary

Commit message: Removed broken links in changelog.

Patch to review:
diff --git a/CHANGELOG.mdx b/CHANGELOG.mdx
index 45b4ddc82ca7..a673a812c22b 100644
--- a/CHANGELOG.mdx
+++ b/CHANGELOG.mdx
@@ -667,7 +667,7 @@ https://github.com/RasaHQ/rasa/tree/main/changelog/ . -->
 
 ### Improvements
 - [#7520](https://github.com/rasahq/rasa/issues/7520): Improve the warning in case the [RulePolicy](policies.mdx#rule-policy) or the deprecated 
-  [MappingPolicy](policies.mdx#mapping-policy) are missing
+  `MappingPolicy` are missing
   from the model's `policies` configuration. Changed the info log to a warning as one
   of this policies should be added to the model configuration.
 
@@ -1412,10 +1412,10 @@ https://github.com/RasaHQ/rasa/tree/main/changelog/ . -->
   custom `Policy` implementation doesn't provide this parameter Rasa Open Source
   will print a warning and omit passing the `interpreter`.
 - [#6088](https://github.com/rasahq/rasa/issues/6088): Added the new dialogue policy RulePolicy which will replace the old “rule-like”
-  policies [Mapping Policy](./policies.mdx#mapping-policy),
-  [Fallback Policy](./policies.mdx#fallback-policy),
-  [Two-Stage Fallback Policy](./policies.mdx#two-stage-fallback-policy), and
-  [Form Policy](./policies.mdx#form-policy). These policies are now
+  policies Mapping Policy,
+  Fallback Policy,
+  Two-Stage Fallback Policy, and
+  Form Policy. These policies are now
   deprecated and will be removed in the future. Please see the
   [rules documentation](./rules.mdx) for more information.
 
@@ -2310,7 +2310,7 @@ https://github.com/RasaHQ/rasa/tree/main/changelog/ . -->
 ### Bugfixes
 
 * [#5205](https://github.com/rasahq/rasa/issues/5205): Fixed the bug when FormPolicy was overwriting MappingPolicy prediction (e.g. `/restart`).
-  Priorities for [Mapping Policy](./policies.mdx#mapping-policy) and [Form Policy](./policies.mdx#form-policy) are no longer linear:
+  Priorities for Mapping Policy and Form Policy are no longer linear:
   `FormPolicy` priority is 5, but its prediction is ignored if `MappingPolicy` is used for prediction.
 
 * [#5215](https://github.com/rasahq/rasa/issues/5215): Fixed issue related to storing Python `float` values as `decimal.Decimal` objects
@@ -2506,7 +2506,7 @@ https://github.com/RasaHQ/rasa/tree/main/changelog/ . -->
 * [#4006](https://github.com/rasahq/rasa/issues/4006): Fixed timestamp parsing warning when using DucklingHTTPExtractor
 
 * [#4601](https://github.com/rasahq/rasa/issues/4601): Fixed issue with `action_restart` getting overridden by `action_listen` when the `MappingPolicy` and the
-  [TwoStageFallbackPolicy](./policies.mdx#two-stage-fallback-policy) are used together.
+  `TwoStageFallbackPolicy` are used together.
 
 * [#5201](https://github.com/rasahq/rasa/issues/5201): Fixed incorrectly raised Error encountered in pipelines with a `ResponseSelector` and NLG.
 
diff --git a/changelog/8880.removal.mdx b/changelog/8880.removal.mdx
new file mode 100644
index 000000000000..55b7ce69cb0e
--- /dev/null
+++ b/changelog/8880.removal.mdx
@@ -0,0 +1,3 @@
+Follow through with removing deprecated policies. 
+
+Remove warning about default value of `max_history` in MemoizationPolicy. The default value is now `None`.
diff --git a/docs/docs/migration-guide.mdx b/docs/docs/migration-guide.mdx
index 2e0444703439..299581ed3b4d 100644
--- a/docs/docs/migration-guide.mdx
+++ b/docs/docs/migration-guide.mdx
@@ -418,10 +418,10 @@ some additional changes will need to be made as described in their respective se
 With the introduction of [rules](./rules.mdx) and the [RulePolicy](./policies.mdx#rule-policy),
 the following policies are deprecated:
 
-- [Mapping Policy](./policies.mdx#mapping-policy)
-- [Fallback Policy](./policies.mdx#fallback-policy)
-- [Two-Stage-Fallback Policy](./policies.mdx#two-stage-fallback-policy)
-- [Form Policy](./policies.mdx#form-policy)
+- `Mapping Policy`
+- `Fallback Policy`
+- `Two-Stage-Fallback Policy`
+- `Form Policy`
 
 
 To migrate the policies automatically, you can run the following command:
@@ -442,7 +442,7 @@ You can also migrate the individual policies manually, if you don't want to use
 
 #### Manually migrating from the Mapping Policy
 
-If you previously used the [Mapping Policy](./policies.mdx#mapping-policy), you
+If you previously used the `Mapping Policy`, you
 can follow the documentation on [FAQs](./chitchat-faqs.mdx) to convert your mapped
 intents to rules. Suppose you previously mapped an intent `ask_is_bot` as follows:
 
@@ -480,7 +480,7 @@ policies:
 
 #### Manually migrating from the Fallback Policy
 
-If you previously used the [Fallback Policy](./policies.mdx#fallback-policy), the following model
+If you previously used the `Fallback Policy`, the following model
 configuration would translate as follows given a previous configuration like this:
 
 ```yaml-rasa title="config.yml"
@@ -525,7 +525,7 @@ information.
 #### Manually migrating from the Two-Stage-Fallback Policy
 
 If you previously used the
-[Two-Stage-Fallback Policy](./policies.mdx#two-stage-fallback-policy), with a configuration
+`Two-Stage-Fallback Policy`, with a configuration
 like this for example:
 
 ```yaml-rasa title="config.yml"
diff --git a/docs/docs/policies.mdx b/docs/docs/policies.mdx
index 9e8e56a96368..c09f474a0263 100644
--- a/docs/docs/policies.mdx
+++ b/docs/docs/policies.mdx
@@ -1096,41 +1096,3 @@ policies:
   - name: "path.to.your.policy.class"
     arg1: "..."
 ```
-
-## Deprecated Policies
-
-### Mapping Policy
-
-:::caution Deprecated
-The `MappingPolicy` is deprecated. Please see [Rules](./rules.mdx) for how to implement
-its behavior using the [Rule Policy](#rule-policy). If you previously used
-the `MappingPolicy`, see the
-[migration guide](./migration-guide.mdx#manually-migrating-from-the-mapping-policy).
-:::
-
-### Fallback Policy
-
-:::caution Deprecated
-The `FallbackPolicy` is deprecated. Please see [Fallbacks](./fallback-handoff.mdx#fallbacks) for how to implement
-its behavior using the [Rule Policy](#rule-policy). If you previously used
-the `FallbackPolicy`, see the
-[migration guide](./migration-guide.mdx#manually-migrating-from-the-fallback-policy).
-:::
-
-### Two-Stage Fallback Policy
-
-:::caution Deprecated
-The `TwoStageFallbackPolicy` is deprecated. Please see [Fallbacks](./fallback-handoff.mdx#fallbacks) for how to implement
-its behavior using the [Rule Policy](#rule-policy). If you previously used
-the `TwoStageFallbackPolicy`, see the
-[migration guide](./migration-guide.mdx#manually-migrating-from-the-two-stage-fallback-policy).
-:::
-
-### Form Policy
-
-:::caution Deprecated
-The `FormPolicy` is deprecated. Please see [Forms](./forms.mdx) for how to implement
-its behavior using the [Rule Policy](#rule-policy). If you previously used
-the `FormPolicy`, see the
-[migration guide](./migration-guide.mdx#forms).
-:::
diff --git a/rasa/core/constants.py b/rasa/core/constants.py
index 8620cd0fb90e..4be07bd49d39 100644
--- a/rasa/core/constants.py
+++ b/rasa/core/constants.py
@@ -10,6 +10,8 @@
 
 DEFAULT_CORE_FALLBACK_THRESHOLD = 0.3
 
+DEFAULT_MAX_HISTORY = None  # Core policy history is unbounded by default.
+
 DEFAULT_REQUEST_TIMEOUT = 60 * 5  # 5 minutes
 
 DEFAULT_RESPONSE_TIMEOUT = 60 * 60  # 1 hour
@@ -18,7 +20,7 @@
 
 BEARER_TOKEN_PREFIX = "Bearer "
 
-# the lowest priority intended to be used by machine learning policies
+# The lowest priority is intended to be used by machine learning policies.
 DEFAULT_POLICY_PRIORITY = 1
 
 # The priority of intent-prediction policies.
@@ -34,21 +36,12 @@
 # policies to predict a winning action prediction.
 UNLIKELY_INTENT_POLICY_PRIORITY = DEFAULT_POLICY_PRIORITY + 1
 
-# the priority intended to be used by mapping policies
-MAPPING_POLICY_PRIORITY = UNLIKELY_INTENT_POLICY_PRIORITY + 1
-# the priority intended to be used by memoization policies
-# it is higher than default and mapping to prioritize training stories
-MEMOIZATION_POLICY_PRIORITY = MAPPING_POLICY_PRIORITY + 1
-# the priority intended to be used by fallback policies
-# it is higher than memoization to prioritize fallback
-FALLBACK_POLICY_PRIORITY = MEMOIZATION_POLICY_PRIORITY + 1
-# the priority intended to be used by form policies
-# it is the highest to prioritize form to the rest of the policies
-FORM_POLICY_PRIORITY = FALLBACK_POLICY_PRIORITY + 1
-# The priority of the `RulePolicy` is higher than the priorities for `FallbackPolicy`,
-# `TwoStageFallbackPolicy` and `FormPolicy` to make it possible to use the
-# `RulePolicy` in conjunction with these deprecated policies.
-RULE_POLICY_PRIORITY = FORM_POLICY_PRIORITY + 1
+# The priority intended to be used by memoization policies.
+# It is higher than default to prioritize training stories.
+MEMOIZATION_POLICY_PRIORITY = UNLIKELY_INTENT_POLICY_PRIORITY + 1
+# The priority of the `RulePolicy` is higher than all other policies since
+# rule execution takes precedence over training stories or predicted actions.
+RULE_POLICY_PRIORITY = MEMOIZATION_POLICY_PRIORITY + 1
 
 DIALOGUE = "dialogue"
 
diff --git a/rasa/core/policies/ensemble.py b/rasa/core/policies/ensemble.py
index 67d03cdfd377..ea7ba0bf2329 100644
--- a/rasa/core/policies/ensemble.py
+++ b/rasa/core/policies/ensemble.py
@@ -11,7 +11,6 @@
 
 import rasa.core
 import rasa.core.training.training
-from rasa.core.constants import FALLBACK_POLICY_PRIORITY
 from rasa.shared.exceptions import RasaException, InvalidConfigException
 import rasa.shared.utils.common
 import rasa.shared.utils.io
@@ -20,7 +19,6 @@
 from rasa.shared.constants import (
     DOCS_URL_RULES,
     DOCS_URL_POLICIES,
-    DOCS_URL_MIGRATION_GUIDE,
     DEFAULT_CONFIG_PATH,
     DOCS_URL_DEFAULT_ACTIONS,
 )
@@ -41,7 +39,6 @@
 from rasa.core.featurizers.tracker_featurizers import MaxHistoryTrackerFeaturizer
 from rasa.shared.nlu.interpreter import NaturalLanguageInterpreter
 from rasa.core.policies.policy import Policy, SupportedData, PolicyPrediction
-from rasa.core.policies.fallback import FallbackPolicy
 from rasa.core.policies.memoization import MemoizationPolicy, AugmentedMemoizationPolicy
 from rasa.core.policies.rule_policy import RulePolicy
 from rasa.core.training import training
@@ -82,17 +79,14 @@ def _set_rule_only_data(self) -> None:
             policy.set_shared_policy_states(rule_only_data=rule_only_data)
 
     def _check_for_important_policies(self) -> None:
-        from rasa.core.policies.mapping_policy import MappingPolicy
 
-        if not any(
-            isinstance(policy, (MappingPolicy, RulePolicy)) for policy in self.policies
-        ):
+        if not any(isinstance(policy, RulePolicy) for policy in self.policies):
             rasa.shared.utils.io.raise_warning(
-                f"Neither '{RulePolicy.__name__}' nor '{MappingPolicy.__name__}' "
-                f"(deprecated) are included in the model's policy configuration. "
-                f"Default intents such as '{USER_INTENT_RESTART}' and "
-                f"'{USER_INTENT_BACK}' will not trigger actions "
-                f"'{ACTION_RESTART_NAME}' and '{ACTION_BACK_NAME}'.",
+                f"'{RulePolicy.__name__}' is not included in the model's "
+                f"policy configuration. Default intents such as "
+                f"'{USER_INTENT_RESTART}' and '{USER_INTENT_BACK}' will "
+                f"not trigger actions '{ACTION_RESTART_NAME}' and "
+                f"'{ACTION_BACK_NAME}'.",
                 docs=DOCS_URL_DEFAULT_ACTIONS,
             )
 
@@ -101,13 +95,7 @@ def check_domain_ensemble_compatibility(
         ensemble: Optional["PolicyEnsemble"], domain: Optional[Domain]
     ) -> None:
         """Check for elements that only work with certain policy/domain combinations."""
-
-        from rasa.core.policies.mapping_policy import MappingPolicy
-        from rasa.core.policies.two_stage_fallback import TwoStageFallbackPolicy
-
         policies_needing_validation = [
-            MappingPolicy,
-            TwoStageFallbackPolicy,
             RulePolicy,
         ]
         for policy in policies_needing_validation:
@@ -436,12 +424,11 @@ def from_dict(cls, policy_configuration: Dict[Text, Any]) -> List[Policy]:
                     f"name is a valid policy."
                 ) from e
 
-        cls._check_if_rule_policy_used_with_rule_like_policies(parsed_policies)
-
         return parsed_policies
 
     @classmethod
     def get_featurizer_from_dict(cls, policy: Dict[Text, Any]) -> Tuple[Any, Any]:
+        """Gets the featurizer initializer and its arguments from a policy config."""
         # policy can have only 1 featurizer
         if len(policy["featurizer"]) > 1:
             raise InvalidPolicyConfig(
@@ -474,39 +461,6 @@ def get_state_featurizer_from_dict(
 
         return state_featurizer_func, state_featurizer_config
 
-    @staticmethod
-    def _check_if_rule_policy_used_with_rule_like_policies(
-        policies: List[Policy],
-    ) -> None:
-        if not any(isinstance(policy, RulePolicy) for policy in policies):
-            return
-
-        from rasa.core.policies.mapping_policy import MappingPolicy
-        from rasa.core.policies.form_policy import FormPolicy
-        from rasa.core.policies.two_stage_fallback import TwoStageFallbackPolicy
-
-        policies_not_be_used_with_rule_policy = (
-            MappingPolicy,
-            FormPolicy,
-            FallbackPolicy,
-            TwoStageFallbackPolicy,
-        )
-
-        if any(
-            isinstance(policy, policies_not_be_used_with_rule_policy)
-            for policy in policies
-        ):
-            rasa.shared.utils.io.raise_warning(
-                f"It is not recommended to use the '{RulePolicy.__name__}' with "
-                f"other policies which implement rule-like "
-                f"behavior. It is highly recommended to migrate all deprecated "
-                f"policies to use the '{RulePolicy.__name__}'. Note that the "
-                f"'{RulePolicy.__name__}' will supersede the predictions of the "
-                f"deprecated policies if the confidence levels of the predictions are "
-                f"equal.",
-                docs=DOCS_URL_MIGRATION_GUIDE,
-            )
-
 
 class SimplePolicyEnsemble(PolicyEnsemble):
     """Default implementation of a `Policy` ensemble."""
@@ -539,22 +493,6 @@ def is_not_in_training_data(
         # also check if confidence is 0, than it cannot be count as prediction
         return not is_memorized or max_confidence == 0.0
 
-    @staticmethod
-    def _is_not_mapping_policy(
-        policy_name: Text, max_confidence: Optional[float] = None
-    ) -> bool:
-        from rasa.core.policies.mapping_policy import MappingPolicy
-
-        is_mapping = policy_name.endswith("_" + MappingPolicy.__name__)
-        # also check if confidence is 0, than it cannot be count as prediction
-        return not is_mapping or max_confidence == 0.0
-
-    @staticmethod
-    def _is_form_policy(policy_name: Text) -> bool:
-        from rasa.core.policies.form_policy import FormPolicy
-
-        return policy_name.endswith("_" + FormPolicy.__name__)
-
     def _pick_best_policy(
         self, predictions: Dict[Text, PolicyPrediction]
     ) -> PolicyPrediction:
@@ -569,14 +507,7 @@ def _pick_best_policy(
         """
         best_confidence = (-1, -1)
         best_policy_name = None
-        # form and mapping policies are special:
-        # form should be above fallback
-        # mapping should be below fallback
-        # mapping is above form if it wins over fallback
-        # therefore form predictions are stored separately
-
-        form_confidence = None
-        form_policy_name = None
+
         # different type of predictions have different priorities
         # No user predictions overrule all other predictions.
         is_no_user_prediction = any(
@@ -604,22 +535,11 @@ def _pick_best_policy(
                 continue
 
             confidence = (prediction.max_confidence, prediction.policy_priority)
-            if self._is_form_policy(policy_name):
-                # store form prediction separately
-                form_confidence = confidence
-                form_policy_name = policy_name
-            elif confidence > best_confidence:
+            if confidence > best_confidence:
                 # pick the best policy
                 best_confidence = confidence
                 best_policy_name = policy_name
 
-        if form_confidence is not None and self._is_not_mapping_policy(
-            best_policy_name, best_confidence[0]
-        ):
-            # if mapping didn't win, check form policy predictions
-            if form_confidence > best_confidence:
-                best_policy_name = form_policy_name
-
         best_prediction = predictions.get(best_policy_name)
 
         if not best_prediction:
@@ -694,44 +614,6 @@ def _best_policy_prediction(
 
         return self._pick_best_policy(predictions)
 
-    def _fallback_after_listen(
-        self, domain: Domain, prediction: PolicyPrediction
-    ) -> PolicyPrediction:
-        """Triggers fallback if `action_listen` is predicted after a user utterance.
-
-        This is done on the condition that:
-        - a fallback policy is present,
-        - we received a user message and the predicted action is `action_listen`
-          by a policy other than the `MemoizationPolicy` or one of its subclasses.
-
-        Args:
-            domain: the :class:`rasa.shared.core.domain.Domain`
-            prediction: The winning prediction.
-
-        Returns:
-            The prediction for the next action.
-        """
-        fallback_idx_policy = [
-            (i, p) for i, p in enumerate(self.policies) if isinstance(p, FallbackPolicy)
-        ]
-
-        if not fallback_idx_policy:
-            return prediction
-
-        fallback_idx, fallback_policy = fallback_idx_policy[0]
-
-        logger.debug(
-            f"Action '{ACTION_LISTEN_NAME}' was predicted after "
-            f"a user message using {prediction.policy_name}. Predicting "
-            f"fallback action: {fallback_policy.fallback_action_name}"
-        )
-
-        return PolicyPrediction(
-            fallback_policy.fallback_scores(domain),
-            f"policy_{fallback_idx}_{type(fallback_policy).__name__}",
-            FALLBACK_POLICY_PRIORITY,
-        )
-
     def probabilities_using_best_policy(
         self,
         tracker: DialogueStateTracker,
@@ -755,17 +637,6 @@ def probabilities_using_best_policy(
         """
         winning_prediction = self._best_policy_prediction(tracker, domain, interpreter)
 
-        if (
-            tracker.latest_action_name == ACTION_LISTEN_NAME
-            and winning_prediction.probabilities is not None
-            and winning_prediction.max_confidence_index
-            == domain.index_for_action(ACTION_LISTEN_NAME)
-            and self.is_not_in_training_data(
-                winning_prediction.policy_name, winning_prediction.max_confidence
-            )
-        ):
-            winning_prediction = self._fallback_after_listen(domain, winning_prediction)
-
         if tracker.latest_action_name == ACTION_LISTEN_NAME:
             if winning_prediction.is_end_to_end_prediction:
                 logger.debug("Made e2e prediction using user text.")
@@ -790,20 +661,16 @@ def _check_policy_for_forms_available(
     if not ensemble:
         return
 
-    from rasa.core.policies.form_policy import FormPolicy
-
-    suited_policies_for_forms = (FormPolicy, RulePolicy)
-
     has_policy_for_forms = ensemble is not None and any(
-        isinstance(policy, suited_policies_for_forms) for policy in ensemble.policies
+        isinstance(policy, RulePolicy) for policy in ensemble.policies
     )
 
     if domain.form_names and not has_policy_for_forms:
         raise InvalidDomain(
-            "You have defined a form action, but have neither added the "
-            f"'{RulePolicy.__name__}' nor the '{FormPolicy.__name__}' (deprecated) to "
-            f"your policy ensemble. Either remove all forms from your domain or add "
-            f"the missing policy to your policy configuration."
+            "You have defined a form action, but have not added the "
+            f"'{RulePolicy.__name__}' to your policy ensemble. Either "
+            f"remove all forms from your domain or add the missing policy "
+            f"to your policy configuration."
         )
 
 
diff --git a/rasa/core/policies/fallback.py b/rasa/core/policies/fallback.py
deleted file mode 100644
index 9ddb96b4ff84..000000000000
--- a/rasa/core/policies/fallback.py
+++ /dev/null
@@ -1,206 +0,0 @@
-import logging
-from typing import Any, List, Text, Optional, Dict, Tuple
-
-import rasa.shared.utils.common
-import rasa.shared.utils.io
-from rasa.shared.constants import DOCS_URL_MIGRATION_GUIDE
-from rasa.shared.core.constants import ACTION_LISTEN_NAME, ACTION_DEFAULT_FALLBACK_NAME
-
-from rasa.shared.core.domain import Domain
-from rasa.shared.nlu.interpreter import NaturalLanguageInterpreter
-from rasa.core.policies.policy import Policy, PolicyPrediction
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.core.generator import TrackerWithCachedStates
-from rasa.core.constants import (
-    FALLBACK_POLICY_PRIORITY,
-    DEFAULT_NLU_FALLBACK_THRESHOLD,
-    DEFAULT_CORE_FALLBACK_THRESHOLD,
-    DEFAULT_NLU_FALLBACK_AMBIGUITY_THRESHOLD,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class FallbackPolicy(Policy):
-    """Policy which predicts fallback actions.
-
-    A fallback can be triggered by a low confidence score on a
-    NLU prediction or by a low confidence score on an action
-    prediction."""
-
-    @staticmethod
-    def _standard_featurizer() -> None:
-        return None
-
-    def __init__(
-        self,
-        priority: int = FALLBACK_POLICY_PRIORITY,
-        nlu_threshold: float = DEFAULT_NLU_FALLBACK_THRESHOLD,
-        ambiguity_threshold: float = DEFAULT_NLU_FALLBACK_AMBIGUITY_THRESHOLD,
-        core_threshold: float = DEFAULT_CORE_FALLBACK_THRESHOLD,
-        fallback_action_name: Text = ACTION_DEFAULT_FALLBACK_NAME,
-        **kwargs: Any,
-    ) -> None:
-        """Create a new Fallback policy.
-
-        Args:
-            priority: Fallback policy priority.
-            core_threshold: if NLU confidence threshold is met,
-                predict fallback action with confidence `core_threshold`.
-                If this is the highest confidence in the ensemble,
-                the fallback action will be executed.
-            nlu_threshold: minimum threshold for NLU confidence.
-                If intent prediction confidence is lower than this,
-                predict fallback action with confidence 1.0.
-            ambiguity_threshold: threshold for minimum difference
-                between confidences of the top two predictions
-            fallback_action_name: name of the action to execute as a fallback
-        """
-        super().__init__(priority=priority, **kwargs)
-
-        self.nlu_threshold = nlu_threshold
-        self.ambiguity_threshold = ambiguity_threshold
-        self.core_threshold = core_threshold
-        self.fallback_action_name = fallback_action_name
-
-        rasa.shared.utils.io.raise_deprecation_warning(
-            f"'{self.__class__.__name__}' is deprecated and will be removed "
-            "in the future. It is recommended to use the 'RulePolicy' instead.",
-            docs=DOCS_URL_MIGRATION_GUIDE,
-        )
-
-    def train(
-        self,
-        training_trackers: List[TrackerWithCachedStates],
-        domain: Domain,
-        interpreter: NaturalLanguageInterpreter,
-        **kwargs: Any,
-    ) -> None:
-        """Does nothing. This policy is deterministic."""
-
-        pass
-
-    def nlu_confidence_below_threshold(
-        self, nlu_data: Dict[Text, Any]
-    ) -> Tuple[bool, float]:
-        """Check if the highest confidence is lower than ``nlu_threshold``."""
-
-        # if NLU interpreter does not provide confidence score,
-        # it is set to 1.0 here in order
-        # to not override standard behaviour
-        nlu_confidence = nlu_data.get("intent", {}).get("confidence", 1.0)
-        return (nlu_confidence < self.nlu_threshold, nlu_confidence)
-
-    def nlu_prediction_ambiguous(
-        self, nlu_data: Dict[Text, Any]
-    ) -> Tuple[bool, Optional[float]]:
-        """Check if top 2 confidences are closer than ``ambiguity_threshold``."""
-        intents = nlu_data.get("intent_ranking", [])
-        if len(intents) >= 2:
-            first_confidence = intents[0].get("confidence", 1.0)
-            second_confidence = intents[1].get("confidence", 1.0)
-            difference = first_confidence - second_confidence
-            return (difference < self.ambiguity_threshold, difference)
-        return (False, None)
-
-    def should_nlu_fallback(
-        self, nlu_data: Dict[Text, Any], last_action_name: Text
-    ) -> bool:
-        """Check if fallback action should be predicted.
-
-        Checks for:
-        - predicted NLU confidence is lower than ``nlu_threshold``
-        - difference in top 2 NLU confidences lower than ``ambiguity_threshold``
-        - last action is action listen
-        """
-        if last_action_name != ACTION_LISTEN_NAME:
-            return False
-
-        below_threshold, nlu_confidence = self.nlu_confidence_below_threshold(nlu_data)
-        ambiguous_prediction, confidence_delta = self.nlu_prediction_ambiguous(nlu_data)
-
-        if below_threshold:
-            logger.debug(
-                "NLU confidence {} is lower "
-                "than NLU threshold {:.2f}. "
-                "".format(nlu_confidence, self.nlu_threshold)
-            )
-            return True
-        elif ambiguous_prediction:
-            logger.debug(
-                "The difference in NLU confidences "
-                "for the top two intents ({}) is lower than "
-                "the ambiguity threshold {:.2f}. "
-                "".format(confidence_delta, self.ambiguity_threshold)
-            )
-            return True
-
-        return False
-
-    def fallback_scores(
-        self, domain: Domain, fallback_score: float = 1.0
-    ) -> List[float]:
-        """Prediction scores used if a fallback is necessary."""
-
-        result = self._default_predictions(domain)
-        idx = domain.index_for_action(self.fallback_action_name)
-        result[idx] = fallback_score
-        return result
-
-    def predict_action_probabilities(
-        self,
-        tracker: DialogueStateTracker,
-        domain: Domain,
-        interpreter: NaturalLanguageInterpreter,
-        **kwargs: Any,
-    ) -> PolicyPrediction:
-        """Predicts a fallback action.
-
-        The fallback action is predicted if the NLU confidence is low
-        or no other policy has a high-confidence prediction.
-        """
-        nlu_data = tracker.latest_message.parse_data
-
-        if (
-            tracker.latest_action_name == self.fallback_action_name
-            and tracker.latest_action_name != ACTION_LISTEN_NAME
-        ):
-            logger.debug(
-                "Predicted 'action_listen' after fallback action '{}'".format(
-                    self.fallback_action_name
-                )
-            )
-            result = self._default_predictions(domain)
-            idx = domain.index_for_action(ACTION_LISTEN_NAME)
-            result[idx] = 1.0
-
-        elif self.should_nlu_fallback(nlu_data, tracker.latest_action_name):
-            result = self.fallback_scores(domain)
-
-        else:
-            # NLU confidence threshold is met, so
-            # predict fallback action with confidence `core_threshold`
-            # if this is the highest confidence in the ensemble,
-            # the fallback action will be executed.
-            logger.debug(
-                "NLU confidence threshold met, confidence of "
-                "fallback action set to core threshold ({}).".format(
-                    self.core_threshold
-                )
-            )
-            result = self.fallback_scores(domain, self.core_threshold)
-
-        return self._prediction(result)
-
-    def _metadata(self) -> Dict[Text, Any]:
-        return {
-            "priority": self.priority,
-            "nlu_threshold": self.nlu_threshold,
-            "ambiguity_threshold": self.ambiguity_threshold,
-            "core_threshold": self.core_threshold,
-            "fallback_action_name": self.fallback_action_name,
-        }
-
-    @classmethod
-    def _metadata_filename(cls) -> Text:
-        return "fallback_policy.json"
diff --git a/rasa/core/policies/form_policy.py b/rasa/core/policies/form_policy.py
deleted file mode 100644
index 817f4500f197..000000000000
--- a/rasa/core/policies/form_policy.py
+++ /dev/null
@@ -1,175 +0,0 @@
-import logging
-from typing import List, Dict, Text, Optional, Any
-
-import rasa.shared.utils.common
-import rasa.shared.utils.io
-from rasa.core.policies.policy import PolicyPrediction
-from rasa.shared.constants import DOCS_URL_MIGRATION_GUIDE
-from rasa.shared.core.constants import (
-    ACTION_LISTEN_NAME,
-    LOOP_NAME,
-    PREVIOUS_ACTION,
-    ACTIVE_LOOP,
-    LOOP_REJECTED,
-)
-from rasa.shared.core.domain import State, Domain, SubStateValue
-from rasa.shared.core.events import LoopInterrupted
-from rasa.core.featurizers.tracker_featurizers import TrackerFeaturizer
-from rasa.shared.nlu.interpreter import NaturalLanguageInterpreter
-from rasa.core.policies.memoization import MemoizationPolicy
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.core.constants import FORM_POLICY_PRIORITY
-from rasa.shared.nlu.constants import ACTION_NAME
-
-
-logger = logging.getLogger(__name__)
-
-
-class FormPolicy(MemoizationPolicy):
-    """Policy which handles prediction of Forms"""
-
-    ENABLE_FEATURE_STRING_COMPRESSION = True
-
-    def __init__(
-        self,
-        featurizer: Optional[TrackerFeaturizer] = None,
-        priority: int = FORM_POLICY_PRIORITY,
-        lookup: Optional[Dict] = None,
-        **kwargs: Any,
-    ) -> None:
-
-        # max history is set to 2 in order to capture
-        # previous meaningful action before action listen
-        super().__init__(
-            featurizer=featurizer,
-            priority=priority,
-            max_history=2,
-            lookup=lookup,
-            **kwargs,
-        )
-
-        rasa.shared.utils.io.raise_deprecation_warning(
-            f"'{FormPolicy.__name__}' is deprecated and will be removed in "
-            "in the future. It is recommended to use the 'RulePolicy' instead.",
-            docs=DOCS_URL_MIGRATION_GUIDE,
-        )
-
-    @staticmethod
-    def _get_active_form_name(state: State,) -> Optional[SubStateValue]:
-        return state.get(ACTIVE_LOOP, {}).get(LOOP_NAME)
-
-    @staticmethod
-    def _prev_action_listen_in_state(state: State) -> bool:
-        prev_action_name = state.get(PREVIOUS_ACTION, {}).get(ACTION_NAME)
-        return prev_action_name == ACTION_LISTEN_NAME
-
-    @staticmethod
-    def _modified_states(states: List[State]) -> List[State]:
-        """Modifies the states to create feature keys for form unhappy path conditions.
-
-        Args:
-            states: a representation of a tracker
-                as a list of dictionaries containing features
-
-        Returns:
-            modified states
-        """
-        if len(states) == 1 or states[0] == {}:
-            action_before_listen = {}
-        else:
-            action_before_listen = {PREVIOUS_ACTION: states[0][PREVIOUS_ACTION]}
-
-        return [action_before_listen, states[-1]]
-
-    def _create_lookup_from_states(
-        self,
-        trackers_as_states: List[List[State]],
-        trackers_as_actions: List[List[Text]],
-    ) -> Dict[Text, SubStateValue]:
-        """Add states to lookup dict."""
-        lookup = {}
-        for states in trackers_as_states:
-            active_form = self._get_active_form_name(states[-1])
-            if active_form and self._prev_action_listen_in_state(states[-1]):
-                # modify the states
-                states = self._modified_states(states)
-                feature_key = self._create_feature_key(states)
-                # even if there are two identical feature keys
-                # their form will be the same
-                # because of `active_form_...` feature
-                lookup[feature_key] = active_form
-        return lookup
-
-    def recall(
-        self, states: List[State], tracker: DialogueStateTracker, domain: Domain,
-    ) -> Optional[Text]:
-        """Finds the action based on the given states.
-
-        Args:
-            states: List of states.
-            tracker: The tracker.
-            domain: The Domain.
-
-        Returns:
-            The name of the action.
-        """
-        # modify the states
-        return self._recall_states(self._modified_states(states))
-
-    def state_is_unhappy(self, tracker: DialogueStateTracker, domain: Domain) -> bool:
-        # since it is assumed that training stories contain
-        # only unhappy paths, notify the form that
-        # it should not be validated if predicted by other policy
-        states = self._prediction_states(tracker, domain)
-
-        memorized_form = self.recall(states, tracker, domain)
-
-        state_is_unhappy = (
-            memorized_form is not None and memorized_form == tracker.active_loop_name
-        )
-
-        if state_is_unhappy:
-            logger.debug(
-                "There is a memorized tracker state {}, "
-                "added `FormValidation(False)` event"
-                "".format(self._modified_states(states))
-            )
-
-        return state_is_unhappy
-
-    def predict_action_probabilities(
-        self,
-        tracker: DialogueStateTracker,
-        domain: Domain,
-        interpreter: NaturalLanguageInterpreter,
-        **kwargs: Any,
-    ) -> PolicyPrediction:
-        """Predicts the corresponding form action if there is an active form."""
-        result = self._default_predictions(domain)
-
-        if tracker.active_loop_name:
-            logger.debug(
-                "There is an active form '{}'".format(tracker.active_loop_name)
-            )
-            if tracker.latest_action_name == ACTION_LISTEN_NAME:
-                # predict form action after user utterance
-
-                if tracker.active_loop.get(LOOP_REJECTED):
-                    if self.state_is_unhappy(tracker, domain):
-                        return self._prediction(result, events=[LoopInterrupted(True)])
-
-                result = self._prediction_result(
-                    tracker.active_loop_name, tracker, domain
-                )
-
-            elif tracker.latest_action_name == tracker.active_loop_name:
-                # predict action_listen after form action
-                result = self._prediction_result(ACTION_LISTEN_NAME, tracker, domain)
-
-        else:
-            logger.debug("There is no active form")
-
-        return self._prediction(result)
-
-    def _metadata(self) -> Dict[Text, Any]:
-        return {"priority": self.priority, "lookup": self.lookup}
diff --git a/rasa/core/policies/mapping_policy.py b/rasa/core/policies/mapping_policy.py
deleted file mode 100644
index 84ed0ff08f0d..000000000000
--- a/rasa/core/policies/mapping_policy.py
+++ /dev/null
@@ -1,176 +0,0 @@
-import logging
-from typing import Any, List, Text, Optional, Dict, TYPE_CHECKING
-
-import rasa.shared.utils.common
-import rasa.utils.io
-import rasa.shared.utils.io
-from rasa.shared.constants import DOCS_URL_POLICIES, DOCS_URL_MIGRATION_GUIDE
-from rasa.shared.nlu.constants import INTENT_NAME_KEY
-from rasa.shared.core.constants import (
-    USER_INTENT_BACK,
-    USER_INTENT_RESTART,
-    USER_INTENT_SESSION_START,
-    ACTION_LISTEN_NAME,
-    ACTION_RESTART_NAME,
-    ACTION_SESSION_START_NAME,
-    ACTION_BACK_NAME,
-)
-from rasa.shared.core.domain import InvalidDomain, Domain
-from rasa.shared.core.events import ActionExecuted
-from rasa.shared.nlu.interpreter import NaturalLanguageInterpreter
-from rasa.core.policies.policy import Policy, PolicyPrediction
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.core.generator import TrackerWithCachedStates
-from rasa.core.constants import MAPPING_POLICY_PRIORITY
-
-if TYPE_CHECKING:
-    from rasa.core.policies.ensemble import PolicyEnsemble
-
-
-logger = logging.getLogger(__name__)
-
-
-class MappingPolicy(Policy):
-    """Policy which maps intents directly to actions.
-
-    Intents can be assigned actions in the domain file which are to be
-    executed whenever the intent is detected. This policy takes precedence over
-    any other policy.
-    """
-
-    @staticmethod
-    def _standard_featurizer() -> None:
-        return None
-
-    def __init__(self, priority: int = MAPPING_POLICY_PRIORITY, **kwargs: Any) -> None:
-        """Create a new Mapping policy."""
-        super().__init__(priority=priority, **kwargs)
-
-        rasa.shared.utils.io.raise_deprecation_warning(
-            f"'{MappingPolicy.__name__}' is deprecated and will be removed in "
-            "the future. It is recommended to use the 'RulePolicy' instead.",
-            docs=DOCS_URL_MIGRATION_GUIDE,
-        )
-
-    @classmethod
-    def validate_against_domain(
-        cls, ensemble: Optional["PolicyEnsemble"], domain: Optional[Domain]
-    ) -> None:
-        if not domain:
-            return
-
-        has_mapping_policy = ensemble is not None and any(
-            isinstance(p, cls) for p in ensemble.policies
-        )
-        has_triggers_in_domain = any(
-            [
-                "triggers" in properties
-                for intent, properties in domain.intent_properties.items()
-            ]
-        )
-        if has_triggers_in_domain and not has_mapping_policy:
-            raise InvalidDomain(
-                "You have defined triggers in your domain, but haven't "
-                "added the MappingPolicy to your policy ensemble. "
-                "Either remove the triggers from your domain or "
-                "include the MappingPolicy in your policy configuration."
-            )
-
-    def train(
-        self,
-        training_trackers: List[TrackerWithCachedStates],
-        domain: Domain,
-        interpreter: NaturalLanguageInterpreter,
-        **kwargs: Any,
-    ) -> None:
-        """Does nothing. This policy is deterministic."""
-
-        pass
-
-    def predict_action_probabilities(
-        self,
-        tracker: DialogueStateTracker,
-        domain: Domain,
-        interpreter: NaturalLanguageInterpreter,
-        **kwargs: Any,
-    ) -> PolicyPrediction:
-        """Predicts the assigned action.
-
-        If the current intent is assigned to an action that action will be
-        predicted with the highest probability of all policies. If it is not
-        the policy will predict zero for every action.
-        """
-        result = self._default_predictions(domain)
-
-        intent = tracker.latest_message.intent.get(INTENT_NAME_KEY)
-        if intent == USER_INTENT_RESTART:
-            action = ACTION_RESTART_NAME
-        elif intent == USER_INTENT_BACK:
-            action = ACTION_BACK_NAME
-        elif intent == USER_INTENT_SESSION_START:
-            action = ACTION_SESSION_START_NAME
-        else:
-            action = domain.intent_properties.get(intent, {}).get("triggers")
-
-        if tracker.latest_action_name == ACTION_LISTEN_NAME:
-            # predict mapped action
-            if action:
-                idx = domain.index_for_action(action)
-                if idx is None:
-                    rasa.shared.utils.io.raise_warning(
-                        f"MappingPolicy tried to predict unknown "
-                        f"action '{action}'. Make sure all mapped actions are "
-                        f"listed in the domain.",
-                        docs=DOCS_URL_POLICIES + "#mapping-policy",
-                    )
-                else:
-                    result[idx] = 1
-
-            if any(result):
-                logger.debug(
-                    "The predicted intent '{}' is mapped to "
-                    " action '{}' in the domain."
-                    "".format(intent, action)
-                )
-        elif tracker.latest_action_name == action and action is not None:
-            # predict next action_listen after mapped action
-            latest_action = tracker.get_last_event_for(ActionExecuted)
-            assert latest_action.action_name == action
-            if latest_action.policy and latest_action.policy.endswith(
-                type(self).__name__
-            ):
-                # this ensures that we only predict listen,
-                # if we predicted the mapped action
-                logger.debug(
-                    "The mapped action, '{}', for this intent, '{}', was "
-                    "executed last so MappingPolicy is returning to "
-                    "action_listen.".format(action, intent)
-                )
-
-                idx = domain.index_for_action(ACTION_LISTEN_NAME)
-                result[idx] = 1
-            else:
-                logger.debug(
-                    "The mapped action, '{}', for the intent, '{}', was "
-                    "executed last, but it was predicted by another policy, '{}', "
-                    "so MappingPolicy is not predicting any action.".format(
-                        action, intent, latest_action.policy
-                    )
-                )
-        elif action == ACTION_RESTART_NAME:
-            logger.debug("Restarting the conversation with action_restart.")
-            idx = domain.index_for_action(ACTION_RESTART_NAME)
-            result[idx] = 1
-        else:
-            logger.debug(
-                "There is no mapped action for the predicted intent, "
-                "'{}'.".format(intent)
-            )
-        return self._prediction(result)
-
-    def _metadata(self) -> Dict[Text, Any]:
-        return {"priority": self.priority}
-
-    @classmethod
-    def _metadata_filename(cls) -> Text:
-        return "mapping_policy.json"
diff --git a/rasa/core/policies/memoization.py b/rasa/core/policies/memoization.py
index 0e4b1703ce59..155b5981516b 100644
--- a/rasa/core/policies/memoization.py
+++ b/rasa/core/policies/memoization.py
@@ -9,7 +9,6 @@
 
 import rasa.utils.io
 import rasa.shared.utils.io
-from rasa.shared.constants import DOCS_URL_POLICIES
 from rasa.shared.core.domain import State, Domain
 from rasa.shared.core.events import ActionExecuted
 from rasa.core.featurizers.tracker_featurizers import (
@@ -21,18 +20,13 @@
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.utils.io import is_logging_disabled
-from rasa.core.constants import MEMOIZATION_POLICY_PRIORITY
+from rasa.core.constants import MEMOIZATION_POLICY_PRIORITY, DEFAULT_MAX_HISTORY
 
 logger = logging.getLogger(__name__)
 
-# temporary constants to support back compatibility
-MAX_HISTORY_NOT_SET = -1
-OLD_DEFAULT_MAX_HISTORY = 5
-
 
 class MemoizationPolicy(Policy):
-    """The policy that remembers exact examples of
-    `max_history` turns from training stories.
+    """A policy that follows exact examples of `max_history` turns in training stories.
 
     Since `slots` that are set some time in the past are
     preserved in all future feature vectors until they are set
@@ -69,7 +63,7 @@ def __init__(
         self,
         featurizer: Optional[TrackerFeaturizer] = None,
         priority: int = MEMOIZATION_POLICY_PRIORITY,
-        max_history: Optional[int] = MAX_HISTORY_NOT_SET,
+        max_history: Optional[int] = DEFAULT_MAX_HISTORY,
         lookup: Optional[Dict] = None,
         **kwargs: Any,
     ) -> None:
@@ -82,18 +76,6 @@ def __init__(
             lookup: a dictionary that stores featurized tracker states and
                 predicted actions for them
         """
-        if max_history == MAX_HISTORY_NOT_SET:
-            max_history = OLD_DEFAULT_MAX_HISTORY  # old default value
-            rasa.shared.utils.io.raise_warning(
-                f"Please configure the max history in your configuration file, "
-                f"currently 'max_history' is set to old default value of "
-                f"'{max_history}'. If you want to have infinite max history "
-                f"set it to 'None' explicitly. We will change the default value of "
-                f"'max_history' in the future to 'None'.",
-                DeprecationWarning,
-                docs=DOCS_URL_POLICIES,
-            )
-
         if not featurizer:
             featurizer = self._standard_featurizer(max_history)
 
diff --git a/rasa/core/policies/registry.py b/rasa/core/policies/registry.py
index f9c776612f0f..71be8198d2d4 100644
--- a/rasa/core/policies/registry.py
+++ b/rasa/core/policies/registry.py
@@ -3,21 +3,11 @@
 
 from rasa.core.policies.ted_policy import TEDPolicy  # noqa: F401
 
-from rasa.core.policies.fallback import FallbackPolicy  # noqa: F401
-
 from rasa.core.policies.memoization import (  # noqa: F401
     MemoizationPolicy,
     AugmentedMemoizationPolicy,
 )
 
-from rasa.core.policies.sklearn_policy import SklearnPolicy  # noqa: F401
-
-from rasa.core.policies.form_policy import FormPolicy  # noqa: F401
-
-from rasa.core.policies.two_stage_fallback import TwoStageFallbackPolicy  # noqa: F401
-
-from rasa.core.policies.mapping_policy import MappingPolicy  # noqa: F401
-
 from rasa.core.policies.rule_policy import RulePolicy  # noqa: F401
 
 from rasa.core.policies.unexpected_intent_policy import (  # noqa: F401
diff --git a/rasa/core/policies/sklearn_policy.py b/rasa/core/policies/sklearn_policy.py
deleted file mode 100644
index cf110177e441..000000000000
--- a/rasa/core/policies/sklearn_policy.py
+++ /dev/null
@@ -1,374 +0,0 @@
-import json
-import logging
-import typing
-import scipy.sparse
-import numpy as np
-from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Text, Tuple, Union
-from collections import defaultdict, OrderedDict
-
-from sklearn.base import clone
-from sklearn.linear_model import LogisticRegression
-from sklearn.model_selection import GridSearchCV
-from sklearn.preprocessing import LabelEncoder
-
-import rasa.shared.utils.io
-import rasa.utils.io as io_utils
-import rasa.utils.tensorflow.model_data_utils as model_data_utils
-from rasa.core.constants import DEFAULT_POLICY_PRIORITY
-from rasa.shared.core.domain import Domain
-from rasa.core.featurizers.single_state_featurizer import SingleStateFeaturizer
-from rasa.core.featurizers.tracker_featurizers import (
-    MaxHistoryTrackerFeaturizer,
-    TrackerFeaturizer,
-)
-from rasa.shared.nlu.interpreter import NaturalLanguageInterpreter
-from rasa.core.policies.policy import Policy, PolicyPrediction
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.core.generator import TrackerWithCachedStates
-from rasa.shared.nlu.constants import ACTION_TEXT, TEXT
-from rasa.shared.nlu.training_data.features import Features
-from rasa.utils.tensorflow.model_data import Data, FeatureArray
-from rasa.utils.tensorflow.constants import SENTENCE
-
-# noinspection PyProtectedMember
-from sklearn.utils import shuffle as sklearn_shuffle
-
-logger = logging.getLogger(__name__)
-
-if typing.TYPE_CHECKING:
-    import sklearn
-
-
-class SklearnPolicy(Policy):
-    """Use an sklearn classifier to train a policy."""
-
-    DEFAULT_MAX_HISTORY = 5
-
-    @staticmethod
-    def _standard_featurizer(
-        max_history: int = DEFAULT_MAX_HISTORY,
-    ) -> MaxHistoryTrackerFeaturizer:
-        # Sklearn policy always uses MaxHistoryTrackerFeaturizer
-        return MaxHistoryTrackerFeaturizer(
-            state_featurizer=SingleStateFeaturizer(), max_history=5
-        )
-
-    def __init__(
-        self,
-        featurizer: Optional[MaxHistoryTrackerFeaturizer] = None,
-        priority: int = DEFAULT_POLICY_PRIORITY,
-        max_history: int = DEFAULT_MAX_HISTORY,
-        model: Optional["sklearn.base.BaseEstimator"] = None,
-        param_grid: Optional[Union[Dict[Text, List], List[Dict]]] = None,
-        cv: Optional[int] = None,
-        scoring: Optional[Union[Text, List, Dict, Callable]] = "accuracy",
-        label_encoder: LabelEncoder = LabelEncoder(),
-        shuffle: bool = True,
-        zero_state_features: Optional[Dict[Text, List["Features"]]] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Create a new sklearn policy.
-
-        Args:
-            featurizer: Featurizer used to convert the training data into
-                vector format.
-            priority: Policy priority
-            max_history: Maximum history of the dialogs.
-            model: The sklearn model or model pipeline.
-            param_grid: If *param_grid* is not None and *cv* is given,
-                a grid search on the given *param_grid* is performed
-                (e.g. *param_grid={'n_estimators': [50, 100]}*).
-            cv: If *cv* is not None, perform a cross validation on
-                the training data. *cv* should then conform to the
-                sklearn standard (e.g. *cv=5* for a 5-fold cross-validation).
-            scoring: Scoring strategy, using the sklearn standard.
-            label_encoder: Encoder for the labels. Must implement an
-                *inverse_transform* method.
-            shuffle: Whether to shuffle training data.
-            zero_state_features: Contains default feature values for attributes
-        """
-        if featurizer:
-            if not isinstance(featurizer, MaxHistoryTrackerFeaturizer):
-                raise TypeError(
-                    f"Passed featurizer of type '{type(featurizer).__name__}', "
-                    f"should be MaxHistoryTrackerFeaturizer."
-                )
-            if not featurizer.max_history:
-                raise ValueError(
-                    "Passed featurizer without `max_history`, `max_history` should be "
-                    "set to a positive integer value."
-                )
-        else:
-            if not max_history:
-                raise ValueError(
-                    "max_history should be set to a positive integer value."
-                )
-            featurizer = self._standard_featurizer(max_history)
-
-        super().__init__(featurizer, priority, **kwargs)
-
-        self.model = model or self._default_model()
-        self.cv = cv
-        self.param_grid = param_grid
-        self.scoring = scoring
-        self.label_encoder = label_encoder
-        self.shuffle = shuffle
-
-        # attributes that need to be restored after loading
-        self._pickle_params = ["model", "cv", "param_grid", "scoring", "label_encoder"]
-        self._train_params = kwargs
-        self.zero_state_features = zero_state_features or defaultdict(list)
-
-        rasa.shared.utils.io.raise_deprecation_warning(
-            f"'{SklearnPolicy.__name__}' is deprecated and will be removed in "
-            "the future. It is recommended to use the 'TEDPolicy' instead."
-        )
-
-    @staticmethod
-    def _default_model() -> Any:
-        return LogisticRegression(solver="liblinear", multi_class="auto")
-
-    @property
-    def _state(self) -> Dict[Text, Any]:
-        return {attr: getattr(self, attr) for attr in self._pickle_params}
-
-    def model_architecture(self, **kwargs: Any) -> Any:
-        """Sets model parameters for training."""
-        # filter out kwargs that cannot be passed to model
-        train_params = self._get_valid_params(self.model.__init__, **kwargs)
-        return self.model.set_params(**train_params)
-
-    @staticmethod
-    def _fill_in_features_to_max_length(
-        features: List[np.ndarray], max_history: int
-    ) -> List[np.ndarray]:
-        """
-        Pad features with zeros to maximum length;
-        Args:
-            features: list of features for each dialog;
-                each feature has shape [dialog_history x shape_attribute]
-            max_history: maximum history of the dialogs
-        Returns:
-            padded features
-        """
-        feature_shape = features[0].shape[-1]
-        features = [
-            feature
-            if feature.shape[0] == max_history
-            else np.vstack(
-                [np.zeros((max_history - feature.shape[0], feature_shape)), feature]
-            )
-            for feature in features
-        ]
-        return features
-
-    def _get_features_for_attribute(
-        self, attribute_data: Dict[Text, List[FeatureArray]]
-    ) -> np.ndarray:
-        """Given a list of all features for one attribute, turn it into a numpy array.
-
-        shape_attribute = features[SENTENCE][0][0].shape[-1]
-            (Shape of features of one attribute)
-
-        Args:
-            attribute_data: all features in the attribute stored in a FeatureArray
-
-        Returns:
-            2D np.ndarray with features for an attribute with
-                shape [num_dialogs x (max_history * shape_attribute)]
-        """
-        sentence_features = attribute_data[SENTENCE][0]
-
-        # vstack serves as removing dimension
-        if sentence_features.is_sparse:
-            sentence_features = [
-                scipy.sparse.vstack(value) for value in sentence_features
-            ]
-            sentence_features = [feature.toarray() for feature in sentence_features]
-        else:
-            sentence_features = [np.vstack(value) for value in sentence_features]
-
-        # MaxHistoryFeaturizer is always used with SkLearn policy;
-        max_history = self.featurizer.max_history
-        features = self._fill_in_features_to_max_length(sentence_features, max_history)
-        features = [feature.reshape((1, -1)) for feature in features]
-        return np.vstack(features)
-
-    def _preprocess_data(self, data: Data) -> np.ndarray:
-        """
-        Turn data into np.ndarray for sklearn training; dialogue history features
-        are flattened.
-        Args:
-            data: training data containing all the features
-        Returns:
-            Training_data: shape [num_dialogs x (max_history * all_features)];
-            all_features - sum of number of features of
-            intent, action_name, entities, forms, slots.
-        """
-        if TEXT in data or ACTION_TEXT in data:
-            raise Exception(
-                f"{self.__name__} cannot be applied to text data. "
-                f"Try to use TEDPolicy instead. "
-            )
-
-        attribute_data = {
-            attribute: self._get_features_for_attribute(attribute_data)
-            for attribute, attribute_data in data.items()
-        }
-        # turning it into OrderedDict so that the order of features is the same
-        attribute_data = OrderedDict(attribute_data)
-        return np.concatenate(list(attribute_data.values()), axis=-1)
-
-    def _search_and_score(
-        self,
-        model: Any,
-        X: np.ndarray,
-        y: np.ndarray,
-        param_grid: Union[Dict[Text, List], List[Dict]],
-    ) -> Tuple[Any, Any]:
-        search = GridSearchCV(
-            model, param_grid=param_grid, cv=self.cv, scoring="accuracy", verbose=1
-        )
-        search.fit(X, y)
-        print("Best params:", search.best_params_)
-        return search.best_estimator_, search.best_score_
-
-    def train(
-        self,
-        training_trackers: List[TrackerWithCachedStates],
-        domain: Domain,
-        interpreter: NaturalLanguageInterpreter,
-        **kwargs: Any,
-    ) -> None:
-        tracker_state_features, label_ids, _ = self._featurize_for_training(
-            training_trackers, domain, interpreter, **kwargs
-        )
-        training_data, zero_state_features = model_data_utils.convert_to_data_format(
-            tracker_state_features
-        )
-        self.zero_state_features = zero_state_features
-
-        self._train_params.update(kwargs)
-        model = self.model_architecture(**self._train_params)
-        score = None
-        # Note: clone is called throughout to avoid mutating default arguments.
-        self.label_encoder = clone(self.label_encoder).fit(label_ids)
-        X = self._preprocess_data(training_data)
-        y = self.label_encoder.transform(label_ids)
-
-        if self.shuffle:
-            X, y = sklearn_shuffle(X, y)
-
-        if self.cv is None:
-            model = clone(model).fit(X, y)
-        else:
-            param_grid = self.param_grid or {}
-            model, score = self._search_and_score(model, X, y, param_grid)
-
-        self.model = model
-        logger.info("Done fitting sklearn policy model")
-        if score is not None:
-            logger.info(f"Cross validation score: {score:.5f}")
-
-    def _postprocess_prediction(
-        self, y_proba: np.ndarray, domain: Domain
-    ) -> List[float]:
-        yp = y_proba[0].tolist()
-
-        # Some classes might not be part of the training labels. Since
-        # sklearn does not predict labels it has never encountered
-        # during training, it is necessary to insert missing classes.
-        indices = self.label_encoder.inverse_transform(np.arange(len(yp)))
-        y_filled = [0.0 for _ in range(domain.num_actions)]
-        for i, pred in zip(indices, yp):
-            y_filled[i] = pred
-
-        return y_filled
-
-    def predict_action_probabilities(
-        self,
-        tracker: DialogueStateTracker,
-        domain: Domain,
-        interpreter: NaturalLanguageInterpreter,
-        **kwargs: Any,
-    ) -> PolicyPrediction:
-        """Predicts the next action the bot should take after seeing the tracker.
-
-        Args:
-            tracker: the :class:`rasa.core.trackers.DialogueStateTracker`
-            domain: the :class:`rasa.shared.core.domain.Domain`
-            interpreter: Interpreter which may be used by the policies to create
-                additional features.
-
-        Returns:
-             The policy's prediction (e.g. the probabilities for the actions).
-        """
-        X = self._featurize_for_prediction(tracker, domain, interpreter)
-        training_data, _ = model_data_utils.convert_to_data_format(
-            X, self.zero_state_features
-        )
-        Xt = self._preprocess_data(training_data)
-        y_proba = self.model.predict_proba(Xt)
-        return self._prediction(self._postprocess_prediction(y_proba, domain))
-
-    def persist(self, path: Union[Text, Path]) -> None:
-        """Persists the policy properties (see parent class for more information)."""
-        if self.model:
-            self.featurizer.persist(path)
-
-            meta = {"priority": self.priority}
-            path = Path(path)
-
-            meta_file = path / "sklearn_policy.json"
-            rasa.shared.utils.io.dump_obj_as_json_to_file(meta_file, meta)
-
-            filename = path / "sklearn_model.pkl"
-            rasa.utils.io.pickle_dump(filename, self._state)
-
-            zero_features_filename = path / "zero_state_features.pkl"
-            io_utils.pickle_dump(zero_features_filename, self.zero_state_features)
-
-        else:
-            rasa.shared.utils.io.raise_warning(
-                "Persist called without a trained model present. "
-                "Nothing to persist then!"
-            )
-
-    @classmethod
-    def load(
-        cls, path: Union[Text, Path], should_finetune: bool = False, **kwargs: Any
-    ) -> Policy:
-        """See the docstring for `Policy.load`."""
-        filename = Path(path) / "sklearn_model.pkl"
-        zero_features_filename = Path(path) / "zero_state_features.pkl"
-        if not Path(path).exists():
-            logger.error(
-                f"Failed to load dialogue model. Path {filename.absolute()} "
-                f"doesn't exist."
-            )
-            return cls()
-
-        featurizer = TrackerFeaturizer.load(path)
-        assert isinstance(featurizer, MaxHistoryTrackerFeaturizer), (
-            f"Loaded featurizer of type {type(featurizer).__name__}, should be "
-            f"MaxHistoryTrackerFeaturizer."
-        )
-
-        meta_file = Path(path) / "sklearn_policy.json"
-        meta = json.loads(rasa.shared.utils.io.read_file(meta_file))
-        zero_state_features = io_utils.pickle_load(zero_features_filename)
-
-        policy = cls(
-            featurizer=featurizer,
-            priority=meta["priority"],
-            zero_state_features=zero_state_features,
-            should_finetune=should_finetune,
-        )
-
-        state = io_utils.pickle_load(filename)
-
-        vars(policy).update(state)
-
-        logger.info("Loaded sklearn model")
-        return policy
diff --git a/rasa/core/policies/two_stage_fallback.py b/rasa/core/policies/two_stage_fallback.py
deleted file mode 100644
index 2685ae215529..000000000000
--- a/rasa/core/policies/two_stage_fallback.py
+++ /dev/null
@@ -1,232 +0,0 @@
-import logging
-from typing import List, Text, Optional, Any, TYPE_CHECKING, Dict
-
-from rasa.shared.core.events import UserUttered, ActionExecuted
-
-from rasa.shared.nlu.interpreter import NaturalLanguageInterpreter
-from rasa.core.policies.fallback import FallbackPolicy
-from rasa.core.policies.policy import confidence_scores_for, PolicyPrediction
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.core.constants import (
-    FALLBACK_POLICY_PRIORITY,
-    DEFAULT_NLU_FALLBACK_THRESHOLD,
-    DEFAULT_CORE_FALLBACK_THRESHOLD,
-    DEFAULT_NLU_FALLBACK_AMBIGUITY_THRESHOLD,
-)
-from rasa.shared.core.constants import (
-    USER_INTENT_OUT_OF_SCOPE,
-    ACTION_LISTEN_NAME,
-    ACTION_DEFAULT_FALLBACK_NAME,
-    ACTION_REVERT_FALLBACK_EVENTS_NAME,
-    ACTION_DEFAULT_ASK_AFFIRMATION_NAME,
-    ACTION_DEFAULT_ASK_REPHRASE_NAME,
-)
-from rasa.shared.core.domain import InvalidDomain, Domain
-from rasa.shared.nlu.constants import ACTION_NAME, INTENT_NAME_KEY, INTENT
-
-if TYPE_CHECKING:
-    from rasa.core.policies.ensemble import PolicyEnsemble
-
-
-logger = logging.getLogger(__name__)
-
-
-def has_user_rephrased(tracker: DialogueStateTracker) -> bool:
-    return tracker.last_executed_action_has(ACTION_DEFAULT_ASK_REPHRASE_NAME)
-
-
-class TwoStageFallbackPolicy(FallbackPolicy):
-    """This policy handles low NLU confidence in multiple stages.
-
-    If a NLU prediction has a low confidence score,
-    the user is asked to affirm whether they really had this intent.
-    If they affirm, the story continues as if the intent was classified
-    with high confidence from the beginning.
-    If they deny, the user is asked to rephrase his intent.
-    If the classification for the rephrased intent was confident, the story
-    continues as if the user had this intent from the beginning.
-    If the rephrased intent was not classified with high confidence,
-    the user is asked to affirm the classified intent.
-    If the user affirm the intent, the story continues as if the user had
-    this intent from the beginning.
-    If the user denies, an ultimate fallback action is triggered
-    (e.g. a hand-off to a human).
-    """
-
-    def __init__(
-        self,
-        priority: int = FALLBACK_POLICY_PRIORITY,
-        nlu_threshold: float = DEFAULT_NLU_FALLBACK_THRESHOLD,
-        ambiguity_threshold: float = DEFAULT_NLU_FALLBACK_AMBIGUITY_THRESHOLD,
-        core_threshold: float = DEFAULT_CORE_FALLBACK_THRESHOLD,
-        fallback_core_action_name: Text = ACTION_DEFAULT_FALLBACK_NAME,
-        fallback_nlu_action_name: Text = ACTION_DEFAULT_FALLBACK_NAME,
-        deny_suggestion_intent_name: Text = USER_INTENT_OUT_OF_SCOPE,
-        **kwargs: Any,
-    ) -> None:
-        """Create a new Two-stage Fallback policy.
-
-        Args:
-            priority: The fallback policy priority.
-            nlu_threshold: minimum threshold for NLU confidence.
-                If intent prediction confidence is lower than this,
-                predict fallback action with confidence 1.0.
-            ambiguity_threshold: threshold for minimum difference
-                between confidences of the top two predictions
-            core_threshold: if NLU confidence threshold is met,
-                predict fallback action with confidence
-                `core_threshold`. If this is the highest confidence in
-                the ensemble, the fallback action will be executed.
-            fallback_core_action_name: This action is executed if the Core
-                threshold is not met.
-            fallback_nlu_action_name: This action is executed if the user
-                denies the recognised intent for the second time.
-            deny_suggestion_intent_name: The name of the intent which is used
-                 to detect that the user denies the suggested intents.
-        """
-        super().__init__(
-            priority,
-            nlu_threshold,
-            ambiguity_threshold,
-            core_threshold,
-            fallback_core_action_name,
-            **kwargs,
-        )
-
-        self.fallback_nlu_action_name = fallback_nlu_action_name
-        self.deny_suggestion_intent_name = deny_suggestion_intent_name
-
-    @classmethod
-    def validate_against_domain(
-        cls, ensemble: Optional["PolicyEnsemble"], domain: Optional[Domain]
-    ) -> None:
-        if ensemble is None:
-            return
-
-        for p in ensemble.policies:
-            if not isinstance(p, TwoStageFallbackPolicy):
-                continue
-            if domain is None or p.deny_suggestion_intent_name not in domain.intents:
-                raise InvalidDomain(
-                    "The intent '{0}' must be present in the "
-                    "domain file to use TwoStageFallbackPolicy. "
-                    "Either include the intent '{0}' in your domain "
-                    "or exclude the TwoStageFallbackPolicy from your "
-                    "policy configuration".format(p.deny_suggestion_intent_name)
-                )
-
-    def predict_action_probabilities(
-        self,
-        tracker: DialogueStateTracker,
-        domain: Domain,
-        interpreter: NaturalLanguageInterpreter,
-        **kwargs: Any,
-    ) -> PolicyPrediction:
-        """Predicts the next action if NLU confidence is low."""
-        nlu_data = tracker.latest_message.parse_data
-        last_intent_name = nlu_data[INTENT].get(INTENT_NAME_KEY, None)
-        should_nlu_fallback = self.should_nlu_fallback(
-            nlu_data, tracker.latest_action.get(ACTION_NAME)
-        )
-        user_rephrased = has_user_rephrased(tracker)
-
-        if self._is_user_input_expected(tracker):
-            result = confidence_scores_for(ACTION_LISTEN_NAME, 1.0, domain)
-        elif self._has_user_denied(last_intent_name, tracker):
-            logger.debug(f"User '{tracker.sender_id}' denied suggested intents.")
-            result = self._results_for_user_denied(tracker, domain)
-        elif user_rephrased and should_nlu_fallback:
-            logger.debug(
-                "Ambiguous rephrasing of user '{}' "
-                "for intent '{}'".format(tracker.sender_id, last_intent_name)
-            )
-            result = confidence_scores_for(
-                ACTION_DEFAULT_ASK_AFFIRMATION_NAME, 1.0, domain
-            )
-        elif user_rephrased:
-            logger.debug(f"User '{tracker.sender_id}' rephrased intent")
-            result = confidence_scores_for(
-                ACTION_REVERT_FALLBACK_EVENTS_NAME, 1.0, domain
-            )
-        elif tracker.last_executed_action_has(ACTION_DEFAULT_ASK_AFFIRMATION_NAME):
-            if not should_nlu_fallback:
-                logger.debug(
-                    "User '{}' affirmed intent '{}'"
-                    "".format(tracker.sender_id, last_intent_name)
-                )
-                result = confidence_scores_for(
-                    ACTION_REVERT_FALLBACK_EVENTS_NAME, 1.0, domain
-                )
-            else:
-                result = confidence_scores_for(
-                    self.fallback_nlu_action_name, 1.0, domain
-                )
-        elif should_nlu_fallback:
-            logger.debug(
-                "User '{}' has to affirm intent '{}'.".format(
-                    tracker.sender_id, last_intent_name
-                )
-            )
-            result = confidence_scores_for(
-                ACTION_DEFAULT_ASK_AFFIRMATION_NAME, 1.0, domain
-            )
-        else:
-            logger.debug(
-                "NLU confidence threshold met, confidence of "
-                "fallback action set to core threshold ({}).".format(
-                    self.core_threshold
-                )
-            )
-            result = self.fallback_scores(domain, self.core_threshold)
-
-        return self._prediction(result)
-
-    def _is_user_input_expected(self, tracker: DialogueStateTracker) -> bool:
-        action_requires_input = tracker.latest_action.get(ACTION_NAME) in [
-            ACTION_DEFAULT_ASK_AFFIRMATION_NAME,
-            ACTION_DEFAULT_ASK_REPHRASE_NAME,
-            self.fallback_action_name,
-        ]
-        try:
-            last_utterance_time = tracker.get_last_event_for(UserUttered).timestamp
-            last_action_time = tracker.get_last_event_for(ActionExecuted).timestamp
-            input_given = last_action_time < last_utterance_time
-        except AttributeError:
-            input_given = False
-
-        return action_requires_input and not input_given
-
-    def _has_user_denied(
-        self, last_intent: Text, tracker: DialogueStateTracker
-    ) -> bool:
-        return (
-            tracker.last_executed_action_has(ACTION_DEFAULT_ASK_AFFIRMATION_NAME)
-            and last_intent == self.deny_suggestion_intent_name
-        )
-
-    def _results_for_user_denied(
-        self, tracker: DialogueStateTracker, domain: Domain
-    ) -> List[float]:
-        has_denied_before = tracker.last_executed_action_has(
-            ACTION_DEFAULT_ASK_REPHRASE_NAME, skip=1
-        )
-
-        if has_denied_before:
-            return confidence_scores_for(self.fallback_nlu_action_name, 1.0, domain)
-        else:
-            return confidence_scores_for(ACTION_DEFAULT_ASK_REPHRASE_NAME, 1.0, domain)
-
-    def _metadata(self) -> Dict[Text, Any]:
-        return {
-            "priority": self.priority,
-            "nlu_threshold": self.nlu_threshold,
-            "ambiguity_threshold": self.ambiguity_threshold,
-            "core_threshold": self.core_threshold,
-            "fallback_core_action_name": self.fallback_action_name,
-            "fallback_nlu_action_name": self.fallback_nlu_action_name,
-            "deny_suggestion_intent_name": self.deny_suggestion_intent_name,
-        }
-
-    @classmethod
-    def _metadata_filename(cls) -> Text:
-        return "two_stage_fallback_policy.json"
diff --git a/rasa/core/test.py b/rasa/core/test.py
index 0981c9fd27a3..42e7ae094369 100644
--- a/rasa/core/test.py
+++ b/rasa/core/test.py
@@ -639,7 +639,6 @@ def _collect_action_executed_predictions(
     fail_on_prediction_errors: bool,
     circuit_breaker_tripped: bool,
 ) -> Tuple[EvaluationStore, PolicyPrediction, Optional[EntityEvaluationResult]]:
-    from rasa.core.policies.form_policy import FormPolicy
 
     action_executed_eval_store = EvaluationStore()
 
@@ -702,14 +701,6 @@ def _collect_action_executed_predictions(
             error_msg = (
                 f"Model predicted a wrong action. Failed Story: " f"\n\n{story_dump}"
             )
-            if FormPolicy.__name__ in prediction.policy_name:
-                error_msg += (
-                    "FormAction is not run during "
-                    "evaluation therefore it is impossible to know "
-                    "if validation failed or this story is wrong. "
-                    "If the story is correct, add it to the "
-                    "training stories and retrain."
-                )
             raise WrongPredictionException(error_msg)
     elif prev_action_unlikely_intent:
         partial_tracker.update(
diff --git a/tests/core/test_agent.py b/tests/core/test_agent.py
index aafbc7d4e834..4955244435ab 100644
--- a/tests/core/test_agent.py
+++ b/tests/core/test_agent.py
@@ -14,7 +14,6 @@
 import rasa.core
 from rasa.exceptions import ModelNotFound
 import rasa.shared.utils.common
-from rasa.core.policies.form_policy import FormPolicy
 from rasa.core.policies.rule_policy import RulePolicy
 import rasa.utils.io
 from rasa.core import jobs
@@ -237,17 +236,11 @@ def test_form_without_form_policy(policy_config: Dict[Text, List[Text]]):
             domain=Domain.from_dict({"forms": {"restaurant_form": {}}}),
             policies=PolicyEnsemble.from_dict(policy_config),
         )
-    assert "neither added the 'RulePolicy' nor the 'FormPolicy'" in str(execinfo.value)
+    assert "have not added the 'RulePolicy'" in str(execinfo.value)
 
 
-@pytest.mark.parametrize(
-    "policy_config",
-    [
-        {"policies": [{"name": FormPolicy.__name__}]},
-        {"policies": [{"name": RulePolicy.__name__}]},
-    ],
-)
-def test_forms_with_suited_policy(policy_config: Dict[Text, List[Text]]):
+def test_forms_with_suited_policy():
+    policy_config = {"policies": [{"name": RulePolicy.__name__}]}
     # Doesn't raise
     Agent(
         domain=Domain.from_dict({"forms": {"restaurant_form": {}}}),
@@ -255,56 +248,6 @@ def test_forms_with_suited_policy(policy_config: Dict[Text, List[Text]]):
     )
 
 
-@pytest.mark.parametrize(
-    "domain, policy_config",
-    [
-        (
-            {
-                "intents": [{"affirm": {"triggers": "utter_ask_num_people"}}],
-                "actions": ["utter_ask_num_people"],
-            },
-            {"policies": [{"name": "MemoizationPolicy"}]},
-        )
-    ],
-)
-def test_trigger_without_mapping_policy(
-    domain: Dict[Text, Any], policy_config: Dict[Text, Any]
-):
-    with pytest.raises(InvalidDomain) as execinfo:
-        Agent(
-            domain=Domain.from_dict(domain),
-            policies=PolicyEnsemble.from_dict(policy_config),
-        )
-    assert "haven't added the MappingPolicy" in str(execinfo.value)
-
-
-@pytest.mark.parametrize(
-    "domain, policy_config",
-    [
-        (
-            {"intents": ["affirm"]},
-            {
-                "policies": [
-                    {
-                        "name": "TwoStageFallbackPolicy",
-                        "deny_suggestion_intent_name": "deny",
-                    }
-                ]
-            },
-        )
-    ],
-)
-def test_two_stage_fallback_without_deny_suggestion(
-    domain: Dict[Text, Any], policy_config: Dict[Text, Any]
-):
-    with pytest.raises(InvalidDomain) as execinfo:
-        Agent(
-            domain=Domain.from_dict(domain),
-            policies=PolicyEnsemble.from_dict(policy_config),
-        )
-    assert "The intent 'deny' must be present" in str(execinfo.value)
-
-
 @pytest.mark.parametrize(
     "domain, policy_config",
     [
diff --git a/tests/core/test_config.py b/tests/core/test_config.py
index 4b898ad09169..fd096ff8b7ed 100644
--- a/tests/core/test_config.py
+++ b/tests/core/test_config.py
@@ -10,8 +10,7 @@
     DEFAULT_NLU_FALLBACK_AMBIGUITY_THRESHOLD,
 )
 from rasa.core.policies.ensemble import PolicyEnsemble
-from rasa.core.policies.fallback import FallbackPolicy
-from rasa.core.policies.form_policy import FormPolicy
+from rasa.core.policies.rule_policy import RulePolicy
 from rasa.core.policies.memoization import MemoizationPolicy
 from rasa.shared.core.constants import (
     ACTION_DEFAULT_FALLBACK_NAME,
@@ -223,51 +222,35 @@ def check_memoization(p):
         assert p.max_history == 5
         assert p.priority == 3
 
-    def check_fallback(p):
-        assert p.fallback_action_name == "action_default_fallback"
-        assert p.nlu_threshold == 0.7
-        assert p.core_threshold == 0.7
-        assert p.priority == 2
-
-    def check_form(p):
+    def check_rule(p):
         assert p.priority == 1
 
     ensemble_dict = {
         "policies": [
             {"max_history": 5, "priority": 3, "name": "MemoizationPolicy"},
-            {
-                "core_threshold": 0.7,
-                "priority": 2,
-                "name": "FallbackPolicy",
-                "nlu_threshold": 0.7,
-                "fallback_action_name": "action_default_fallback",
-            },
-            {"name": "FormPolicy", "priority": 1},
+            {"name": "RulePolicy", "priority": 1},
         ]
     }
     ensemble = PolicyEnsemble.from_dict(ensemble_dict)
 
     # Check if all policies are present
-    assert len(ensemble) == 3
-    # MemoizationPolicy is parent of FormPolicy
+    assert len(ensemble) == 2
+    # MemoizationPolicy is parent of RulePolicy
     assert any(
         [
-            isinstance(p, MemoizationPolicy) and not isinstance(p, FormPolicy)
+            isinstance(p, MemoizationPolicy) and not isinstance(p, RulePolicy)
             for p in ensemble
         ]
     )
-    assert any([isinstance(p, FallbackPolicy) for p in ensemble])
-    assert any([isinstance(p, FormPolicy) for p in ensemble])
+    assert any([isinstance(p, RulePolicy) for p in ensemble])
 
     # Verify policy configurations
     for policy in ensemble:
         if isinstance(policy, MemoizationPolicy):
-            if isinstance(policy, FormPolicy):
-                check_form(policy)
+            if isinstance(policy, RulePolicy):
+                check_rule(policy)
             else:
                 check_memoization(policy)
-        elif isinstance(policy, FallbackPolicy):
-            check_fallback(policy)
 
 
 TEST_MIGRATED_MAPPING_POLICIES = [
diff --git a/tests/core/test_ensemble.py b/tests/core/test_ensemble.py
index 3c9cd7725bde..b072ab1abb05 100644
--- a/tests/core/test_ensemble.py
+++ b/tests/core/test_ensemble.py
@@ -13,9 +13,7 @@
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.generator import TrackerWithCachedStates
-from rasa.shared.core.events import UserUttered, ActiveLoop, Event, SlotSet
-from rasa.core.policies.fallback import FallbackPolicy
-from rasa.core.policies.form_policy import FormPolicy
+from rasa.shared.core.events import UserUttered, Event, SlotSet
 from rasa.core.policies.policy import Policy, PolicyPrediction
 from rasa.core.policies.ensemble import (
     PolicyEnsemble,
@@ -23,18 +21,10 @@
     SimplePolicyEnsemble,
 )
 from rasa.core.policies.rule_policy import RulePolicy
-import rasa.core.actions.action
 
-from tests.core import utilities
-from rasa.core.constants import FORM_POLICY_PRIORITY
 from rasa.shared.core.events import ActionExecuted, DefinePrevUserUtteredFeaturization
-from rasa.core.policies.two_stage_fallback import TwoStageFallbackPolicy
-from rasa.core.policies.mapping_policy import MappingPolicy
 from rasa.shared.core.constants import (
-    USER_INTENT_RESTART,
     ACTION_LISTEN_NAME,
-    ACTION_RESTART_NAME,
-    ACTION_DEFAULT_FALLBACK_NAME,
     ACTION_UNLIKELY_INTENT_NAME,
 )
 from rasa.core.policies.unexpected_intent_policy import UnexpecTEDIntentPolicy
@@ -184,152 +174,6 @@ def test_policy_priority():
     assert prediction.probabilities == priority_2_result.probabilities
 
 
-def test_fallback_mapping_restart():
-    domain = Domain.load("data/test_domains/default.yml")
-    events = [
-        ActionExecuted(ACTION_DEFAULT_FALLBACK_NAME, timestamp=1),
-        utilities.user_uttered(USER_INTENT_RESTART, 1, timestamp=2),
-    ]
-    tracker = DialogueStateTracker.from_events("test", events, [])
-
-    two_stage_fallback_policy = TwoStageFallbackPolicy(
-        priority=2, deny_suggestion_intent_name="deny"
-    )
-    mapping_policy = MappingPolicy(priority=1)
-
-    mapping_fallback_ensemble = SimplePolicyEnsemble(
-        [two_stage_fallback_policy, mapping_policy]
-    )
-
-    prediction = mapping_fallback_ensemble.probabilities_using_best_policy(
-        tracker, domain, RegexInterpreter()
-    )
-    index_of_mapping_policy = 1
-    next_action = rasa.core.actions.action.action_for_index(
-        prediction.max_confidence_index, domain, None
-    )
-
-    assert (
-        prediction.policy_name
-        == f"policy_{index_of_mapping_policy}_{MappingPolicy.__name__}"
-    )
-    assert next_action.name() == ACTION_RESTART_NAME
-
-
-@pytest.mark.parametrize(
-    "events",
-    [
-        [
-            ActiveLoop("test-form"),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            utilities.user_uttered(USER_INTENT_RESTART, 1),
-        ],
-        [
-            ActionExecuted(ACTION_LISTEN_NAME),
-            utilities.user_uttered(USER_INTENT_RESTART, 1),
-        ],
-    ],
-)
-def test_mapping_wins_over_form(events: List[Event]):
-    domain = """
-    forms:
-      test-form: {}
-    """
-    domain = Domain.from_yaml(domain)
-    tracker = DialogueStateTracker.from_events("test", events, [])
-
-    ensemble = SimplePolicyEnsemble(
-        [
-            MappingPolicy(),
-            ConstantPolicy(priority=1, predict_index=0),
-            FormPolicy(),
-            FallbackPolicy(),
-        ]
-    )
-    prediction = ensemble.probabilities_using_best_policy(
-        tracker, domain, RegexInterpreter()
-    )
-
-    next_action = rasa.core.actions.action.action_for_index(
-        prediction.max_confidence_index, domain, None
-    )
-
-    index_of_mapping_policy = 0
-    assert (
-        prediction.policy_name
-        == f"policy_{index_of_mapping_policy}_{MappingPolicy.__name__}"
-    )
-    assert next_action.name() == ACTION_RESTART_NAME
-
-
-@pytest.mark.parametrize(
-    "ensemble",
-    [
-        SimplePolicyEnsemble(
-            [
-                FormPolicy(),
-                ConstantPolicy(FORM_POLICY_PRIORITY - 1, 0),
-                FallbackPolicy(),
-            ]
-        ),
-        SimplePolicyEnsemble([FormPolicy(), MappingPolicy()]),
-    ],
-)
-def test_form_wins_over_everything_else(ensemble: SimplePolicyEnsemble):
-    form_name = "test-form"
-    domain = f"""
-    forms:
-      {form_name}: {{}}
-    """
-    domain = Domain.from_yaml(domain)
-
-    events = [
-        ActiveLoop("test-form"),
-        ActionExecuted(ACTION_LISTEN_NAME),
-        utilities.user_uttered("test", 1),
-    ]
-    tracker = DialogueStateTracker.from_events("test", events, [])
-    prediction = ensemble.probabilities_using_best_policy(
-        tracker, domain, RegexInterpreter()
-    )
-
-    next_action = rasa.core.actions.action.action_for_index(
-        prediction.max_confidence_index, domain, None
-    )
-
-    index_of_form_policy = 0
-    assert (
-        prediction.policy_name == f"policy_{index_of_form_policy}_{FormPolicy.__name__}"
-    )
-    assert next_action.name() == form_name
-
-
-def test_fallback_wins_over_mapping():
-    domain = Domain.load("data/test_domains/default.yml")
-    events = [
-        ActionExecuted(ACTION_LISTEN_NAME),
-        # Low confidence should trigger fallback
-        utilities.user_uttered(USER_INTENT_RESTART, 0.0001),
-    ]
-    tracker = DialogueStateTracker.from_events("test", events, [])
-
-    ensemble = SimplePolicyEnsemble([FallbackPolicy(), MappingPolicy()])
-
-    prediction = ensemble.probabilities_using_best_policy(
-        tracker, domain, RegexInterpreter()
-    )
-    index_of_fallback_policy = 0
-    next_action = rasa.core.actions.action.action_for_index(
-        prediction.max_confidence_index, domain, None
-    )
-
-    assert (
-        prediction.policy_name
-        == f"policy_{index_of_fallback_policy}_{FallbackPolicy.__name__}"
-    )
-    assert next_action.name() == ACTION_DEFAULT_FALLBACK_NAME
-
-
 class LoadReturnsNonePolicy(Policy):
     @classmethod
     def load(cls, *args, **kwargs) -> None:
@@ -471,7 +315,7 @@ def test_rule_based_data_warnings_no_rule_trackers():
 
 def test_rule_based_data_warnings_no_rule_policy():
     trackers = [DialogueStateTracker("some-id", slots=[], is_rule_tracker=True)]
-    policies = [FallbackPolicy()]
+    policies = [ConstantPolicy()]
     ensemble = SimplePolicyEnsemble(policies)
 
     with pytest.warns(UserWarning) as record:
@@ -482,24 +326,6 @@ def test_rule_based_data_warnings_no_rule_policy():
     ) in record[0].message.args[0]
 
 
-@pytest.mark.parametrize(
-    "policies",
-    [
-        ["RulePolicy", "MappingPolicy"],
-        ["RulePolicy", "FallbackPolicy"],
-        ["RulePolicy", "TwoStageFallbackPolicy"],
-        ["RulePolicy", "FormPolicy"],
-        ["RulePolicy", "FallbackPolicy", "FormPolicy"],
-    ],
-)
-def test_mutual_exclusion_of_rule_policy_and_old_rule_like_policies(
-    policies: List[Text],
-):
-    policy_config = [{"name": policy_name} for policy_name in policies]
-    with pytest.warns(UserWarning):
-        PolicyEnsemble.from_dict({"policies": policy_config})
-
-
 def test_end_to_end_prediction_supersedes_others(domain: Domain):
     expected_action_index = 2
     expected_confidence = 0.5
diff --git a/tests/core/test_policies.py b/tests/core/test_policies.py
index 0f1a85adf0f3..d473198ff32d 100644
--- a/tests/core/test_policies.py
+++ b/tests/core/test_policies.py
@@ -1,39 +1,20 @@
 from pathlib import Path
-from typing import Type, List, Text, Tuple, Optional, Any
-from unittest.mock import patch
+from typing import Type, List, Text, Optional, Any
 
 import numpy as np
 import pytest
 
-from rasa.core.channels import OutputChannel
-from rasa.core.nlg import NaturalLanguageGenerator
 from rasa.shared.core.generator import TrackerWithCachedStates
-import rasa.shared.utils.io
 
 from rasa.core import training
-import rasa.core.actions.action
 from rasa.shared.constants import DEFAULT_SENDER_ID
-from rasa.shared.core.training_data.story_writer.markdown_story_writer import (
-    MarkdownStoryWriter,
-)
-from rasa.shared.nlu.constants import ACTION_NAME, INTENT_NAME_KEY
 from rasa.shared.core.constants import (
-    USER_INTENT_RESTART,
-    USER_INTENT_BACK,
     ACTION_LISTEN_NAME,
-    ACTION_RESTART_NAME,
-    ACTION_DEFAULT_FALLBACK_NAME,
-    ACTION_DEFAULT_ASK_AFFIRMATION_NAME,
-    ACTION_DEFAULT_ASK_REPHRASE_NAME,
-    ACTION_BACK_NAME,
-    PREVIOUS_ACTION,
-    USER,
     ACTION_UNLIKELY_INTENT_NAME,
 )
-from rasa.shared.core.domain import State, Domain
+from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import (
     ActionExecuted,
-    ConversationPaused,
     Event,
     UserUttered,
     EntitiesAdded,
@@ -45,18 +26,12 @@
     TrackerFeaturizer,
 )
 from rasa.shared.nlu.interpreter import RegexInterpreter
-from rasa.core.policies.form_policy import FormPolicy
 from rasa.core.policies.policy import SupportedData, Policy
 from rasa.core.policies.rule_policy import RulePolicy
-from rasa.core.policies.two_stage_fallback import TwoStageFallbackPolicy
 from rasa.core.policies.ted_policy import TEDPolicy
-from rasa.core.policies.fallback import FallbackPolicy
-from rasa.core.policies.mapping_policy import MappingPolicy
 from rasa.core.policies.memoization import AugmentedMemoizationPolicy, MemoizationPolicy
-from rasa.core.policies.sklearn_policy import SklearnPolicy
 from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.nlu.training_data.formats.markdown import INTENT
-from tests.core.utilities import get_tracker, read_dialogue_file, user_uttered
+from tests.core.utilities import get_tracker, read_dialogue_file
 
 
 async def train_trackers(
@@ -192,182 +167,6 @@ def _get_next_action(policy: Policy, events: List[Event], domain: Domain) -> Tex
         return domain.action_names_or_texts[index]
 
 
-class TestSklearnPolicy(PolicyTestCollection):
-    def create_policy(
-        self, featurizer: Optional[TrackerFeaturizer], priority: int, **kwargs: Any
-    ) -> SklearnPolicy:
-        return SklearnPolicy(featurizer, priority, **kwargs)
-
-    @pytest.fixture()
-    def mock_search(self):
-        with patch("rasa.core.policies.sklearn_policy.GridSearchCV") as gs:
-            gs.best_estimator_ = "mockmodel"
-            gs.best_score_ = 0.123
-            gs.return_value = gs  # for __init__
-            yield gs
-
-    @pytest.fixture(scope="class")
-    async def trackers(
-        self, default_domain: Domain, stories_path: Text
-    ) -> List[TrackerWithCachedStates]:
-        return await train_trackers(
-            default_domain, stories_path, augmentation_factor=20
-        )
-
-    def test_additional_train_args_do_not_raise(
-        self,
-        default_domain: Domain,
-        trackers: List[TrackerWithCachedStates],
-        featurizer: Optional[TrackerFeaturizer],
-        priority: int,
-    ):
-        policy = self.create_policy(featurizer=featurizer, priority=priority, cv=None)
-        policy.train(
-            trackers,
-            domain=default_domain,
-            interpreter=RegexInterpreter(),
-            this_is_not_a_feature=True,
-        )
-
-    def test_cv_none_does_not_trigger_search(
-        self,
-        mock_search,
-        default_domain: Domain,
-        trackers: List[TrackerWithCachedStates],
-        featurizer: Optional[TrackerFeaturizer],
-        priority: int,
-    ):
-        policy = self.create_policy(featurizer=featurizer, priority=priority, cv=None)
-        policy.train(trackers, domain=default_domain, interpreter=RegexInterpreter())
-
-        assert mock_search.call_count == 0
-        assert policy.model != "mockmodel"
-
-    def test_cv_not_none_param_grid_none_triggers_search_without_params(
-        self,
-        mock_search,
-        default_domain: Domain,
-        trackers: List[TrackerWithCachedStates],
-        featurizer: Optional[TrackerFeaturizer],
-        priority: int,
-    ):
-
-        policy = self.create_policy(featurizer=featurizer, priority=priority, cv=3)
-        policy.train(trackers, domain=default_domain, interpreter=RegexInterpreter())
-
-        assert mock_search.call_count > 0
-        assert mock_search.call_args_list[0][1]["cv"] == 3
-        assert mock_search.call_args_list[0][1]["param_grid"] == {}
-        assert policy.model == "mockmodel"
-
-    def test_cv_not_none_param_grid_none_triggers_search_with_params(
-        self,
-        mock_search,
-        default_domain: Domain,
-        trackers: List[TrackerWithCachedStates],
-        featurizer: Optional[TrackerFeaturizer],
-        priority: int,
-    ):
-        param_grid = {"n_estimators": 50}
-        policy = self.create_policy(
-            featurizer=featurizer, priority=priority, cv=3, param_grid=param_grid
-        )
-        policy.train(trackers, domain=default_domain, interpreter=RegexInterpreter())
-
-        assert mock_search.call_count > 0
-        assert mock_search.call_args_list[0][1]["cv"] == 3
-        assert mock_search.call_args_list[0][1]["param_grid"] == param_grid
-        assert policy.model == "mockmodel"
-
-    def test_missing_classes_filled_correctly(
-        self,
-        default_domain: Domain,
-        trackers: List[TrackerWithCachedStates],
-        tracker: DialogueStateTracker,
-        featurizer: Optional[TrackerFeaturizer],
-        priority: int,
-    ):
-        # Pretend that a couple of classes are missing and check that
-        # those classes are predicted as 0, while the other class
-        # probabilities are predicted normally.
-        policy = self.create_policy(featurizer=featurizer, priority=priority, cv=None)
-
-        classes = [1, 3]
-        new_trackers = []
-        for tr in trackers:
-            new_tracker = DialogueStateTracker(DEFAULT_SENDER_ID, default_domain.slots)
-            for e in tr.applied_events():
-                if isinstance(e, ActionExecuted):
-                    new_action = rasa.core.actions.action.action_for_index(
-                        np.random.choice(classes), default_domain, action_endpoint=None
-                    ).name()
-                    new_tracker.update(ActionExecuted(new_action))
-                else:
-                    new_tracker.update(e)
-
-            new_trackers.append(new_tracker)
-
-        policy.train(
-            new_trackers, domain=default_domain, interpreter=RegexInterpreter()
-        )
-        prediction = policy.predict_action_probabilities(
-            tracker, default_domain, RegexInterpreter()
-        )
-
-        assert not prediction.is_end_to_end_prediction
-        assert len(prediction.probabilities) == default_domain.num_actions
-        assert np.allclose(sum(prediction.probabilities), 1.0)
-        for i, prob in enumerate(prediction.probabilities):
-            if i in classes:
-                assert prob >= 0.0
-            else:
-                assert prob == 0.0
-
-    def test_train_kwargs_are_set_on_model(
-        self,
-        default_domain: Domain,
-        trackers: List[TrackerWithCachedStates],
-        featurizer: Optional[TrackerFeaturizer],
-        priority: int,
-    ):
-        policy = self.create_policy(
-            featurizer=featurizer, priority=priority, cv=None, C=123
-        )
-        policy.train(trackers, domain=default_domain, interpreter=RegexInterpreter())
-        assert policy.model.C == 123
-
-    def test_train_with_shuffle_false(
-        self,
-        default_domain: Domain,
-        trackers: List[TrackerWithCachedStates],
-        featurizer: Optional[TrackerFeaturizer],
-        priority: int,
-    ):
-        policy = self.create_policy(
-            featurizer=featurizer, priority=priority, shuffle=False
-        )
-        # does not raise
-        policy.train(trackers, domain=default_domain, interpreter=RegexInterpreter())
-
-    def test_finetune_after_load(
-        self,
-        trained_policy: SklearnPolicy,
-        trackers: List[TrackerWithCachedStates],
-        default_domain: Domain,
-        tmp_path: Path,
-    ):
-
-        trained_policy.persist(tmp_path)
-
-        loaded_policy = SklearnPolicy.load(tmp_path, should_finetune=True)
-
-        assert loaded_policy.finetune_mode
-
-        loaded_policy.train(trackers, default_domain, RegexInterpreter())
-
-        assert loaded_policy.model
-
-
 class TestMemoizationPolicy(PolicyTestCollection):
     def create_policy(
         self, featurizer: Optional[TrackerFeaturizer], priority: int
@@ -552,451 +351,6 @@ def create_policy(
         return AugmentedMemoizationPolicy(priority=priority, max_history=max_history)
 
 
-class TestFormPolicy(TestMemoizationPolicy):
-    def create_policy(
-        self, featurizer: Optional[TrackerFeaturizer], priority: int
-    ) -> Policy:
-        return FormPolicy(priority=priority)
-
-    def _test_for_previous_action_and_intent(
-        self, states: List[State], intent: Text, action_name: Text
-    ) -> bool:
-        previous_action_as_expected = False
-        intent_as_expected = False
-        if states[0].get(PREVIOUS_ACTION):
-            previous_action_as_expected = (
-                states[0].get(PREVIOUS_ACTION).get(ACTION_NAME) == action_name
-            )
-        if states[-1].get(USER):
-            intent_as_expected = states[-1].get(USER).get(INTENT) == intent
-        return previous_action_as_expected and intent_as_expected
-
-    async def test_memorise(self, trained_policy: FormPolicy, default_domain: Domain):
-        domain = Domain.load("data/test_domains/form.yml")
-        trackers = await training.load_data(
-            "data/test_yaml_stories/stories_form.yml", domain
-        )
-        trained_policy.train(trackers, domain, RegexInterpreter())
-
-        (
-            all_states,
-            all_actions,
-        ) = trained_policy.featurizer.training_states_and_labels(trackers, domain)
-
-        for tracker, states, actions in zip(trackers, all_states, all_actions):
-            for state in states:
-                if state is not None:
-                    # check that 'form: inform' was ignored
-                    if state.get(USER):
-                        assert not state.get(USER).get(INTENT) == "inform"
-            recalled = trained_policy.recall(states, tracker, domain)
-            active_form = trained_policy._get_active_form_name(states[-1])
-
-            if states[0] is not None and states[-1] is not None:
-                # explicitly set intents and actions before listen after
-                # which FormPolicy should not predict a form action and
-                # should add FormValidation(False) event
-                # @formatter:off
-                is_no_validation = (
-                    self._test_for_previous_action_and_intent(
-                        states, "default", "some_form"
-                    )
-                    or self._test_for_previous_action_and_intent(
-                        states, "stop", "some_form"
-                    )
-                    or self._test_for_previous_action_and_intent(
-                        states, "affirm", "utter_ask_continue"
-                    )
-                    or self._test_for_previous_action_and_intent(
-                        states, "deny", "utter_ask_continue"
-                    )
-                    # comes from the fact that intent_inform after utter_ask_continue
-                    # is not read from stories
-                    or self._test_for_previous_action_and_intent(
-                        states, "stop", "utter_ask_continue"
-                    )
-                )
-                # @formatter:on
-            else:
-                is_no_validation = False
-
-            if "intent_start_form" in states[-1]:
-                # explicitly check that intent that starts the form
-                # is not memorized as non validation intent
-                assert recalled is None
-            elif is_no_validation:
-                assert recalled == active_form
-
-        nums = np.random.randn(domain.num_states)
-        random_states = [{f: num for f, num in zip(domain.input_states, nums)}]
-        assert trained_policy.recall(random_states, None, domain) is None
-
-    def test_memorise_with_nlu(self, trained_policy, default_domain):
-        pass
-
-
-class TestMappingPolicy(PolicyTestCollection):
-    def create_policy(
-        self, featurizer: Optional[TrackerFeaturizer], priority: int
-    ) -> Policy:
-        return MappingPolicy()
-
-    def test_featurizer(self, trained_policy: Policy, tmp_path: Path):
-        assert trained_policy.featurizer is None
-        trained_policy.persist(str(tmp_path))
-        loaded = trained_policy.__class__.load(str(tmp_path))
-        assert loaded.featurizer is None
-
-    @pytest.fixture(scope="class")
-    def domain_with_mapping(self, domain_with_mapping_path: Text) -> Domain:
-        return Domain.load(domain_with_mapping_path)
-
-    @pytest.fixture
-    def tracker(self, domain_with_mapping: Domain) -> DialogueStateTracker:
-        return DialogueStateTracker(DEFAULT_SENDER_ID, domain_with_mapping.slots)
-
-    @pytest.fixture(
-        params=[
-            ("default", "utter_default"),
-            ("greet", "utter_greet"),
-            (USER_INTENT_RESTART, ACTION_RESTART_NAME),
-            (USER_INTENT_BACK, ACTION_BACK_NAME),
-        ]
-    )
-    def intent_mapping(self, request) -> Tuple[Text, Text]:
-        return request.param
-
-    def test_predict_mapped_action(
-        self,
-        priority: int,
-        domain_with_mapping: Domain,
-        intent_mapping: Tuple[Text, Text],
-    ):
-        policy = self.create_policy(None, priority)
-        events = [
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered(intent_mapping[0], 1),
-        ]
-
-        assert (
-            self._get_next_action(policy, events, domain_with_mapping)
-            == intent_mapping[1]
-        )
-
-    def test_restart_if_paused(self, priority: int, domain_with_mapping: Domain):
-        policy = self.create_policy(None, priority)
-        events = [ConversationPaused(), user_uttered(USER_INTENT_RESTART, 1)]
-
-        assert (
-            self._get_next_action(policy, events, domain_with_mapping)
-            == ACTION_RESTART_NAME
-        )
-
-    def test_predict_action_listen(
-        self,
-        priority: int,
-        domain_with_mapping: Domain,
-        intent_mapping: Tuple[Text, Text],
-    ):
-        policy = self.create_policy(None, priority)
-        events = [
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered(intent_mapping[0], 1),
-            ActionExecuted(intent_mapping[1], policy="policy_0_MappingPolicy"),
-        ]
-        tracker = get_tracker(events)
-        prediction = policy.predict_action_probabilities(
-            tracker, domain_with_mapping, RegexInterpreter()
-        )
-        index = prediction.probabilities.index(max(prediction.probabilities))
-        action_planned = domain_with_mapping.action_names_or_texts[index]
-        assert not prediction.is_end_to_end_prediction
-        assert action_planned == ACTION_LISTEN_NAME
-        assert prediction.probabilities != [0] * domain_with_mapping.num_actions
-
-    def test_do_not_follow_other_policy(
-        self,
-        priority: int,
-        domain_with_mapping: Domain,
-        intent_mapping: Tuple[Text, Text],
-    ):
-        policy = self.create_policy(None, priority)
-        events = [
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered(intent_mapping[0], 1),
-            ActionExecuted(intent_mapping[1], policy="other_policy"),
-        ]
-        tracker = get_tracker(events)
-        prediction = policy.predict_action_probabilities(
-            tracker, domain_with_mapping, RegexInterpreter()
-        )
-        assert prediction.probabilities == [0] * domain_with_mapping.num_actions
-        assert not prediction.is_end_to_end_prediction
-
-
-class TestFallbackPolicy(PolicyTestCollection):
-    def create_policy(
-        self, featurizer: Optional[TrackerFeaturizer], priority: int
-    ) -> Policy:
-        return FallbackPolicy(priority=priority)
-
-    def test_featurizer(self, trained_policy: Policy, tmp_path: Path):
-        assert trained_policy.featurizer is None
-        trained_policy.persist(str(tmp_path))
-        loaded = trained_policy.__class__.load(str(tmp_path))
-        assert loaded.featurizer is None
-
-    @pytest.mark.parametrize(
-        "top_confidence, all_confidences, last_action_name, should_nlu_fallback",
-        [
-            (0.1, [0.1], "some_action", False),
-            (0.1, [0.1], "action_listen", True),
-            (0.9, [0.9, 0.1], "some_action", False),
-            (0.9, [0.9, 0.1], "action_listen", False),
-            (0.4, [0.4, 0.35], "some_action", False),
-            (0.4, [0.4, 0.35], "action_listen", True),
-            (0.9, [0.9, 0.85], "action_listen", True),
-        ],
-    )
-    def test_should_nlu_fallback(
-        self,
-        trained_policy: TwoStageFallbackPolicy,
-        top_confidence: float,
-        all_confidences: List[float],
-        last_action_name: Text,
-        should_nlu_fallback: bool,
-    ):
-        nlu_data = {
-            "intent": {"confidence": top_confidence},
-            "intent_ranking": [
-                {"confidence": confidence} for confidence in all_confidences
-            ],
-        }
-        assert (
-            trained_policy.should_nlu_fallback(nlu_data, last_action_name)
-            is should_nlu_fallback
-        )
-
-
-class TestTwoStageFallbackPolicy(TestFallbackPolicy):
-    def create_policy(
-        self, featurizer: Optional[TrackerFeaturizer], priority: int
-    ) -> Policy:
-        return TwoStageFallbackPolicy(
-            priority=priority, deny_suggestion_intent_name="deny"
-        )
-
-    @pytest.fixture(scope="class")
-    def default_domain(self) -> Domain:
-        content = """
-        intents:
-          - greet
-          - bye
-          - affirm
-          - deny
-        """
-        return Domain.from_yaml(content)
-
-    @staticmethod
-    async def _get_tracker_after_reverts(
-        events: List[Event],
-        channel: OutputChannel,
-        nlg: NaturalLanguageGenerator,
-        domain: Domain,
-    ) -> DialogueStateTracker:
-        tracker = get_tracker(events)
-        action = rasa.core.actions.action.ActionRevertFallbackEvents()
-        events += await action.run(channel, nlg, tracker, domain)
-
-        return get_tracker(events)
-
-    def test_ask_affirmation(self, trained_policy: Policy, default_domain: Domain):
-        events = [ActionExecuted(ACTION_LISTEN_NAME), user_uttered("Hi", 0.2)]
-
-        next_action = self._get_next_action(trained_policy, events, default_domain)
-
-        assert next_action == ACTION_DEFAULT_ASK_AFFIRMATION_NAME
-
-    async def test_affirmation(
-        self,
-        default_channel: OutputChannel,
-        default_nlg: NaturalLanguageGenerator,
-        default_domain: Domain,
-    ):
-        events = [
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 1),
-            ActionExecuted("utter_hello"),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 0.2),
-            ActionExecuted(ACTION_DEFAULT_ASK_AFFIRMATION_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 1),
-        ]
-
-        tracker = await self._get_tracker_after_reverts(
-            events, default_channel, default_nlg, default_domain
-        )
-
-        assert "greet" == tracker.latest_message.parse_data["intent"][INTENT_NAME_KEY]
-        assert tracker.export_stories(MarkdownStoryWriter(), e2e=True) == (
-            "## sender\n* greet: Random\n    - utter_hello\n* greet: Random\n"
-        )
-
-    def test_ask_rephrase(self, trained_policy: Policy, default_domain: Domain):
-        events = [
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 0.2),
-            ActionExecuted(ACTION_DEFAULT_ASK_AFFIRMATION_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("deny", 1),
-        ]
-
-        next_action = self._get_next_action(trained_policy, events, default_domain)
-
-        assert next_action == ACTION_DEFAULT_ASK_REPHRASE_NAME
-
-    async def test_successful_rephrasing(
-        self,
-        default_channel: OutputChannel,
-        default_nlg: NaturalLanguageGenerator,
-        default_domain: Domain,
-    ):
-        events = [
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 0.2),
-            ActionExecuted(ACTION_DEFAULT_ASK_AFFIRMATION_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("deny", 1),
-            ActionExecuted(ACTION_DEFAULT_ASK_REPHRASE_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("bye", 1),
-        ]
-
-        tracker = await self._get_tracker_after_reverts(
-            events, default_channel, default_nlg, default_domain
-        )
-
-        assert "bye" == tracker.latest_message.parse_data["intent"][INTENT_NAME_KEY]
-        assert tracker.export_stories(MarkdownStoryWriter()) == "## sender\n* bye\n"
-
-    def test_affirm_rephrased_intent(
-        self, trained_policy: Policy, default_domain: Domain
-    ):
-        events = [
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 0.2),
-            ActionExecuted(ACTION_DEFAULT_ASK_AFFIRMATION_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("deny", 1),
-            ActionExecuted(ACTION_DEFAULT_ASK_REPHRASE_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 0.2),
-        ]
-
-        next_action = self._get_next_action(trained_policy, events, default_domain)
-
-        assert next_action == ACTION_DEFAULT_ASK_AFFIRMATION_NAME
-
-    async def test_affirmed_rephrasing(
-        self,
-        default_channel: OutputChannel,
-        default_nlg: NaturalLanguageGenerator,
-        default_domain: Domain,
-    ):
-        events = [
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 0.2),
-            ActionExecuted(ACTION_DEFAULT_ASK_AFFIRMATION_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("deny", 1),
-            ActionExecuted(ACTION_DEFAULT_ASK_REPHRASE_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("bye", 0.2),
-            ActionExecuted(ACTION_DEFAULT_ASK_AFFIRMATION_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("bye", 1),
-        ]
-
-        tracker = await self._get_tracker_after_reverts(
-            events, default_channel, default_nlg, default_domain
-        )
-
-        assert "bye" == tracker.latest_message.parse_data["intent"][INTENT_NAME_KEY]
-        assert tracker.export_stories(MarkdownStoryWriter()) == "## sender\n* bye\n"
-
-    def test_denied_rephrasing_affirmation(
-        self, trained_policy: Policy, default_domain: Domain
-    ):
-        events = [
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 0.2),
-            ActionExecuted(ACTION_DEFAULT_ASK_AFFIRMATION_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("deny", 1),
-            ActionExecuted(ACTION_DEFAULT_ASK_REPHRASE_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("bye", 0.2),
-            ActionExecuted(ACTION_DEFAULT_ASK_AFFIRMATION_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("deny", 1),
-        ]
-
-        next_action = self._get_next_action(trained_policy, events, default_domain)
-
-        assert next_action == ACTION_DEFAULT_FALLBACK_NAME
-
-    async def test_rephrasing_instead_affirmation(
-        self,
-        default_channel: OutputChannel,
-        default_nlg: NaturalLanguageGenerator,
-        default_domain: Domain,
-    ):
-        events = [
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 1),
-            ActionExecuted("utter_hello"),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 0.2),
-            ActionExecuted(ACTION_DEFAULT_ASK_AFFIRMATION_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("bye", 1),
-        ]
-
-        tracker = await self._get_tracker_after_reverts(
-            events, default_channel, default_nlg, default_domain
-        )
-
-        assert "bye" == tracker.latest_message.parse_data["intent"][INTENT_NAME_KEY]
-        assert tracker.export_stories(MarkdownStoryWriter(), e2e=True) == (
-            "## sender\n* greet: Random\n    - utter_hello\n* bye: Random\n"
-        )
-
-    def test_unknown_instead_affirmation(
-        self, trained_policy: Policy, default_domain: Domain
-    ):
-        events = [
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 0.2),
-            ActionExecuted(ACTION_DEFAULT_ASK_AFFIRMATION_NAME),
-            ActionExecuted(ACTION_LISTEN_NAME),
-            user_uttered("greet", 0.2),
-        ]
-
-        next_action = self._get_next_action(trained_policy, events, default_domain)
-
-        assert next_action == ACTION_DEFAULT_FALLBACK_NAME
-
-    def test_listen_after_hand_off(
-        self, trained_policy: Policy, default_domain: Domain
-    ):
-        events = [ActionExecuted(ACTION_DEFAULT_FALLBACK_NAME)]
-
-        next_action = self._get_next_action(trained_policy, events, default_domain)
-
-        assert next_action == ACTION_LISTEN_NAME
-
-
 @pytest.mark.parametrize(
     "policy,supported_data",
     [
@@ -1046,9 +400,13 @@ def test_get_training_trackers_for_policy(
     assert len(ml_trackers) == n_ml_trackers
 
 
-@pytest.mark.parametrize(
-    "policy", [FormPolicy, MappingPolicy, FallbackPolicy, TwoStageFallbackPolicy]
-)
-def test_deprecation_warnings_for_old_rule_like_policies(policy: Type[Policy]):
-    with pytest.warns(FutureWarning):
-        policy(None)
+class PolicyWithoutInitKwargs(Policy):
+    def __init__(self, *args: Any) -> None:
+        pass
+
+    def persist(self, _) -> None:
+        pass
+
+    @classmethod
+    def _metadata_filename(cls) -> Text:
+        return "no_finetune_policy"
diff --git a/tests/core/test_training.py b/tests/core/test_training.py
index beadbc0d1c8f..1eec838be83d 100644
--- a/tests/core/test_training.py
+++ b/tests/core/test_training.py
@@ -5,14 +5,14 @@
 
 import pytest
 
-from rasa.core.policies.memoization import MemoizationPolicy, OLD_DEFAULT_MAX_HISTORY
+from rasa.core.policies.memoization import MemoizationPolicy
+from rasa.core.constants import DEFAULT_MAX_HISTORY
 from rasa.core.policies.rule_policy import RulePolicy
 from rasa.shared.core.domain import Domain
 from rasa.core.interpreter import RasaNLUInterpreter
 from rasa.shared.nlu.interpreter import RegexInterpreter
 from rasa.core.train import train
 from rasa.core.agent import Agent
-from rasa.core.policies.form_policy import FormPolicy
 from rasa.core.policies.ted_policy import TEDPolicy
 
 from rasa.shared.core.training_data.visualization import visualize_stories
@@ -69,10 +69,8 @@ async def test_training_script_without_max_history_set(
     agent = Agent.load(tmpdir)
     for policy in agent.policy_ensemble.policies:
         if hasattr(policy.featurizer, "max_history"):
-            if type(policy) == FormPolicy:
-                assert policy.featurizer.max_history == 2
-            elif type(policy) == MemoizationPolicy:
-                assert policy.featurizer.max_history == OLD_DEFAULT_MAX_HISTORY
+            if type(policy) == MemoizationPolicy:
+                assert policy.featurizer.max_history == DEFAULT_MAX_HISTORY
             else:
                 assert policy.featurizer.max_history is None
 
@@ -92,7 +90,7 @@ async def test_training_script_with_max_history_set(
     )
     agent = Agent.load(tmpdir)
 
-    expected_max_history = {FormPolicy: 2, RulePolicy: None}
+    expected_max_history = {RulePolicy: None}
     for policy in agent.policy_ensemble.policies:
         if hasattr(policy.featurizer, "max_history"):
             expected_history = expected_max_history.get(type(policy), 5)
diff --git a/tests/shared/core/test_constants.py b/tests/shared/core/test_constants.py
index 1906d7a7c908..3396309ebe37 100644
--- a/tests/shared/core/test_constants.py
+++ b/tests/shared/core/test_constants.py
@@ -2,32 +2,17 @@
 
 import pytest
 
-from rasa.core.policies.fallback import FallbackPolicy
-from rasa.core.policies.form_policy import FormPolicy
-from rasa.core.policies.mapping_policy import MappingPolicy
 from rasa.core.policies.rule_policy import RulePolicy
-from rasa.core.policies.two_stage_fallback import TwoStageFallbackPolicy
 from rasa.nlu.classifiers.fallback_classifier import FallbackClassifier
 from rasa.shared.core.constants import (
     CLASSIFIER_NAME_FALLBACK,
-    POLICY_NAME_FALLBACK,
-    POLICY_NAME_MAPPING,
     POLICY_NAME_RULE,
-    POLICY_NAME_TWO_STAGE_FALLBACK,
-    POLICY_NAME_FORM,
 )
 
 
 @pytest.mark.parametrize(
     "name_in_constant, policy_class",
-    [
-        (POLICY_NAME_TWO_STAGE_FALLBACK, TwoStageFallbackPolicy),
-        (POLICY_NAME_FALLBACK, FallbackPolicy),
-        (POLICY_NAME_MAPPING, MappingPolicy),
-        (POLICY_NAME_FORM, FormPolicy),
-        (POLICY_NAME_RULE, RulePolicy),
-        (CLASSIFIER_NAME_FALLBACK, FallbackClassifier),
-    ],
+    [(POLICY_NAME_RULE, RulePolicy), (CLASSIFIER_NAME_FALLBACK, FallbackClassifier),],
 )
 def test_policy_names(name_in_constant: Text, policy_class: Type):
     assert name_in_constant == policy_class.__name__


Code review comments:
diff_hunk: @@ -1046,9 +400,13 @@ def test_get_training_trackers_for_policy(
     assert len(ml_trackers) == n_ml_trackers
 
 
-@pytest.mark.parametrize(
-    "policy", [FormPolicy, MappingPolicy, FallbackPolicy, TwoStageFallbackPolicy]
-)
-def test_deprecation_warnings_for_old_rule_like_policies(policy: Type[Policy]):
-    with pytest.warns(FutureWarning):
-        policy(None)
+class PolicyWithoutInitKwargs(Policy):
+    def __init__(self, *args: Any) -> None:
+        pass
+
+    def persist(self, _) -> None:
+        pass
+
+    @classmethod
+    def _metadata_filename(cls) -> Text:
+        return "no_finetune_policy"
path: tests/core/test_policies.py
text: @user1:
Looks like this policy isn't used anywhere, did you mean to add some more code?

@author:
Ahh that should be removed. Its leftover code that should have been deleted when I was resolving a merge conflict with main. Removing it now.

diff_hunk: @@ -790,20 +661,16 @@ def _check_policy_for_forms_available(
     if not ensemble:
         return
 
-    from rasa.core.policies.form_policy import FormPolicy
-
-    suited_policies_for_forms = (FormPolicy, RulePolicy)
-
     has_policy_for_forms = ensemble is not None and any(
-        isinstance(policy, suited_policies_for_forms) for policy in ensemble.policies
+        isinstance(policy, RulePolicy) for policy in ensemble.policies
     )
 
     if domain.form_names and not has_policy_for_forms:
         raise InvalidDomain(
-            "You have defined a form action, but have neither added the "
-            f"'{RulePolicy.__name__}' nor the '{FormPolicy.__name__}' (deprecated) to "
-            f"your policy ensemble. Either remove all forms from your domain or add "
-            f"the missing policy to your policy configuration."
+            "You have defined a form action, but have not added the "
+            f"'{RulePolicy.__name__}' to your policy ensemble. Either "
+            f"remove all forms from your domain or add the missing policy "
path: rasa/core/policies/ensemble.py
text: @user1:
```suggestion
            f"remove all forms from your domain or add the '{RulePolicy.__name__}' "
```