rasa-pro 3.9.14__py3-none-any.whl → 3.9.16__py3-none-any.whl

rasa/utils/tensorflow/feature_array.py

@@ -0,0 +1,366 @@
+from typing import Dict, Any, List, Tuple, Optional, Union
+
+from safetensors.numpy import save_file
+import numpy as np
+from safetensors.numpy import load_file
+import scipy.sparse
+
+import rasa.shared.utils.io
+
+
+def _recursive_serialize(
+    array: Any, prefix: str, data_dict: Dict[str, Any], metadata: List[Dict[str, Any]]
+) -> None:
+    """Recursively serialize arrays and matrices for high dimensional data."""
+    if isinstance(array, np.ndarray) and array.ndim <= 2:
+        data_key = f"{prefix}_array"
+        data_dict[data_key] = array
+        metadata.append({"type": "dense", "key": data_key, "shape": array.shape})
+
+    elif isinstance(array, list) and all([isinstance(v, float) for v in array]):
+        data_key = f"{prefix}_list"
+        data_dict[data_key] = np.array(array, dtype=np.float32)
+        metadata.append({"type": "list", "key": data_key})
+
+    elif isinstance(array, list) and all([isinstance(v, int) for v in array]):
+        data_key = f"{prefix}_list"
+        data_dict[data_key] = np.array(array, dtype=np.int64)
+        metadata.append({"type": "list", "key": data_key})
+
+    elif isinstance(array, scipy.sparse.spmatrix):
+        data_key_data = f"{prefix}_data"
+        data_key_row = f"{prefix}_row"
+        data_key_col = f"{prefix}_col"
+        array = array.tocoo()
+        data_dict.update(
+            {
+                data_key_data: array.data,
+                data_key_row: array.row,
+                data_key_col: array.col,
+            }
+        )
+        metadata.append({"type": "sparse", "key": prefix, "shape": array.shape})
+
+    elif isinstance(array, list) or isinstance(array, np.ndarray):
+        group_metadata = {"type": "group", "subcomponents": []}
+        for idx, item in enumerate(array):
+            new_prefix = f"{prefix}_{idx}"
+            _recursive_serialize(
+                item, new_prefix, data_dict, group_metadata["subcomponents"]
+            )
+        metadata.append(group_metadata)
+
+
+def _serialize_nested_data(
+    nested_data: Dict[str, Dict[str, List["FeatureArray"]]],
+    prefix: str,
+    data_dict: Dict[str, np.ndarray],
+    metadata: List[Dict[str, Union[str, List]]],
+) -> None:
+    """Handle serialization across dictionary and list levels."""
+    for outer_key, inner_dict in nested_data.items():
+        inner_metadata = {"key": outer_key, "components": []}
+
+        for inner_key, feature_arrays in inner_dict.items():
+            array_metadata = {
+                "key": inner_key,
+                "number_of_dimensions": feature_arrays[0].number_of_dimensions,
+                "features": [],
+            }
+
+            for idx, feature_array in enumerate(feature_arrays):
+                feature_prefix = f"{prefix}_{outer_key}_{inner_key}_{idx}"
+                _recursive_serialize(
+                    feature_array.tolist(),
+                    feature_prefix,
+                    data_dict,
+                    array_metadata["features"],
+                )
+
+            inner_metadata["components"].append(array_metadata)  # type:ignore[attr-defined]
+
+        metadata.append(inner_metadata)
+
+
+def serialize_nested_feature_arrays(
+    nested_feature_array: Dict[str, Dict[str, List["FeatureArray"]]],
+    data_filename: str,
+    metadata_filename: str,
+) -> None:
+    data_dict: Dict[str, np.ndarray] = {}
+    metadata: List[Dict[str, Union[str, List]]] = []
+
+    _serialize_nested_data(nested_feature_array, "component", data_dict, metadata)
+
+    # Save serialized data and metadata
+    save_file(data_dict, data_filename)
+    rasa.shared.utils.io.dump_obj_as_json_to_file(metadata_filename, metadata)
+
+
+def _recursive_deserialize(
+    metadata: List[Dict[str, Any]], data: Dict[str, Any]
+) -> List[Any]:
+    """Recursively deserialize arrays and matrices for high dimensional data."""
+    result = []
+
+    for item in metadata:
+        if item["type"] == "dense":
+            key = item["key"]
+            array = np.asarray(data[key]).reshape(item["shape"])
+            result.append(array)
+
+        elif item["type"] == "list":
+            key = item["key"]
+            result.append(list(data[key]))
+
+        elif item["type"] == "sparse":
+            data_vals = data[f"{item['key']}_data"]
+            row_vals = data[f"{item['key']}_row"]
+            col_vals = data[f"{item['key']}_col"]
+            sparse_matrix = scipy.sparse.coo_matrix(
+                (data_vals, (row_vals, col_vals)), shape=item["shape"]
+            )
+            result.append(sparse_matrix)
+        elif item["type"] == "group":
+            sublist = _recursive_deserialize(item["subcomponents"], data)
+            result.append(sublist)
+
+    return result
+
+
+def _deserialize_nested_data(
+    metadata: List[Dict[str, Any]], data_dict: Dict[str, Any]
+) -> Dict[str, Dict[str, List["FeatureArray"]]]:
+    """Handle deserialization across all dictionary and list levels."""
+    result: Dict[str, Dict[str, List["FeatureArray"]]] = {}
+
+    for outer_item in metadata:
+        outer_key = outer_item["key"]
+        result[outer_key] = {}
+
+        for inner_item in outer_item["components"]:
+            inner_key = inner_item["key"]
+            feature_arrays = []
+
+            # Reconstruct the list of FeatureArrays
+            for feature_item in inner_item["features"]:
+                # Reconstruct the list of FeatureArrays
+                feature_array_data = _recursive_deserialize([feature_item], data_dict)
+                # Prepare the input for the FeatureArray;
+                # ensure it is np.ndarray compatible
+                input_array = np.array(feature_array_data[0], dtype=object)
+                feature_array = FeatureArray(
+                    input_array, inner_item["number_of_dimensions"]
+                )
+                feature_arrays.append(feature_array)
+
+            result[outer_key][inner_key] = feature_arrays
+
+    return result
+
+
+def deserialize_nested_feature_arrays(
+    data_filename: str, metadata_filename: str
+) -> Dict[str, Dict[str, List["FeatureArray"]]]:
+    metadata = rasa.shared.utils.io.read_json_file(metadata_filename)
+    data_dict = load_file(data_filename)
+
+    return _deserialize_nested_data(metadata, data_dict)
+
+
+class FeatureArray(np.ndarray):
+    """Stores any kind of features ready to be used by a RasaModel.
+
+    Next to the input numpy array of features, it also received the number of
+    dimensions of the features.
+    As our features can have 1 to 4 dimensions we might have different number of numpy
+    arrays stacked. The number of dimensions helps us to figure out how to handle this
+    particular feature array. Also, it is automatically determined whether the feature
+    array is sparse or not and the number of units is determined as well.
+
+    Subclassing np.array: https://numpy.org/doc/stable/user/basics.subclassing.html
+    """
+
+    def __new__(
+        cls, input_array: np.ndarray, number_of_dimensions: int
+    ) -> "FeatureArray":
+        """Create and return a new object.  See help(type) for accurate signature."""
+        FeatureArray._validate_number_of_dimensions(number_of_dimensions, input_array)
+
+        feature_array = np.asarray(input_array).view(cls)
+
+        if number_of_dimensions <= 2:
+            feature_array.units = input_array.shape[-1]
+            feature_array.is_sparse = isinstance(input_array[0], scipy.sparse.spmatrix)
+        elif number_of_dimensions == 3:
+            feature_array.units = input_array[0].shape[-1]
+            feature_array.is_sparse = isinstance(input_array[0], scipy.sparse.spmatrix)
+        elif number_of_dimensions == 4:
+            feature_array.units = input_array[0][0].shape[-1]
+            feature_array.is_sparse = isinstance(
+                input_array[0][0], scipy.sparse.spmatrix
+            )
+        else:
+            raise ValueError(
+                f"Number of dimensions '{number_of_dimensions}' currently not "
+                f"supported."
+            )
+
+        feature_array.number_of_dimensions = number_of_dimensions
+
+        return feature_array
+
+    def __init__(
+        self, input_array: Any, number_of_dimensions: int, **kwargs: Any
+    ) -> None:
+        """Initialize. FeatureArray.
+
+        Needed in order to avoid 'Invalid keyword argument number_of_dimensions
+        to function FeatureArray.__init__ '
+        Args:
+            input_array: the array that contains features
+            number_of_dimensions: number of dimensions in input_array
+        """
+        super().__init__(**kwargs)
+        self.number_of_dimensions = number_of_dimensions
+
+    def __array_finalize__(self, obj: Optional[np.ndarray]) -> None:
+        """This method is called when the system allocates a new array from obj.
+
+        Args:
+            obj: A subclass (subtype) of ndarray.
+        """
+        if obj is None:
+            return
+
+        self.units = getattr(obj, "units", None)
+        self.number_of_dimensions = getattr(obj, "number_of_dimensions", None)  # type: ignore[assignment]
+        self.is_sparse = getattr(obj, "is_sparse", None)
+
+        default_attributes = {
+            "units": self.units,
+            "number_of_dimensions": self.number_of_dimensions,
+            "is_spare": self.is_sparse,
+        }
+        self.__dict__.update(default_attributes)
+
+    # pytype: disable=attribute-error
+    def __array_ufunc__(
+        self, ufunc: Any, method: str, *inputs: Any, **kwargs: Any
+    ) -> Any:
+        """Overwrite this method as we are subclassing numpy array.
+
+        Args:
+            ufunc: The ufunc object that was called.
+            method: A string indicating which Ufunc method was called
+                    (one of "__call__", "reduce", "reduceat", "accumulate", "outer",
+                    "inner").
+            *inputs: A tuple of the input arguments to the ufunc.
+            **kwargs: Any additional arguments
+
+        Returns:
+            The result of the operation.
+        """
+        f = {
+            "reduce": ufunc.reduce,
+            "accumulate": ufunc.accumulate,
+            "reduceat": ufunc.reduceat,
+            "outer": ufunc.outer,
+            "at": ufunc.at,
+            "__call__": ufunc,
+        }
+        # convert the inputs to np.ndarray to prevent recursion, call the function,
+        # then cast it back as FeatureArray
+        output = FeatureArray(
+            f[method](*(i.view(np.ndarray) for i in inputs), **kwargs),
+            number_of_dimensions=kwargs["number_of_dimensions"],
+        )
+        output.__dict__ = self.__dict__  # carry forward attributes
+        return output
+
+    def __reduce__(self) -> Tuple[Any, Any, Any]:
+        """Needed in order to pickle this object.
+
+        Returns:
+            A tuple.
+        """
+        pickled_state = super(FeatureArray, self).__reduce__()
+        if isinstance(pickled_state, str):
+            raise TypeError("np array __reduce__ returned string instead of tuple.")
+        new_state = pickled_state[2] + (
+            self.number_of_dimensions,
+            self.is_sparse,
+            self.units,
+        )
+        return pickled_state[0], pickled_state[1], new_state
+
+    def __setstate__(self, state: Any, **kwargs: Any) -> None:
+        """Sets the state.
+
+        Args:
+            state: The state argument must be a sequence that contains the following
+                   elements version, shape, dtype, isFortan, rawdata.
+            **kwargs: Any additional parameter
+        """
+        # Needed in order to load the object
+        self.number_of_dimensions = state[-3]
+        self.is_sparse = state[-2]
+        self.units = state[-1]
+        super(FeatureArray, self).__setstate__(state[0:-3], **kwargs)
+
+    # pytype: enable=attribute-error
+
+    @staticmethod
+    def _validate_number_of_dimensions(
+        number_of_dimensions: int, input_array: np.ndarray
+    ) -> None:
+        """Validates if the input array has given number of dimensions.
+
+        Args:
+            number_of_dimensions: number of dimensions
+            input_array: input array
+
+        Raises: ValueError in case the dimensions do not match
+        """
+        # when loading the feature arrays from disk, the shape represents
+        # the correct number of dimensions
+        if len(input_array.shape) == number_of_dimensions:
+            return
+
+        _sub_array = input_array
+        dim = 0
+        # Go number_of_dimensions into the given input_array
+        for i in range(1, number_of_dimensions + 1):
+            _sub_array = _sub_array[0]
+            if isinstance(_sub_array, scipy.sparse.spmatrix):
+                dim = i
+                break
+            if isinstance(_sub_array, np.ndarray) and _sub_array.shape[0] == 0:
+                # sequence dimension is 0, we are dealing with "fake" features
+                dim = i
+                break
+
+        # If the resulting sub_array is sparse, the remaining number of dimensions
+        # should be at least 2
+        if isinstance(_sub_array, scipy.sparse.spmatrix):
+            if dim > 2:
+                raise ValueError(
+                    f"Given number of dimensions '{number_of_dimensions}' does not "
+                    f"match dimensions of given input array: {input_array}."
+                )
+        elif isinstance(_sub_array, np.ndarray) and _sub_array.shape[0] == 0:
+            # sequence dimension is 0, we are dealing with "fake" features,
+            # but they should be of dim 2
+            if dim > 2:
+                raise ValueError(
+                    f"Given number of dimensions '{number_of_dimensions}' does not "
+                    f"match dimensions of given input array: {input_array}."
+                )
+        # If the resulting sub_array is dense, the sub_array should be a single number
+        elif not np.issubdtype(type(_sub_array), np.integer) and not isinstance(
+            _sub_array, (np.float32, np.float64)
+        ):
+            raise ValueError(
+                f"Given number of dimensions '{number_of_dimensions}' does not match "
+                f"dimensions of given input array: {input_array}."
+            )

rasa/utils/tensorflow/model_data.py

@@ -20,6 +20,8 @@ import numpy as np
 import scipy.sparse
 from sklearn.model_selection import train_test_split
 
+from rasa.utils.tensorflow.feature_array import FeatureArray
+
 logger = logging.getLogger(__name__)
 
 
@@ -37,199 +39,6 @@ def ragged_array_to_ndarray(ragged_array: Iterable[np.ndarray]) -> np.ndarray:
         return np.array(ragged_array, dtype=object)
 
 
-class FeatureArray(np.ndarray):
-    """Stores any kind of features ready to be used by a RasaModel.
-
-    Next to the input numpy array of features, it also received the number of
-    dimensions of the features.
-    As our features can have 1 to 4 dimensions we might have different number of numpy
-    arrays stacked. The number of dimensions helps us to figure out how to handle this
-    particular feature array. Also, it is automatically determined whether the feature
-    array is sparse or not and the number of units is determined as well.
-
-    Subclassing np.array: https://numpy.org/doc/stable/user/basics.subclassing.html
-    """
-
-    def __new__(
-        cls, input_array: np.ndarray, number_of_dimensions: int
-    ) -> "FeatureArray":
-        """Create and return a new object.  See help(type) for accurate signature."""
-        FeatureArray._validate_number_of_dimensions(number_of_dimensions, input_array)
-
-        feature_array = np.asarray(input_array).view(cls)
-
-        if number_of_dimensions <= 2:
-            feature_array.units = input_array.shape[-1]
-            feature_array.is_sparse = isinstance(input_array[0], scipy.sparse.spmatrix)
-        elif number_of_dimensions == 3:
-            feature_array.units = input_array[0].shape[-1]
-            feature_array.is_sparse = isinstance(input_array[0], scipy.sparse.spmatrix)
-        elif number_of_dimensions == 4:
-            feature_array.units = input_array[0][0].shape[-1]
-            feature_array.is_sparse = isinstance(
-                input_array[0][0], scipy.sparse.spmatrix
-            )
-        else:
-            raise ValueError(
-                f"Number of dimensions '{number_of_dimensions}' currently not "
-                f"supported."
-            )
-
-        feature_array.number_of_dimensions = number_of_dimensions
-
-        return feature_array
-
-    def __init__(
-        self, input_array: Any, number_of_dimensions: int, **kwargs: Any
-    ) -> None:
-        """Initialize. FeatureArray.
-
-        Needed in order to avoid 'Invalid keyword argument number_of_dimensions
-        to function FeatureArray.__init__ '
-        Args:
-            input_array: the array that contains features
-            number_of_dimensions: number of dimensions in input_array
-        """
-        super().__init__(**kwargs)
-        self.number_of_dimensions = number_of_dimensions
-
-    def __array_finalize__(self, obj: Optional[np.ndarray]) -> None:
-        """This method is called when the system allocates a new array from obj.
-
-        Args:
-            obj: A subclass (subtype) of ndarray.
-        """
-        if obj is None:
-            return
-
-        self.units = getattr(obj, "units", None)
-        self.number_of_dimensions = getattr(obj, "number_of_dimensions", None)  # type: ignore[assignment]
-        self.is_sparse = getattr(obj, "is_sparse", None)
-
-        default_attributes = {
-            "units": self.units,
-            "number_of_dimensions": self.number_of_dimensions,
-            "is_spare": self.is_sparse,
-        }
-        self.__dict__.update(default_attributes)
-
-    # pytype: disable=attribute-error
-    def __array_ufunc__(
-        self, ufunc: Any, method: Text, *inputs: Any, **kwargs: Any
-    ) -> Any:
-        """Overwrite this method as we are subclassing numpy array.
-
-        Args:
-            ufunc: The ufunc object that was called.
-            method: A string indicating which Ufunc method was called
-                    (one of "__call__", "reduce", "reduceat", "accumulate", "outer",
-                    "inner").
-            *inputs: A tuple of the input arguments to the ufunc.
-            **kwargs: Any additional arguments
-
-        Returns:
-            The result of the operation.
-        """
-        f = {
-            "reduce": ufunc.reduce,
-            "accumulate": ufunc.accumulate,
-            "reduceat": ufunc.reduceat,
-            "outer": ufunc.outer,
-            "at": ufunc.at,
-            "__call__": ufunc,
-        }
-        # convert the inputs to np.ndarray to prevent recursion, call the function,
-        # then cast it back as FeatureArray
-        output = FeatureArray(
-            f[method](*(i.view(np.ndarray) for i in inputs), **kwargs),
-            number_of_dimensions=kwargs["number_of_dimensions"],
-        )
-        output.__dict__ = self.__dict__  # carry forward attributes
-        return output
-
-    def __reduce__(self) -> Tuple[Any, Any, Any]:
-        """Needed in order to pickle this object.
-
-        Returns:
-            A tuple.
-        """
-        pickled_state = super(FeatureArray, self).__reduce__()
-        if isinstance(pickled_state, str):
-            raise TypeError("np array __reduce__ returned string instead of tuple.")
-        new_state = pickled_state[2] + (
-            self.number_of_dimensions,
-            self.is_sparse,
-            self.units,
-        )
-        return pickled_state[0], pickled_state[1], new_state
-
-    def __setstate__(self, state: Any, **kwargs: Any) -> None:
-        """Sets the state.
-
-        Args:
-            state: The state argument must be a sequence that contains the following
-                   elements version, shape, dtype, isFortan, rawdata.
-            **kwargs: Any additional parameter
-        """
-        # Needed in order to load the object
-        self.number_of_dimensions = state[-3]
-        self.is_sparse = state[-2]
-        self.units = state[-1]
-        super(FeatureArray, self).__setstate__(state[0:-3], **kwargs)
-
-    # pytype: enable=attribute-error
-
-    @staticmethod
-    def _validate_number_of_dimensions(
-        number_of_dimensions: int, input_array: np.ndarray
-    ) -> None:
-        """Validates if the the input array has given number of dimensions.
-
-        Args:
-            number_of_dimensions: number of dimensions
-            input_array: input array
-
-        Raises: ValueError in case the dimensions do not match
-        """
-        _sub_array = input_array
-        dim = 0
-        # Go number_of_dimensions into the given input_array
-        for i in range(1, number_of_dimensions + 1):
-            _sub_array = _sub_array[0]
-            if isinstance(_sub_array, scipy.sparse.spmatrix):
-                dim = i
-                break
-            if isinstance(_sub_array, np.ndarray) and _sub_array.shape[0] == 0:
-                # sequence dimension is 0, we are dealing with "fake" features
-                dim = i
-                break
-
-        # If the resulting sub_array is sparse, the remaining number of dimensions
-        # should be at least 2
-        if isinstance(_sub_array, scipy.sparse.spmatrix):
-            if dim > 2:
-                raise ValueError(
-                    f"Given number of dimensions '{number_of_dimensions}' does not "
-                    f"match dimensions of given input array: {input_array}."
-                )
-        elif isinstance(_sub_array, np.ndarray) and _sub_array.shape[0] == 0:
-            # sequence dimension is 0, we are dealing with "fake" features,
-            # but they should be of dim 2
-            if dim > 2:
-                raise ValueError(
-                    f"Given number of dimensions '{number_of_dimensions}' does not "
-                    f"match dimensions of given input array: {input_array}."
-                )
-        # If the resulting sub_array is dense, the sub_array should be a single number
-        elif not np.issubdtype(type(_sub_array), np.integer) and not isinstance(
-            _sub_array, (np.float32, np.float64)
-        ):
-            raise ValueError(
-                f"Given number of dimensions '{number_of_dimensions}' does not match "
-                f"dimensions of given input array: {input_array}."
-            )
-
-
 class FeatureSignature(NamedTuple):
     """Signature of feature arrays.
 

rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.9.14"
+__version__ = "3.9.16"

{rasa_pro-3.9.14.dist-info → rasa_pro-3.9.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rasa-pro
-Version: 3.9.14
+Version: 3.9.16
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Home-page: https://rasa.com
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
@@ -33,7 +33,6 @@ Requires-Dist: attrs (>=23.1,<23.2)
 Requires-Dist: azure-storage-blob (>=12.16.0,<12.17.0)
 Requires-Dist: boto3 (>=1.27.1,<2.0.0)
 Requires-Dist: certifi (>=2024.2.2)
-Requires-Dist: cloudpickle (>=2.2.1,<3.1)
 Requires-Dist: colorama (>=0.4.6,<0.5.0) ; sys_platform == "win32"
 Requires-Dist: colorclass (>=2.2,<2.3)
 Requires-Dist: coloredlogs (>=15,<16)
@@ -54,7 +53,6 @@ Requires-Dist: importlib-metadata (>=6.8.0,<7.0.0)
 Requires-Dist: importlib-resources (>=6.1.1,<7.0.0)
 Requires-Dist: jieba (>=0.42.1,<0.43) ; extra == "jieba" or extra == "full"
 Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
-Requires-Dist: joblib (>=1.2.0,<1.3.0)
 Requires-Dist: jsonpatch (>=1.33,<2.0)
 Requires-Dist: jsonpickle (>=3.0,<3.1)
 Requires-Dist: jsonschema (>=4.20,<4.21)
@@ -103,6 +101,7 @@ Requires-Dist: requests (>=2.31.0,<2.32.0)
 Requires-Dist: rich (>=13.4.2,<14.0.0)
 Requires-Dist: rocketchat_API (>=1.30.0,<1.31.0)
 Requires-Dist: ruamel.yaml (>=0.17.21,<0.17.22)
+Requires-Dist: safetensors (>=0.4.5,<0.5.0)
 Requires-Dist: sanic (>=22.12,<22.13)
 Requires-Dist: sanic-cors (>=2.2.0,<2.3.0)
 Requires-Dist: sanic-jwt (>=1.8.0,<2.0.0)
@@ -113,6 +112,7 @@ Requires-Dist: sentencepiece[sentencepiece] (>=0.1.99,<0.2.0) ; extra == "transf
 Requires-Dist: sentry-sdk (>=1.14.0,<1.15.0)
 Requires-Dist: setuptools (>=70.0.0,<70.1.0)
 Requires-Dist: sklearn-crfsuite (>=0.3.6,<0.4.0)
+Requires-Dist: skops (>=0.10.0,<0.11.0)
 Requires-Dist: slack-sdk (>=3.27.1,<4.0.0)
 Requires-Dist: spacy (>=3.5.4,<4.0.0) ; extra == "spacy" or extra == "full"
 Requires-Dist: structlog (>=23.1.0,<23.2.0)
@@ -383,6 +383,39 @@ To check the types execute
 make types
 ```
 
+### Backporting
+
+In order to port changes to `main` and across release branches, we use the `backport` workflow located at
+the `.github/workflows/backport.yml` path.
+This workflow is triggered by the `backport-to-<release-branch>` label applied to a PR, for example `backport-to-3.8.x`.
+Current available target branches are `main` and maintained release branches.
+
+When a PR gets labelled `backport-to-<release-branch>`, a PR is opened by the `backport-github-action` as soon as the
+source PR gets closed (by merging). If you want to close the PR without merging changes, make sure to remove the `backport-to-<release-branch>` label.
+
+The PR author which the action assigns to the backporting PR has to resolve any conflicts before approving and merging.
+Release PRs should also be labelled with `backport-to-main` to backport the `CHANGELOG.md` updates to `main`.
+Backporting version updates should be accepted to the `main` branch from the latest release branch only.
+
+Here are some guidelines to follow when backporting changes and resolving conflicts:
+
+a) for conflicts in `version.py`: accept only the version from the latest release branch. Do not merge version changes
+from earlier release branches into `main` because this could cause issues when trying to make the next minor release.
+
+b) for conflicts in `pyproject.toml`: if related to the `rasa-pro` version, accept only the latest release branch; 
+if related to other dependencies, accept `main` or whichever is the higher upgrade (main usually has the updated 
+dependencies because we only do housekeeping on `main`, apart from vulnerability updates). Be mindful of dependencies that
+are removed from `main` but still exist in former release branches (for example `langchain`).
+
+c) for conflicts in `poetry.lock`: accept changes which were already present on the target branch, then run
+`poetry lock --no-update` so that the lock file contains your changes from `pyproject.toml` too.
+
+d) for conflicts in `CHANGELOG.md`: Manually place the changelog in their allocated section (e.g. 3.8.10 will go under the 
+3.8 section with the other releases, rather than go at the top of the file)
+
+If the backporting workflow fails, you are encouraged to cherry-pick the commits manually and create a PR to
+the target branch. Alternatively, you can install the backporting CLI tool as described [here](https://github.com/sorenlouv/backport?tab=readme-ov-file#install).
+
 ## Releases
 Rasa has implemented robust policies governing version naming, as well as release pace for major, minor, and patch releases.
 
@@ -465,9 +498,12 @@ Releasing a new version is quite simple, as the packages are build and distribut
 9. If however an error occurs in the build, then we should see a failure message automatically posted in the company's Slack (`dev-tribe` channel) like this [one](https://rasa-hq.slack.com/archives/C01M5TAHDHA/p1701444735622919)
    (In this case do the following checks):
     - Check the workflows in [Github Actions](https://github.com/RasaHQ/rasa-private/actions) and make sure that the merged PR of the current release is completed successfully. To easily find your PR you can use the filters `event: push` and `branch: <version number>` (example on release 2.4 you can see [here](https://github.com/RasaHQ/rasa/actions/runs/643344876))
-    - If the workflow is not completed, then try to re run the workflow in case that solves the problem
+    - If the workflow is not completed, then try to re-run the workflow in case that solves the problem
     - If the problem persists, check also the log files and try to find the root cause of the issue
     - If you still cannot resolve the error, contact the infrastructure team by providing any helpful information from your investigation
+10. If the release is successful, add the newly created release branch to the backporting configuration in the `.backportrc.json` file to
+the `targetBranchesChoices` list. This is necessary for the backporting workflow to work correctly with new release branches.
+
 
 ### Cutting a Patch release