Skip to content

Linear weights

timecave.validation_methods.weights.linear_weights(n_splits, gap=0, compensation=0, params={'slope': 2})

Compute linear weights.

This function computes a linear weight vector. It may be passed to the Growing Window, Rolling Window, and Block CV classes.

Parameters:

Name Type Description Default
n_splits int

Number of splits the validation method will use.

 required
gap int

Number of folds separating the validation set from the training set. Used by prequential methods.

 0
compensation int

A compensation factor that allows the function to generate the correct amount of weights. 0 for CV methods, +1 for prequential methods. Additionally, if a gap is specified, it must be added to this compensation factor as well.

 0
params dict

Parameters from which to generate the weights. Only slope needs to be specified. Any other parameter will be ignored.

 None

Returns:

Type Description
ndarray

Weights.

Raises:

Type Description
TypeError

If slope is neither an integer nor a float.
ValueError

If slope is not positive.

Examples:

>>> from timecave.validation_methods.weights import linear_weights
>>> linear_weights(5);
array([0.06666667, 0.13333333, 0.2       , 0.26666667, 0.33333333])

If a gap is specified, there will be fewer iterations. Therefore, fewer weights should be generated:

>>> linear_weights(5, gap=1);
array([0.1, 0.2, 0.3, 0.4])

For a given number of folds, CV methods will run for an additional iteration compared to prequential methods. Therefore, a compensation factor of 1 must be specified if one intends to use weighted prequential methods:

>>> linear_weights(5, gap=1, compensation=1);
array([0.16666667, 0.33333333, 0.5       ])
Source code in timecave/validation_methods/weights.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
def linear_weights(
    n_splits: int, gap: int = 0, compensation: int = 0, params: dict = {"slope": 2}
) -> np.ndarray:
    """
    Compute linear weights.

    This function computes a linear weight vector. It may be passed to the [Growing Window](../prequential/grow.md), 
    [Rolling Window](../prequential/roll.md), and [Block CV](../CV/block.md) classes.

    Parameters
    ----------
    n_splits : int
        Number of splits the validation method will use.

    gap : int, default=0
        Number of folds separating the validation set from the training set. \
        Used by [prequential methods](../prequential/index.md).

    compensation : int, default=0
        A compensation factor that allows the function to generate the correct amount of weights. \
        0 for [CV methods](../CV/index.md), +1 for [prequential methods](../prequential/index.md). \
        Additionally, if a gap is specified, it must be added to this compensation factor as well.

    params : dict, default=None
        Parameters from which to generate the weights. Only `slope` needs to be specified. 
        Any other parameter will be ignored.

    Returns
    -------
    np.ndarray
        Weights.

    Raises
    ------
    TypeError
        If `slope` is neither an integer nor a float.

    ValueError
        If `slope` is not positive.

    Examples
    --------
    >>> from timecave.validation_methods.weights import linear_weights
    >>> linear_weights(5);
    array([0.06666667, 0.13333333, 0.2       , 0.26666667, 0.33333333])

    If a gap is specified, there will be fewer iterations. Therefore, fewer weights should be generated:

    >>> linear_weights(5, gap=1);
    array([0.1, 0.2, 0.3, 0.4])

    For a given number of folds, CV methods will run for an additional iteration compared to prequential 
    methods. Therefore, a compensation factor of 1 must be specified if one intends to use weighted prequential 
    methods:

    >>> linear_weights(5, gap=1, compensation=1);
    array([0.16666667, 0.33333333, 0.5       ])
    """

    _check_params(params["slope"])
    splits = n_splits - gap - compensation
    weights = np.array([params["slope"] * i for i in range(1, splits + 1)])
    weights = weights / weights.sum()

    return weights