Documentation for Neural NARX¶

def check_dimension(x, y):
    """Check if x and y have only real values.

    If there is any string or object samples a ValueError is raised.

    Parameters
    ----------
    x : ndarray of floats
        The input data.
    y : ndarray of floats
        The output data.

    """
    if x.ndim == 0:
        raise ValueError(
            "Input must be a 2d array, got scalar instead. Reshape your data using"
            " array.reshape(-1, 1)"
        )

    if x.ndim == 1:
        raise ValueError(
            "Input must be a 2d array, got 1d array instead. "
            "Reshape your data using array.reshape(-1, 1)"
        )

    if y.ndim == 0:
        raise ValueError(
            "Output must be a 2d array, got scalar instead. "
            "Reshape your data using array.reshape(-1, 1)"
        )

    if y.ndim == 1:
        raise ValueError(
            "Output must be a 2d array, got 1d array instead. "
            "Reshape your data using array.reshape(-1, 1)"
        )

def check_infinity(x, y):
    """Check that x and y have no NaN or Inf samples.

    If there is any NaN or Inf samples a ValueError is raised.

    Parameters
    ----------
    x : ndarray of floats
        The input data.
    y : ndarray of floats
        The output data.

    """
    if np.isinf(x).any():
        msg_error = (
            "Input contains invalid values (e.g. NaN, Inf) on "
            f"index {np.argwhere(np.isinf(x))}"
        )
        raise ValueError(msg_error)

    if np.isinf(y).any():
        msg_error = (
            "Output contains invalid values (e.g Inf) on "
            f"index {np.argwhere(np.isinf(y))}"
        )
        raise ValueError(msg_error)

def check_length(x, y):
    """Check that x and y have the same number of samples.

    If the length of x and y are different a ValueError is raised.

    Parameters
    ----------
    x : ndarray of floats
        The input data.
    y : ndarray of floats
        The output data.

    """
    if x.shape[0] != y.shape[0]:
        msg_error = (
            "Input and output data must have the same number of "
            f"samples. x has dimension {x.shape} and "
            f"y has dimension {y.shape}"
        )
        raise ValueError(msg_error)

def check_linear_dependence_rows(psi):
    """Check for linear dependence in the rows of the Psi matrix.

    Parameters
    ----------
    psi : ndarray of floats
        The information matrix of the model.

    Warns
    -----
    UserWarning
        If the Psi matrix has linearly dependent rows.
    """
    if np.linalg.matrix_rank(psi) != psi.shape[1]:
        warn(
            "Psi matrix might have linearly dependent rows."
            "Be careful and check your data",
            stacklevel=2,
        )

def check_nan(x, y):
    """Check that x and y have no NaN or Inf samples.

    If there is any NaN or Inf samples a ValueError is raised.

    Parameters
    ----------
    x : ndarray of floats
        The input data.
    y : ndarray of floats
        The output data.

    """
    if np.isnan(x).any():
        msg_error = (
            "Input contains invalid values (e.g. NaN, Inf) on "
            f"index {np.argwhere(np.isnan(x))}"
        )
        raise ValueError(msg_error)

    if not ~np.isnan(y).any():
        msg_error = (
            "Output contains invalid values (e.g. NaN, Inf) on "
            f"index {np.argwhere(np.isnan(y))}"
        )
        raise ValueError(msg_error)

def check_random_state(seed):
    """Turn `seed` into a `np.random.RandomState` instance.

    Parameters
    ----------
    seed : {None, int, `numpy.random.Generator`,
            `numpy.random.RandomState`}, optional
        If `seed` is None (or `np.random`), the `numpy.random.RandomState`
        singleton is used.
        If `seed` is an int, a new ``RandomState`` instance is used,
        seeded with `seed`.
        If `seed` is already a ``Generator`` or ``RandomState`` instance then
        that instance is used.

    Returns
    -------
    seed : {`numpy.random.Generator`, `numpy.random.RandomState`}
        Random number generator.

    """
    if seed is None or seed is np.random:
        return np.random.mtrand._rand
    if isinstance(seed, (numbers.Integral, np.integer)):
        return np.random.default_rng(seed)
    if isinstance(seed, (np.random.RandomState, np.random.Generator)):
        return seed

    raise ValueError(
        "%r cannot be used to seed a numpy.random.RandomState instance" % seed
    )

def check_x_y(x, y):
    """Validate input and output data using some crucial tests.

    Parameters
    ----------
    x : ndarray of floats
        The input data.
    y : ndarray of floats
        The output data.

    """
    check_length(x, y)
    check_dimension(x, y)
    check_infinity(x, y)
    check_nan(x, y)

def deprecated(version, future_version=None, message=None, alternative=None, **kwargs):
    """Decorate deprecated methods.

    This decorator is adapted from astroML decorator:
    https://github.com/astroML/astroML/blob/f66558232f6d33cb34ecd1bed8a80b9db7ae1c30/astroML/utils/decorators.py#L120

    """

    def deprecate_function(
        func,
        version=version,
        future_version=future_version,
        message=message,
        alternative=alternative,
    ):
        if message is None:
            message = f"Function {func.__name__} has been deprecated since {version}."
            if alternative is not None:
                message += (
                    f"\n You'll have to use {alternative} instead."
                    "This module was deprecated in favor of "
                    f"{alternative} module into which all the refactored "
                    "classes and functions are moved."
                )
            if future_version is not None:
                message += (
                    f"\n This change will be applied in version {future_version}."
                )

        @functools.wraps(func)
        def deprecated_func(*args, **kwargs):
            warnings.warn(message, FutureWarning, stacklevel=1)
            return func(*args, **kwargs)

        return deprecated_func

    def deprecate_class(
        cls,
        version=version,
        future_version=future_version,
        message=message,
        alternative=alternative,
    ):
        if message is None:
            message = f"Class {cls.__name__} has been deprecated since {version}."
            if alternative is not None:
                message += alternative
            if future_version is not None:
                message += (
                    f"\n This change will be applied in version {future_version}."
                )

        cls.__init__ = deprecate_function(cls.__init__, message=message)

        return cls

    def deprecate_warning(obj):
        if isinstance(obj, type):
            return deprecate_class(obj)

        return deprecate_function(obj)

    return deprecate_warning

def results(
    final_model=None,
    theta=None,
    err=None,
    n_terms=None,
    theta_precision=4,
    err_precision=8,
    dtype="dec",
):
    """Return the model regressors, parameters and ERR values.

    Generates a formatted string matrix containing model regressors,
    their corresponding parameters, and error reduction ratio (ERR) values.

    This function constructs a structured output where each row represents
    a model regressor, its estimated parameter, and the associated ERR value.
    The numerical values can be displayed in either decimal or scientific notation.

    Parameters
    ----------
    final_model : array-like, optional
        The identified model structure, where each row corresponds to
        a regressor represented by numerical codes.

    theta : array-like, optional
        A column vector containing the estimated parameters for each regressor.

    err : array-like, optional
        A vector containing the error reduction ratio (ERR) values for each regressor.

    n_terms : int, optional
        Number of terms (regressors) in the model.

    theta_precision : int, default=4
        Number of decimal places for displaying parameter values.

    err_precision : int, default=8
        Number of decimal places for displaying ERR values.

    dtype : {'dec', 'sci'}, default='dec'
        Format for displaying numerical values:
        - 'dec' : Decimal notation.
        - 'sci' : Scientific notation.

    Returns
    -------
    output_matrix : list of lists
        A structured matrix where:
        - The first column contains regressor representations as strings.
        - The second column contains the corresponding estimated parameter values.
        - The third column contains the associated ERR values.

    Raises
    ------
    ValueError
        If `theta_precision` or `err_precision` is not a positive integer.
        If `dtype` is not 'dec' or 'sci'.

    """
    if not isinstance(theta_precision, int) or theta_precision < 1:
        raise ValueError(
            f"theta_precision must be integer and > zero. Got {theta_precision}."
        )

    if not isinstance(err_precision, int) or err_precision < 1:
        raise ValueError(
            f"err_precision must be integer and > zero. Got {err_precision}."
        )

    if dtype not in ("dec", "sci"):
        raise ValueError(f"dtype must be dec or sci. Got {dtype}.")

    output_matrix = []
    theta_output_format = "{:." + str(theta_precision)
    err_output_format = "{:." + str(err_precision)

    if dtype == "dec":
        theta_output_format = theta_output_format + "f}"
        err_output_format = err_output_format + "f}"
    else:
        theta_output_format = theta_output_format + "E}"
        err_output_format = err_output_format + "E}"

    for i in range(n_terms):
        if np.max(final_model[i]) < 1:
            tmp_regressor = str(1)
        else:
            regressor_dic = Counter(final_model[i])
            regressor_string = []
            for j in range(len(list(regressor_dic.keys()))):
                regressor_key = list(regressor_dic.keys())[j]
                if regressor_key < 1:
                    translated_key = ""
                    translated_exponent = ""
                else:
                    delay_string = str(
                        int(regressor_key - np.floor(regressor_key / 1000) * 1000)
                    )
                    if int(regressor_key / 1000) < 2:
                        translated_key = "y(k-" + delay_string + ")"
                    else:
                        translated_key = (
                            "x"
                            + str(int(regressor_key / 1000) - 1)
                            + "(k-"
                            + delay_string
                            + ")"
                        )
                    if regressor_dic[regressor_key] < 2:
                        translated_exponent = ""
                    else:
                        translated_exponent = "^" + str(regressor_dic[regressor_key])
                regressor_string.append(translated_key + translated_exponent)
            tmp_regressor = "".join(regressor_string)

        current_parameter = theta_output_format.format(theta[i, 0])
        current_err = err_output_format.format(err[i])
        current_output = [tmp_regressor, current_parameter, current_err]
        output_matrix.append(current_output)

    return output_matrix

def get_miso_data(n=5000, colored_noise=False, sigma=0.05, train_percentage=90):
    """Generate synthetic data for Multiple-Input Single-Output system identification.

    This function simulates input-output data for a nonlinear MISO system using two
    input signals. The system output is influenced by both inputs and can be affected
    by either white or colored (autoregressive) noise based on the `colored_noise` flag.

    Parameters
    ----------
    n : int, optional (default=5000)
        Number of samples to generate.
    colored_noise : bool, optional (default=False)
        If True, adds colored (autoregressive) noise to the system; otherwise, white
        noise is used.
    sigma : float, optional (default=0.05)
        Standard deviation of the noise distribution.
    train_percentage : int, optional (default=90)
        Percentage of the dataset allocated for training. The remainder is used
        for validation.

    Returns
    -------
    x_train : ndarray
        Input data matrix (features) for system identification (training).
    x_valid : ndarray
        Input data matrix (features) for system validation (testing).
    y_train : ndarray
        Output data corresponding to `x_train`.
    y_valid : ndarray
        Output data corresponding to `x_valid`.

    Notes
    -----
    - The system follows the nonlinear difference equation:

      y[k] = 0.4 * y[k-1]² + 0.1 * y[k-1] * x1[k-1] + 0.6 * x2[k-1]
             - 0.3 * x1[k-1] * x2[k-2] + e[k]

      where `e[k]` is either white or colored noise.

    - The inputs `x1` and `x2` are independently sampled from a uniform distribution in
      the range [-1, 1].
    - The dataset is split into training and validation sets based on `train_percentage`
      , ensuring a clear separation between them.
    - The function returns `x_train` and `x_valid` as stacked arrays, where each row
      represents a sample and each column corresponds to an input variable
      (`x1` or `x2`).

    """
    if train_percentage < 0 or train_percentage > 100:
        raise ValueError("train_percentage must be smaller than 100")

    mu = 0  # mean of the distribution
    nu = np.random.normal(mu, sigma, n).T
    e = np.zeros((n, 1))

    lag = 2
    if colored_noise is True:
        for k in range(lag, len(e)):
            e[k] = 0.8 * nu[k - 1] + nu[k]
    else:
        e = nu

    x1 = np.random.uniform(-1, 1, n).T
    x2 = np.random.uniform(-1, 1, n).T
    y = np.zeros((n, 1))
    theta = np.array([[0.4], [0.1], [0.6], [-0.3]])

    lag = 2
    for k in range(lag, len(e)):
        y[k] = (
            theta[0] * y[k - 1] ** 2
            + theta[1] * y[k - 1] * x1[k - 1]
            + theta[2] * x2[k - 1]
            + theta[3] * x1[k - 1] * x2[k - 2]
            + e[k]
        )

    split_data = int(len(x1) * (train_percentage / 100))
    x1_train = x1[0:split_data].reshape(-1, 1)
    x2_train = x2[0:split_data].reshape(-1, 1)
    x1_valid = x1[split_data::].reshape(-1, 1)
    x2_valid = x2[split_data::].reshape(-1, 1)

    x_train = np.hstack([x1_train, x2_train])
    x_valid = np.hstack([x1_valid, x2_valid])

    y_train = y[0:split_data].reshape(-1, 1)
    y_valid = y[split_data::].reshape(-1, 1)

    return x_train, x_valid, y_train, y_valid

def get_siso_data(n=5000, colored_noise=False, sigma=0.05, train_percentage=90):
    r"""Generate synthetic data for Single-Input Single-Output system identification.

    This function simulates input-output data for a SISO system based on a predefined
    nonlinear difference equation. The system output is affected by either white noise
    or colored noise (autoregressive noise) depending on the `colored_noise` flag.

    Parameters
    ----------
    n : int, optional (default=5000)
        Number of samples to generate.
    colored_noise : bool, optional (default=False)
        If True, adds colored (autoregressive) noise to the system; otherwise, white
        noise is used.
    sigma : float, optional (default=0.05)
        Standard deviation of the noise distribution.
    train_percentage : int, optional (default=90)
        Percentage of the dataset allocated for training. The rest is used for
        validation.

    Returns
    -------
    x_train : ndarray
        Input data for system identification (training).
    x_valid : ndarray
        Input data for system validation (testing).
    y_train : ndarray
        Output data corresponding to `x_train`.
    y_valid : ndarray
        Output data corresponding to `x_valid`.

    Notes
    -----
    - The system follows the nonlinear difference equation:

      y[k] = 0.2 * y[k-1] + 0.1 * y[k-1] * x[k-1] + 0.9 * x[k-2] + e[k]

      where `e[k]` is either white or colored noise.

    - The input `x` is uniformly sampled from the range [-1, 1].
    - The dataset is split based on `train_percentage`, ensuring a clear separation
      between training and validation data.

    """
    if train_percentage < 0 or train_percentage > 100:
        raise ValueError("train_percentage must be smaller than 100")

    mu = 0  # mean of the distribution
    nu = np.random.normal(mu, sigma, n).T
    e = np.zeros((n, 1))

    lag = 2
    if colored_noise is True:
        for k in range(lag, len(e)):
            e[k] = 0.8 * nu[k - 1] + nu[k]
    else:
        e = nu

    x = np.random.uniform(-1, 1, n).T
    y = np.zeros((n, 1))
    theta = np.array([[0.2], [0.1], [0.9]])
    lag = 2
    for k in range(lag, len(x)):
        y[k] = (
            theta[0] * y[k - 1]
            + theta[1] * y[k - 1] * x[k - 1]
            + theta[2] * x[k - 2]
            + e[k]
        )

    split_data = int(len(x) * (train_percentage / 100))

    x_train = x[0:split_data].reshape(-1, 1)
    x_valid = x[split_data::].reshape(-1, 1)

    y_train = y[0:split_data].reshape(-1, 1)
    y_valid = y[split_data::].reshape(-1, 1)

    return x_train, x_valid, y_train, y_valid

def build_input_matrix(x, xlag: np.ndarray) -> np.ndarray:
    """Build the information matrix of input values.

    Each column of the information matrix represents a candidate
    regressor. The set of candidate regressors are based on xlag,
    ylag, and degree entered by the user.

    Parameters
    ----------
    x : array-like
        Input data used during the training phase.
    xlag : int, list of int, or nested list of int
        Input that can be a single integer, a list, or a nested list.

    Returns
    -------
    data = ndarray of floats
        The lagged matrix built in respect with each lag and column.

    """
    # Generate a lagged data which each column is a input or output
    # related to its respective lags. With this approach we can create
    # the information matrix by using all possible combination of
    # the columns as a product in the iterations

    n_inputs, xlag = _process_xlag(x, xlag)
    x_lagged = _create_lagged_x(x, n_inputs, xlag)
    constant = np.ones([x_lagged.shape[0], 1])
    data = np.concatenate([constant, x_lagged], axis=1)
    return data

def build_input_output_matrix(x: np.ndarray, y: np.ndarray, xlag, ylag) -> np.ndarray:
    """Build the information matrix.

    Each column of the information matrix represents a candidate
    regressor. The set of candidate regressors are based on xlag,
    ylag, and degree entered by the user.

    Parameters
    ----------
    x : array-like
        Input data used on training phase.
    y : array-like
        Target data used on training phase.
    xlag : int, list of int, or nested list of int
        Input that can be a single integer, a list, or a nested list.
    ylag : int or list of int
        The range of lags according to user definition.

    Returns
    -------
    data = ndarray of floats
        The constructed information matrix.

    """
    # Generate a lagged data which each column is a input or output
    # related to its respective lags. With this approach we can create
    # the information matrix by using all possible combination of
    # the columns as a product in the iterations
    lagged_data = initial_lagged_matrix(x, y, xlag, ylag)
    constant = np.ones([lagged_data.shape[0], 1])
    data = np.concatenate([constant, lagged_data], axis=1)
    return data

def build_output_matrix(y, ylag: np.ndarray) -> np.ndarray:
    """Build the information matrix of output values.

    Each column of the information matrix represents a candidate
    regressor. The set of candidate regressors are based on xlag,
    ylag, and degree entered by the user.

    Parameters
    ----------
    y : array-like
        Output data used during the training phase.
    ylag : int or list of int
        The range of lags according to user definition.

    Returns
    -------
    data = ndarray of floats
        The constructed output regressor matrix.

    """
    # Generate a lagged data which each column is an input or output
    # related to its respective lags. With this approach we can create
    # the information matrix by using all possible combination of
    # the columns as a product in the iterations
    ylag = _process_ylag(ylag)
    y_lagged = _create_lagged_y(y, ylag)
    constant = np.ones([y_lagged.shape[0], 1])
    data = np.concatenate([constant, y_lagged], axis=1)
    return data

def count_model_regressors(
    *,
    x: np.ndarray,
    y: np.ndarray,
    xlag: int,
    ylag: int,
    model_type: str,
    basis_function,
    is_neural_narx: bool = False,
) -> int:
    """
    Compute the number of model regressors after applying the basis function.

    Parameters
    ----------
    x : np.ndarray
        Input data.
    y : np.ndarray
        Output data.
    xlag : int
        Number of lags for input variables.
    ylag : int
        Number of lags for output variables.
    model_type : str
        The type of model ('NARMAX', 'NAR', 'NFIR', etc.).
    basis_function : object
        The basis function used for feature transformation.
    is_neural_narx : bool, optional
        Whether to adjust for a neural NARX model, by default False.

    Returns
    -------
    int
        The number of regressors/features after transformation.
    """
    data = build_lagged_matrix(x, y, xlag, ylag, model_type)
    n_features = basis_function.fit(data[:3, :]).shape[1]
    if is_neural_narx:
        return n_features - 1

    return n_features

def get_build_io_method(model_type):
    """Get info criteria method.

    Parameters
    ----------
    model_type = str
        The type of the model (NARMAX, NAR or NFIR)

    Returns
    -------
    build_method = Self
        Method to build the input-output matrix
    """
    build_matrix_options = {
        "NARMAX": build_input_output_matrix,
        "NFIR": build_input_matrix,
        "NAR": build_output_matrix,
    }
    return build_matrix_options.get(model_type, None)

def initial_lagged_matrix(x: np.ndarray, y: np.ndarray, xlag, ylag) -> np.ndarray:
    """Construct a matrix with lagged versions of input and output variables.

    Parameters
    ----------
    x : array-like
        Input data used during the training phase.
    y : array-like
        Output data used during the training phase.
    xlag : int, list of int, or nested list of int
        Input that can be a single integer, a list, or a nested list.
    ylag : int or list of int
        The range of lags according to user definition.

    Returns
    -------
    lagged_data : ndarray
        The combined matrix containing lagged input and output values.

    Examples
    --------
    If `xlag=2` and `ylag=2`, the resulting matrix will contain columns:
    Y[k-1], Y[k-2], x[k-1], x[k-2].

    """
    n_inputs, xlag = _process_xlag(x, xlag)
    ylag = _process_ylag(ylag)
    x_lagged = _create_lagged_x(x, n_inputs, xlag)
    y_lagged = _create_lagged_y(y, ylag)
    lagged_data = np.concatenate([y_lagged, x_lagged], axis=1)
    return lagged_data

def shift_column(col_to_shift: np.ndarray, lag: int) -> np.ndarray:
    """Shift an array by a specified lag, introducing zeros for missing values.

    Parameters
    ----------
    col_to_shift : array-like of shape (n_samples,)
        The input or output time-series data to be lagged.
    lag : int
        The number of time steps to shift the data.

    Returns
    -------
    tmp_column : ndarray of shape (n_samples, 1)
        The shifted array, where the first `lag` values are replaced with zeros.

    Examples
    --------
    >>> y = np.array([1, 2, 3, 4, 5])
    >>> shift_column(y, 1)
    array([[0],
           [1],
           [2],
           [3],
           [4]])

    """
    n_samples = col_to_shift.shape[0]
    tmp_column = np.zeros((n_samples, 1))
    aux = col_to_shift[0 : n_samples - lag].reshape(-1, 1)
    tmp_column[lag:, 0] = aux[:, 0]
    return tmp_column

def get_lag_from_regressor_code(regressors):
    """Get the maximum lag from array of regressors.

    Parameters
    ----------
    regressors : ndarray of int
        Flattened list of input or output regressors.

    Returns
    -------
    max_lag : int
        Maximum lag of list of regressors.

    """
    lag_list = [int(i) for i in regressors.astype("str") for i in [np.sum(int(i[2:]))]]
    if len(lag_list) != 0:
        return max(lag_list)

    return 1

def get_max_lag_from_model_code(model_code: List[int]) -> int:
    """Create a flattened array of input regressors.

    Parameters
    ----------
    model_code : ndarray of int
        Model defined by the user to simulate.

    Returns
    -------
    max_lag : int
        Maximum lag of list of regressors.

    """
    xlag_code = list_input_regressor_code(model_code)
    ylag_code = list_output_regressor_code(model_code)
    xlag = get_lag_from_regressor_code(xlag_code)
    ylag = get_lag_from_regressor_code(ylag_code)
    return max(xlag, ylag)

def get_max_xlag(xlag: int = 1):
    """Get maximum value from various xlag structures.

    Parameters
    ----------
    xlag : int, list of int, or nested list of int
        Input that can be a single integer, a list, or a nested list.

    Returns
    -------
    int
        Maximum value found.
    """
    if isinstance(xlag, int):  # Case 1: Single integer
        return xlag

    if isinstance(xlag, list):
        # Case 2: Flat list of integers
        if all(isinstance(i, int) for i in xlag):
            return max(xlag)
        # Case 3: Nested list
        return max(chain.from_iterable(xlag))

    raise ValueError("Unsupported data type for xlag")

def get_max_ylag(ylag: int = 1):
    """Get maximum ylag.

    Parameters
    ----------
    ylag : ndarray of int
        The range of lags according to user definition.

    Returns
    -------
    ny : list
        Maximum value of ylag.

    """
    ny = np.max(list(chain.from_iterable([[ylag]])))
    return ny

@deprecated(
    version="v0.6.0",
    future_version="v1.0.0",
    message=(
        " `regressor_code` is deprecated in v0.6.0 and will be removed in v1.0.0."
        " Use the `count_model_regressors` from sysidentpy.utils instead."
    ),
)
def regressor_code(
    *,
    X: Optional[np.ndarray] = None,
    xlag: int = 2,
    ylag: int = 2,
    model_type: str = "NARMAX",
    model_representation: Optional[str] = None,
    basis_function: Polynomial = Polynomial(),
) -> np.ndarray:
    """Generate a regressor code based on the provided parameters.

    Parameters
    ----------
    X : np.ndarray, optional
        The input feature matrix.
    xlag : int, optional
        The number of lags for the input features.
    ylag : int, optional
        The number of lags for the target variable.
    model_type : str, optional
        The type of model to be used. Default is "NARMAX".
    model_representation : str, optional
        The model representation to be used.
    basis_function : object, optional
        The basis function object used to transform the regressor space.

    Returns
    -------
    encoding : np.ndarray
        The generated regressor encoding.
    """
    if X is not None:
        n_inputs = num_features(X)
    else:
        n_inputs = 1  # only used to create the regressor space base

    encoding = RegressorDictionary(
        xlag=xlag, ylag=ylag, model_type=model_type, basis_function=basis_function
    ).regressor_space(n_inputs)

    if not isinstance(basis_function, Polynomial) and basis_function.ensemble:
        repetition = basis_function.n * 2
        basis_code = np.sort(
            np.tile(encoding[1:, :], (repetition, 1)),
            axis=0,
        )
        encoding = np.concatenate([encoding[1:], basis_code])
    elif (
        not isinstance(basis_function, Polynomial) and basis_function.ensemble is False
    ):
        repetition = basis_function.n * 2
        encoding = np.sort(
            np.tile(encoding[1:, :], (repetition, 1)),
            axis=0,
        )

    if (
        isinstance(basis_function, Polynomial)
        and model_representation == "neural_network"
    ):
        return encoding[1:]
    if isinstance(basis_function, Polynomial) and model_representation is None:
        return encoding

    return encoding