tsbootstrap

https://tsbootstrap.readthedocs.io/en/latest/
Admin
A Python library providing bootstrap methods for time series analysis, including block, residual,...
Tokens:106,892
Snippets:832
Trust Score:9.6
Update:4 months ago
Show doc for...
Tokens:
Raw
### Get Test Parameters for Block Bootstrap

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Returns a list of dictionaries, where each dictionary contains parameter settings for testing the BlockBootstrap estimator. Useful for quick validation or example usage.

```python
@classmethod
def get_test_params(cls):
        """Return testing parameter settings for the estimator."""
        return [{"n_bootstraps": 10, "block_length": 10}]
```

--------------------------------

### Demonstrate Service Architecture in Bootstrap

Source: https://tsbootstrap.readthedocs.io/en/latest/bootstrap.html

Showcase the power of service-based bootstrap architecture. This example illustrates how the service architecture enables flexible, testable, and extensible bootstrap implementations.

```python
tsbootstrap.bootstrap.demonstrate_service_architecture()

```

--------------------------------

### Example Bootstrap Instantiations

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/base_bootstrap.html

Demonstrates instantiating different bootstrap strategies: model-based for parametric time series and block bootstrap for non-parametric inference. Specify parameters like the number of bootstraps, model type, order, or block length as needed.

```python
bootstrap = WholeResidualBootstrap(
    n_bootstraps=1000,
    model_type='ar',
    order=2
)

# Block bootstrap for non-parametric inferenceootstrap = MovingBlockBootstrap(
    n_bootstraps=1000,
    block_length=10  # Optimal for capturing weekly patterns in daily data
)
```

--------------------------------

### Bootstrap Lifecycle Example

Source: https://tsbootstrap.readthedocs.io/en/latest/base_bootstrap.html

Illustrates the general lifecycle of a time series bootstrap process. This pseudo-code shows how data is passed to a concrete bootstrap implementation and samples are generated.

```python
>>> # Pseudo-code showing the bootstrap lifecycle
>>> bootstrap = ConcreteBootstrap(n_bootstraps=1000)
>>> samples = bootstrap.bootstrap(time_series_data)
>>>
>>> # Each sample preserves key statistical properties
>>> original_mean = np.mean(time_series_data)
>>> bootstrap_means = [np.mean(sample) for sample in samples]
```

--------------------------------

### WholeResidualBootstrap Example

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/bootstrap.html

Demonstrates bootstrapping an AR(2) process to estimate parameter uncertainty. It fits an AR(2) model, generates bootstrap samples, and calculates confidence intervals for the AR parameters.

```python
>>> ts = simulate_ar2_process(n=200)
>>> bootstrap = WholeResidualBootstrap(
...     n_bootstraps=1000,
...     model_type='ar',
...     order=2
... )
>>> samples = bootstrap.bootstrap(ts)
>>>
>>> # Estimate parameter confidence intervals
>>> ar_params = [fit_ar2(sample) for sample in samples]
>>> ci_lower, ci_upper = np.percentile(ar_params, [2.5, 97.5], axis=0)
```

--------------------------------

### Summarize Blocks Example

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/markov_sampler.html

Demonstrates summarizing a list of blocks using the 'middle' method. Initializes BlockCompressor and applies it to sample data.

```python
compressor = BlockCompressor(method='middle')
        blocks = [np.array([1, 2, 3]), np.array([4, 5, 6])]
        summarized_blocks = compressor.summarize_blocks(blocks)
        summarized_blocks
```

--------------------------------

### Stationary Block Bootstrap Example

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Illustrates calculating a Sharpe ratio confidence interval for financial returns using StationaryBlockBootstrap. Assumes the availability of stock return data and a Sharpe ratio computation function.

```python
returns = load_stock_returns()
bootstrap = StationaryBlockBootstrap(
    n_bootstraps=5000,
    block_length=20  # Expected block length
)
samples = bootstrap.bootstrap(returns)
# Sharpe ratio CI accounting for serial correlation
sharpe_ratios = [compute_sharpe(s) for s in samples]
ci = np.percentile(sharpe_ratios, [2.5, 97.5])
```

--------------------------------

### Moving Block Bootstrap Example

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Demonstrates confidence interval calculation for autocorrelated data using MovingBlockBootstrap. Requires loading a time series and computing trend confidence intervals.

```python
series = load_temperature_anomalies()  # Daily data with serial correlation
bootstrap = MovingBlockBootstrap(
    n_bootstraps=2000,
    block_length=30  # Monthly blocks for daily data
)
samples = bootstrap.bootstrap(series)
trend_ci = compute_trend_confidence_interval(samples)
```

--------------------------------

### BaseTimeSeriesBootstrap.get_n_bootstraps

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/base_bootstrap.html

Get the number of bootstrap samples configured for the instance.

```APIDOC
## get_n_bootstraps

### Description
Get the number of bootstrap samples.

### Method
`get_n_bootstraps(self) -> int`

### Returns
- `int`: The number of bootstrap samples.
```

--------------------------------

### Initialize Gaussian HMM

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/markov_sampler.html

Initializes a GaussianHMM model with specified parameters. It handles potential ImportError if 'hmmlearn' is not installed and allows for custom initial transition matrices and means.

```python
try:
            from hmmlearn import hmm
        except ImportError as e:
            raise ImportError(
                "The 'hmmlearn' package is required for Hidden Markov Model functionality. "
                "This package provides the Gaussian HMM implementation used for learning "
                "latent states in time series. Install it using: pip install hmmlearn"
            ) from e

hmm_model = hmm.GaussianHMM(
            n_components=n_states,  # type: ignore
            covariance_type="full",
            n_iter=self.n_iter_hmm,  # type: ignore
            init_params="stmc",
            params="stmc",
            random_state=(self.random_seed + idx if self.random_seed is not None else idx),
        )
        if transmat_init is not None:
            hmm_model.transmat_ = transmat_init
        if means_init is not None:
            hmm_model.means_ = means_init

        return hmm_model
```

--------------------------------

### Circular Block Bootstrap Example

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Shows how to estimate seasonal effects with uncertainty using CircularBlockBootstrap for monthly sales data. This method is suitable for time series with clear periodic patterns.

```python
monthly_sales = load_monthly_sales(years=10)  # 120 observations
bootstrap = CircularBlockBootstrap(
    n_bootstraps=1000,
    block_length=12  # Full year blocks
)
samples = bootstrap.bootstrap(monthly_sales)
# Analyze seasonal patterns with proper uncertainty
seasonal_effects = estimate_seasonal_effects(samples)
```

--------------------------------

### Markov Sampler Usage Examples

Source: https://tsbootstrap.readthedocs.io/en/latest/markov_sampler.html

Demonstrates two primary modes of using the MarkovSampler: direct block transition and Hidden Markov Model (HMM) abstraction. The direct mode uses blocks as hidden states, while the HMM mode requires specifying the number of states.

```python
>>> # Direct block transition mode
>>> sampler = MarkovSampler(blocks_as_hidden_states_flag=True)
>>> blocks = [np.random.rand(10, 5) for _ in range(50)]
>>> results = sampler.sample(blocks)
>>>
>>> # HMM abstraction mode
>>> sampler = MarkovSampler(n_iter_hmm=200, n_fits_hmm=20)
>>> results = sampler.sample(blocks, n_states=5)
```

--------------------------------

### BlockLengthSampler Initialization with Pydantic Configuration

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_length_sampler.html

Initializes the BlockLengthSampler with Pydantic's ConfigDict for model configuration, allowing arbitrary types and validating assignments. This setup ensures robust data handling and validation.

```python
model_config = ConfigDict(
    arbitrary_types_allowed=True,
    validate_assignment=True,  # Allows extra attributes like 'test__attr'
)
```

--------------------------------

### Demonstrate Service Architecture

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/bootstrap.html

Illustrates the flexible, testable, and extensible bootstrap implementations using a service-based architecture. Shows standard usage with default services and advanced usage with custom service configuration.

```python
import numpy as np

# Generate sample data
np.random.seed(42)
n = 100
X = np.cumsum(np.random.randn(n)).reshape(-1, 1)

# Standard usage with default services
bootstrap = WholeResidualBootstrap(n_bootstraps=5, model_type="ar", order=2)
samples = bootstrap.bootstrap(X)

# Advanced usage with custom service configuration
# This demonstrates the flexibility of dependency injection
custom_services = BootstrapServices.create_for_model_based_bootstrap()

# Services can be customized for specific needs:
# - Different model fitting algorithms
# - Alternative resampling strategies
# - Custom reconstruction methods
# - Specialized validation rules

bootstrap_custom = WholeResidualBootstrap(
    services=custom_services, n_bootstraps=5, model_type="ar", order=2
)
samples_custom = bootstrap_custom.bootstrap(X)

# The architecture benefits:
# 1. Each service is independently testable
# 2. Services can be mocked for unit testing
# 3. New functionality via service composition
# 4. Clear interfaces and responsibilities
# 5. Performance optimizations per service

return samples, samples_custom
```

--------------------------------

### Get Test Parameters for Estimator

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/markov_sampler.html

Returns a dictionary of parameters for creating testing instances of the estimator. It dynamically includes methods like 'kmedoids' and 'kmedians' if their respective soft dependencies ('scikit-learn-extra', 'pyclustering') are installed.

```python
from tsbootstrap.utils.skbase_compat import (
    safe_check_soft_dependencies as _check_soft_dependencies,
)

methods = [
    "first",
    "middle",
    "last",
    "mean",
    "mode",
    "median",
    "kmeans",
]
if _check_soft_dependencies("scikit-learn-extra", severity="none"):
    methods.append("kmedoids")
if _check_soft_dependencies("pyclustering", severity="none"):
    methods.append("kmedians")

return [{"method": method} for method in methods]
```

--------------------------------

### Calculate Block Start Index

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_generator.html

Determines the starting index for a block, returning a random integer if wrap-around is enabled, otherwise returning 0.

```python
def _calculate_start_index(self) -> int:
    """
    Calculate the starting index of a block.

    Returns
    -------
    int
        The starting index of the block.
    """
    if self.wrap_around_flag:
        return self.rng.integers(self.input_length)  # type: ignore
    else:
        return 0
```

--------------------------------

### Calculate Next Start Index for Blocks

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_generator.html

Calculates the starting index for the next block, considering overlap. This is useful for sequential block generation in time series data.

```python
def _calculate_next_start_index(
        self,
        start_index: int,
        block_length: int,
        overlap_length: int,
    ) -> int:
        """
        Calculate the next start index for generating the subsequent block.

        Parameters
        ----------
        start_index : int
            The start index of the current block.
        block_length : int
            The length of the current block.
        overlap_length : int
            The overlap length between the current and next block.

        Returns
        -------
        int
            The start index for the next block.
        """
        next_start_index = start_index + block_length - overlap_length
        next_start_index = next_start_index % self.input_length
        return next_start_index
```

--------------------------------

### BaseBootstrap Initialization

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/base_bootstrap.html

Illustrates the initialization of the BaseBootstrap class, including dependency injection of services and handling of the random number generator.

```python
def __init__(self, services: Optional[BootstrapServices] = None, **data: Any) -> None:
    """
    Initialize with dependency injection of services.

    Parameters
    ----------
    services : BootstrapServices, optional
        Service container. If None, creates default services.
    **data : Any
        Field values for the model
    """
    # Store original rng value BEFORE any conversion
    original_rng = data.get("rng")

    # Convert rng to Generator if needed
    if (
        "rng" in data
        and data["rng"] is not None
        and not isinstance(data["rng"], np.random.Generator)
    ):
        data["rng"] = np.random.default_rng(data["rng"])

    # Initialize Pydantic model
    super().__init__(**data)

    # IMPORTANT: Also initialize BaseObject to set up _tags_dynamic
    # This is needed for skbase compatibility
    from skbase.base import BaseObject

    BaseObject.__init__(self)

    # NOW set the private attribute after super().__init__
    self._rng_init_val = original_rng

    # Store services for lazy initialization
    self._services_instance = services
    self._services_initialized = False

    # Initialize random number generator if needed
    if self.rng is None:
        self.rng = np.random.default_rng()
```

--------------------------------

### Generate Overlapping Block Indices

Source: https://tsbootstrap.readthedocs.io/en/latest/block_generator.html

Generates indices for overlapping blocks in a time series. The block indices are created by sampling a starting index and block length, then iteratively updating the starting index.

```python
generate_overlapping_blocks()
```

--------------------------------

### BlockSieveBootstrap Initialization

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/bootstrap.html

Initializes the BlockSieveBootstrap with optional custom services or creates default sieve bootstrap services. Demonstrates how to configure the use of backend services.

```python
def __init__(self, services: Optional[BootstrapServices] = None, **data):
    """Initialize with sieve bootstrap services."""
    if services is None:
        # Extract use_backend from data if provided, otherwise use the field default
        use_backend = data.get("use_backend", True)  # Match the field default
        services = BootstrapServices.create_for_sieve_bootstrap(use_backend=use_backend)

    super().__init__(services=services, **data)
```

--------------------------------

### get_params

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/base_bootstrap.html

Get parameters for this estimator. This method is compatible with scikit-learn estimators.

```APIDOC
## get_params

### Description
Get parameters for this estimator. This method is compatible with scikit-learn estimators.

### Method
GET

### Endpoint
Not applicable (Python method)

### Parameters
#### Query Parameters
- **deep** (bool) - Optional - If True, will return the parameters for this estimator and contained subobjects.

### Response
#### Success Response (200)
- **params** (dict[str, Any]) - A dictionary containing the estimator's parameters.

### Response Example
```json
{
  "param1": "value1",
  "param2": 123
}
```
```

--------------------------------

### rng

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/time_series_simulator.html

Get or set the random number generator instance for the simulator.

```APIDOC
## rng

### Description
Get or set the random number generator instance used for simulations.

### Method
GET / rng
SET / rng

### Parameters
#### Setter Parameters
- **rng** (Optional[Union[Integral, Generator]]) - Required - Random number generator instance or seed.
```

--------------------------------

### Get Testing Parameters

Source: https://tsbootstrap.readthedocs.io/en/latest/base_bootstrap.html

Returns a dictionary of parameters suitable for testing the estimator. This is a class method.

```python
classmethod get_test_params()
```

--------------------------------

### Initialize and Resample Blocks

Source: https://tsbootstrap.readthedocs.io/en/latest/block_resampler.html

Demonstrates how to initialize a BlockResampler with data and blocks, and then resample them. Verifies that the number of new blocks matches the original data length.

```python
>>> block_resampler = BlockResampler(blocks=blocks, X=data)
>>> new_blocks, new_tapered_weights = block_resampler.resample_blocks()
>>> len(new_blocks) == len(data)
True
```

--------------------------------

### BlockResampler Initialization and Resampling

Source: https://tsbootstrap.readthedocs.io/en/latest/block_resampler.html

Demonstrates how to initialize the BlockResampler with blocks and data, and then resample the blocks to obtain new block structures and tapered weights.

```APIDOC
## BlockResampler

### Description
Initializes the BlockResampler with a list of blocks and input data. The `resample_blocks` method processes these to return new block structures and associated tapered weights.

### Method
__init__(blocks: list[np.ndarray], X: np.ndarray)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **blocks** (list[np.ndarray]) - Required - The list of block indices.
* **X** (np.ndarray) - Required - The input data array.

### Request Example
```python
block_resampler = BlockResampler(blocks=blocks, X=data)
```

### Response
#### Success Response (200)
* **new_blocks** (list[np.ndarray]) - A list of new block structures.
* **new_tapered_weights** (list[np.ndarray]) - A list of tapered weights for the new blocks.

#### Response Example
```python
new_blocks, new_tapered_weights = block_resampler.resample_blocks()
```

## resample_blocks

### Description
Resamples the blocks based on the initialized data and blocks. It returns the processed block structures and their corresponding tapered weights.

### Method
resample_blocks() -> Tuple[List[np.ndarray], List[np.ndarray]]

### Parameters
None

### Request Example
```python
new_blocks, new_tapered_weights = block_resampler.resample_blocks()
```

### Response
#### Success Response (200)
* **new_blocks** (list[np.ndarray]) - A list of 1D NumPy arrays representing the new block structures.
* **new_tapered_weights** (list[np.ndarray]) - A list of 1D NumPy arrays containing the tapered weights for each corresponding block.

#### Response Example
```python
len(new_blocks) == len(data)
```
```

--------------------------------

### Get Estimator Parameters

Source: https://tsbootstrap.readthedocs.io/en/latest/base_bootstrap.html

Retrieves the parameters of the estimator. Useful for inspection or saving estimator configurations.

```python
get_params(deep: bool = True) -> dict[str, Any]
```

--------------------------------

### Get Test Parameters for Estimator

Source: https://tsbootstrap.readthedocs.io/en/latest/bootstrap.html

Returns testing parameter settings for an estimator. This is useful for setting up reproducible tests.

```python
_classmethod _get_test_params()[source]
    
Return testing parameter settings for the estimator. 

model_config _: ClassVar[ConfigDict]__ = {'arbitrary_types_allowed': True, 'defer_build': True, 'extra': 'allow', 'protected_namespaces': (), 'use_enum_values': True, 'validate_assignment': True, 'validate_default': False}_
```

--------------------------------

### Initialize Bootstrap Services

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/bootstrap.html

Initializes the Bootstrap class with optional services. If services are not provided, they are created based on the 'use_backend' parameter, defaulting to True. The residual resampler's RNG is updated if available.

```python
def __init__(self, services: Optional[BootstrapServices] = None, **data):
        """Initialize with model-based services."""
        # Create appropriate services if not provided
        if services is None:
            # Extract use_backend from data if provided, otherwise use the field default
            use_backend = data.get("use_backend", True)  # Match the field default
            services = BootstrapServices.create_for_model_based_bootstrap(use_backend=use_backend)

        super().__init__(services=services, **data)

        # Update residual resampler with our RNG
        if self._services.residual_resampler:
            self._services.residual_resampler.rng = self.rng
```

--------------------------------

### Get Bootstrap Type

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/base_bootstrap.html

Retrieves the bootstrap type from the model's tags. If the 'bootstrap_type' tag is not found, it defaults to 'unknown'.

```python
return self._tags.get("bootstrap_type", "unknown")
```

--------------------------------

### Initialize Sieve Bootstrap Services

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/bootstrap.html

Initializes the WholeSieveBootstrap class. If no services are provided, it creates default BootstrapServices for sieve bootstrapping, optionally using a backend.

```python
    def __init__(self, services: Optional[BootstrapServices] = None, **data):
        """Initialize with sieve bootstrap services."""
        if services is None:
            # Extract use_backend from data if provided, otherwise use the field default
            use_backend = data.get("use_backend", True)  # Match the field default
            services = BootstrapServices.create_for_sieve_bootstrap(use_backend=use_backend)

        super().__init__(services=services, **data)
```

--------------------------------

### Get Number of Bootstraps

Source: https://tsbootstrap.readthedocs.io/en/latest/base_bootstrap.html

Retrieves the configured number of bootstrap samples for the instance. Call this to check how many samples will be generated.

```python
get_n_bootstraps() -> int
```

--------------------------------

### Tukey Bootstrap Initialization with Adaptive Tapering

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Initializes a Tukey Bootstrap with adaptive tapering based on the series' correlation structure. The alpha parameter controls the degree of tapering.

```python
>>> series = load_complex_series()
>>> # Estimate optimal alpha from ACF
>>> alpha_opt = estimate_tukey_alpha(series)
>>> bootstrap = TukeyBootstrap(
...     n_bootstraps=2000,
...     block_length=40,
...     alpha=alpha_opt
... )
```

--------------------------------

### Initialize WindowedBlockBootstrap

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Initializes the WindowedBlockBootstrap with a window service. The `tapered_weights` are set via a property.

```python
def __init__(self, services: Optional[BootstrapServices] = None, **data):
    """Initialize with window service."""
    super().__init__(services=services, **data)

    # Create window service
    self._window_service = WindowFunctionService()
    # Don't set tapered_weights here - use property instead
```

--------------------------------

### Get Test Parameters for Abstract Class

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/bootstrap.html

Returns an empty list for testing parameters as this is an abstract class and cannot be instantiated directly.

```python
@classmethod
def get_test_params(cls):
        """Return testing parameter settings for the estimator."""
        # Abstract class - return empty list
        return []
```

--------------------------------

### Registering Default Distributions

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_length_sampler.html

Registers all predefined probability distributions with the DistributionRegistry. This setup is necessary before using the BlockLengthSampler with specific distributions.

```python
DistributionRegistry.register_distribution(DistributionTypes.POISSON, sample_poisson)
DistributionRegistry.register_distribution(DistributionTypes.EXPONENTIAL, sample_exponential)
DistributionRegistry.register_distribution(DistributionTypes.NORMAL, sample_normal)
DistributionRegistry.register_distribution(DistributionTypes.GAMMA, sample_gamma)
DistributionRegistry.register_distribution(DistributionTypes.BETA, sample_beta)
DistributionRegistry.register_distribution(DistributionTypes.LOGNORMAL, sample_lognormal)
DistributionRegistry.register_distribution(DistributionTypes.WEIBULL, sample_weibull)
DistributionRegistry.register_distribution(DistributionTypes.PARETO, sample_pareto)
DistributionRegistry.register_distribution(DistributionTypes.GEOMETRIC, sample_geometric)
DistributionRegistry.register_distribution(DistributionTypes.UNIFORM, sample_uniform)
DistributionRegistry.register_distribution(DistributionTypes.NONE, sample_none)
```

--------------------------------

### Instantiate and Use BlockResampler

Source: https://tsbootstrap.readthedocs.io/en/latest/block_resampler.html

Demonstrates how to instantiate the BlockResampler with pre-defined blocks and data, and then generate resampled block indices and data. Asserts that the total length of the resampled blocks matches the original data length.

```python
>>> block_resampler = BlockResampler(blocks=blocks, X=data)
>>> block_indices, block_data = block_resampler.resample_block_indices_and_data()
>>> total_length = sum(len(block) for block in block_indices)
>>> assert total_length == len(data)
```

--------------------------------

### Get Tapered Weights Function

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Retrieves the tapered weights function for the current window type, creating it if it's not already cached.

```python
@property
def tapered_weights(self) -> Optional[Callable]:
    """Get tapered weights function for current window type."""
    if self._tapered_weights_cache is None and self._window_service is not None:
        self._tapered_weights_cache = self._create_tapered_weights()
    return self._tapered_weights_cache
```

--------------------------------

### Calculating Transition Probabilities with MarkovTransitionMatrixCalculator

Source: https://tsbootstrap.readthedocs.io/en/latest/markov_sampler.html

Illustrates how to calculate the transition probability matrix using the MarkovTransitionMatrixCalculator. This involves initializing the calculator and providing a list of data blocks.

```python
>>> calculator = MarkovTransitionMatrixCalculator()
>>> blocks = [np.random.rand(10, 5) for _ in range(50)]
>>> transition_matrix = calculator.calculate_transition_probabilities(blocks)
```

--------------------------------

### Get Bootstrap Test Parameters

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/bootstrap.html

This class method returns a dictionary of parameters for testing the Bootstrap estimator. It specifies the number of bootstraps to use.

```python
@classmethod
    def get_test_params(cls):
        """Return testing parameter settings for the estimator."""
        return [{"n_bootstraps": 10}]
```

--------------------------------

### Get Test Parameters for Estimator

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/bootstrap.html

Returns a list of dictionaries, each containing parameter settings for testing the estimator. This is useful for automated testing and validation.

```python
    @classmethod
    def get_test_params(cls):
        """Return testing parameter settings for the estimator."""
        return [{"n_bootstraps": 10}]
```

--------------------------------

### MarkovSampler Initialization with PCA

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/markov_sampler.html

Initialize the MarkovSampler, enabling Principal Component Analysis (PCA) for dimensionality reduction of blocks. An optional pre-configured PCA instance can be provided.

```python
sampler = MarkovSampler(method="middle", apply_pca_flag=True, pca=sklearn.decomposition.PCA(n_components=1))

```

--------------------------------

### Get Parameters (Excluding Non-Cloneable)

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Retrieves the parameters of the estimator, excluding fields that cannot be cloned, such as callable block weights. This is useful for serialization or deep copying.

```python
def get_params(self, deep=True):
        """Get parameters, excluding non-cloneable fields."""
        params = super().get_params(deep=deep)
        # Remove callable fields that can't be cloned
        if "block_weights" in params and callable(params.get("block_weights")):
            params.pop("block_weights", None)
        return params
```

--------------------------------

### Block Residual Bootstrap for GARCH-type Effects

Source: https://tsbootstrap.readthedocs.io/en/latest/bootstrap.html

Example of using BlockResidualBootstrap to handle volatility clusters in financial returns. The block_length is set to preserve these patterns.

```python
>>> returns = load_stock_returns()
>>> bootstrap = BlockResidualBootstrap(
...     n_bootstraps=1000,
...     model_type='ar',
...     order=1,
...     block_length=20  # Preserve volatility clusters
... )
>>> samples = bootstrap.bootstrap(returns)
>>>
>>> # Compute VaR with proper uncertainty quantification
>>> var_estimates = [compute_var(sample, alpha=0.05) for sample in samples]
```

--------------------------------

### Initialize Bartletts Bootstrap

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Use for smooth spectral estimation. Requires specifying the number of bootstrap samples and the block length.

```python
bootstrap = BartlettsBootstrap(n_bootstraps=1000, block_length=20)
```

--------------------------------

### Block Bootstrap Initialization

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Initializes the BlockBootstrap class with optional services and data. It creates instances of BlockGenerationService and BlockResamplingService.

```python
def __init__(self, services: Optional[BootstrapServices] = None, **data):
        """Initialize with block bootstrap services."""
        super().__init__(services=services, **data)

        # Create block services
        self._block_gen_service = BlockGenerationService()
        self._block_resample_service = BlockResamplingService()
```

--------------------------------

### Initialize WholeSieveBootstrap for Unknown Order

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/bootstrap.html

Use this when the order of the time series model is unknown. It allows the data to determine the appropriate lag range for the model.

```python
bootstrap = WholeSieveBootstrap(n_bootstraps=1000, min_lag=1, max_lag=10)
```

--------------------------------

### Time Series Bootstrap Strategies

Source: https://tsbootstrap.readthedocs.io/en/latest/base_bootstrap.html

Demonstrates the instantiation of different bootstrap strategies for time series analysis. Use WholeResidualBootstrap for parametric models and MovingBlockBootstrap for non-parametric inference.

```python
>>> # Model-based bootstrap for parametric time series
>>> bootstrap = WholeResidualBootstrap(
...     n_bootstraps=1000,
...     model_type='ar',
...     order=2
... )
>>>
>>> # Block bootstrap for non-parametric inference
>>> bootstrap = MovingBlockBootstrap(
...     n_bootstraps=1000,
...     block_length=10  # Optimal for capturing weekly patterns in daily data
... )
```

--------------------------------

### Override setattr for skbase Compatibility

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_length_sampler.html

Overrides the setattr method to allow setting test attributes, supporting skbase compatibility. This enables setting arbitrary attributes that start with 'test_'.

```python
def __setattr__(self, name: str, value) -> None:
        """
        Override setattr to allow test attributes for skbase compatibility.

        This allows setting arbitrary attributes that start with 'test_' to support

```

--------------------------------

### Block-Based Bootstrap Initialization

Source: https://tsbootstrap.readthedocs.io/en/latest/base_bootstrap.html

Initializes a block-based bootstrap method that preserves local temporal structure by resampling contiguous data chunks. Suitable for time series with complex dependencies.

```python
class BlockBasedBootstrap(services: BootstrapServices | None = None, *, n_bootstraps: Annotated[int, Ge(ge=1)] = 10, rng: Generator | None = None, **data: Any)
```

--------------------------------

### Get Estimator Parameters

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/base_bootstrap.html

Retrieves the parameters of the estimator. It handles fallback to simple attribute extraction if no scikit-learn adapter is available. Restores the original RNG value for scikit-learn compatibility.

```python
def get_params(self, deep: bool = True) -> dict[str, Any]:
    """Get parameters for this estimator."""
    if self._services.sklearn_adapter is None:
        # Fallback to simple param extraction
        params = {
            k: getattr(self, k) for k in self.__class__.model_fields if not k.startswith("_")
        }
    else:
        params = self._services.sklearn_adapter.get_params(deep=deep)
    # Restore original rng value for sklearn
    if "rng" in params and self._rng_init_val is not None:
        params["rng"] = self._rng_init_val
    return params
```

--------------------------------

### Initialize BartlettsBootstrap

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Initializes the BartlettsBootstrap with specific default settings for the Bartlett window, including wrap-around and overlap flags.

```python
def __init__(self, services: Optional[BootstrapServices] = None, **data):
    """Initialize with Bartlett window."""
    data["window_type"] = "bartletts"
    data.setdefault("wrap_around_flag", False)
    data.setdefault("overlap_flag", True)

    super().__init__(services=services, **data)
```

--------------------------------

### Initialize TimeSeriesModel (Old API)

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/time_series_model.html

Use this constructor when providing data directly during initialization for backward compatibility. The model type and order can be specified.

```python
>>> # Old API (backward compatibility)
>>> time_series_model = TimeSeriesModel(X=data, model_type="ar")
>>> results = time_series_model.fit()
```

--------------------------------

### Initialize BlackmanBootstrap

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Initializes the BlackmanBootstrap, setting the window type to 'blackman' and configuring default flags for wrap-around and overlap.

```python
def __init__(self, services: Optional[BootstrapServices] = None, **data):
    """Initialize with Blackman window."""
    data["window_type"] = "blackman"
    data.setdefault("wrap_around_flag", False)
    data.setdefault("overlap_flag", True)

    super().__init__(services=services, **data)
```

--------------------------------

### Initialize BlockLengthSampler with default settings

Source: https://tsbootstrap.readthedocs.io/en/latest/block_length_sampler.html

Instantiate the BlockLengthSampler with default average block length and no specific distribution. This results in fixed-length blocks equal to the default average.

```python
from tsbootstrap.block_length_sampler import BlockLengthSampler

sampler = BlockLengthSampler()
print(sampler.avg_block_length)
```

--------------------------------

### generate_overlapping_blocks

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_generator.html

Generates block indices for overlapping blocks in a time series. It iteratively creates blocks, adjusting start indices and lengths while considering overlap, until the time series is fully covered or a loop is detected.

```APIDOC
## generate_overlapping_blocks

### Description
Generates block indices for overlapping blocks in a time series. This method samples block lengths and calculates overlap to create blocks that may share elements, continuing until the time series is covered or a repeating pattern is detected.

### Returns
- list[np.ndarray]: A list of numpy arrays, where each array represents the indices of a block in the time series.

### Notes
The block indices are generated as follows:

1. A starting index is sampled from a uniform distribution over the time series.
2. A block length is sampled from the block length sampler.
3. An overlap length is calculated from the block length.
4. A block is created from the starting index and block length.
5. The starting index is updated to the next starting index.
6. Steps 2-5 are repeated until the total length covered is equal to the length of the time series.

The block length sampler is used to sample the block length. The overlap length is calculated from the block length. The starting index is updated to the next starting index by adding the block length and subtracting the overlap length. The starting index is then wrapped around if the wrap-around flag is set to True.
```

--------------------------------

### Initialize TimeSeriesModel (New API)

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/time_series_model.html

Use this constructor for scikit-learn compatibility, passing data to the fit method. Specify the model type and order.

```python
>>> # New sklearn-compatible API
>>> time_series_model = TimeSeriesModel(model_type="ar", order=2)
>>> results = time_series_model.fit(X)
```

--------------------------------

### WindowedBlockBootstrap

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Foundation for tapered block methods with smooth transitions. This class provides the framework for various window functions, each with different trade-offs between bias reduction and variance.

```APIDOC
## WindowedBlockBootstrap

### Description
Foundation for tapered block methods with smooth transitions. A sophisticated enhancement to block bootstrapping that addresses the "hard boundary" problem by applying tapering functions that smoothly down-weight observations near block edges.

### Class
WindowedBlockBootstrap

### Attributes
- **window_type** (str) - Default: "hanning" - Type of window function.

### Methods
#### `__init__(self, services: Optional[BootstrapServices] = None, **data)`
Initialize with window service.

#### `tapered_weights` (property)
Get tapered weights function for current window type.

#### `get_test_params(cls)`
Return testing parameter settings for the estimator. Abstract base for windowed methods - return empty.
```

--------------------------------

### Bypass Pydantic Validation for Test Attributes

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_length_sampler.html

This snippet demonstrates how to bypass Pydantic validation for attributes starting with 'test_' during object initialization. It uses `object.__setattr__` for test-related attributes and `super().__setattr__` for others, ensuring that Pydantic's validation is only applied when necessary.

```python
if name.startswith("test_"):\n            # For test attributes, bypass Pydantic validation\n            object.__setattr__(self, name, value)\n        else:\n            # Use Pydantic's normal setattr\n            super().__setattr__(name, value)
```

--------------------------------

### Initialize BlockLengthSampler

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_length_sampler.html

Initializes the BlockLengthSampler, ensuring proper initialization of parent classes. Accepts keyword arguments for configuration.

```python
def __init__(self, **data):
        """
        Initialize the BlockLengthSampler, ensuring proper initialization of parent classes.

        Parameters
        ----------
        **data : dict
            Keyword arguments for initializing the class.
        """
        super().__init__(**data)
        BaseObject.__init__(self)
```

--------------------------------

### Generate Sieve Bootstrap Sample

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/time_series_simulator.html

Generates a bootstrap sample using the sieve bootstrap method. It supports AR models by simulating the AR process or falls back to simulating non-AR processes.

```python
from typing import Optional, Union, List, Integral

validate_literal_type(model_type, ModelTypes)
if model_type == "ar":
    self._validate_ar_simulation_params(
        {
            "resids_lags": resids_lags,
            "resids_coefs": resids_coefs,
            "resids": resids,
        }
    )
    return self.simulate_ar_process(resids_lags, resids_coefs, resids, n_samples)  # type: ignore
else:
    return self.simulate_non_ar_process(n_samples)
```

--------------------------------

### Initialize RankLags and Estimate Conservative Lag

Source: https://tsbootstrap.readthedocs.io/en/latest/ranklags.html

Demonstrates how to initialize the RankLags class with sample data and obtain a conservative lag estimate using the `estimate_conservative_lag` method. This is useful for a quick, robust lag selection.

```python
from tsbootstrap import RankLags
import numpy as np
# Generate AR(2) process for demonstration
np.random.seed(42)
X = np.random.normal(size=(100, 1))
rank_obj = RankLags(X, model_type='ar')

# Get conservative lag estimate
rank_obj.estimate_conservative_lag()
```

--------------------------------

### Lazy Initialization of Services

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/base_bootstrap.html

Provides a property to lazily initialize the BootstrapServices if they haven't been set up yet.

```python
@property
def _services(self) -> BootstrapServices:
    """Lazy initialization of services."""
    if not self._services_initialized:
        if self._services_instance is None:
            self._services_instance = BootstrapServices()

```

--------------------------------

### HammingBootstrap

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Initializes a Hamming Bootstrap object. This method uses a Hamming window for tapering, which is effective for frequency domain analysis and reducing edge artifacts. It defaults to wrap-around disabled and overlap enabled.

```APIDOC
## HammingBootstrap

### Description
Initializes a Hamming Bootstrap object using a Hamming window for tapering. This method is particularly effective for frequency domain analysis and reducing edge artifacts. It defaults to `wrap_around_flag=False` and `overlap_flag=True`.

### Method
__init__

### Parameters
- **services** (Optional[BootstrapServices]) - Optional services object.
- **
**data** (**kwargs) - Additional data for initialization, including `n_bootstraps` and `block_length`.

### Request Example
```python
bootstrap = HammingBootstrap(
    n_bootstraps=500,
    block_length=256  # FFT-friendly size
)
```

### Response
Initializes the HammingBootstrap object.
```

--------------------------------

### Markov Model Parameter Comparison

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/markov_sampler.html

Illustrates how to compare key parameters of Markov models for equality. This is useful for testing and ensuring model consistency. Requires NumPy for float array comparisons.

```python
# self.model.startprob_ == other.model.startprob_
# self.model.transmat_ == other.model.transmat_
# self.model.means_ == other.model.means_
# self.model.covars_ == other.model.covars_
# This requires np.allclose for float arrays.
# For simplicity now, we'll skip deep model parameter comparison.
# Add more detailed checks if necessary for test correctness.
```

--------------------------------

### Initialize BlockLengthSampler with Pareto distribution

Source: https://tsbootstrap.readthedocs.io/en/latest/block_length_sampler.html

Create a BlockLengthSampler instance configured to use a Pareto distribution. This is suitable for capturing long-range dependencies in the time series data.

```python
from tsbootstrap.block_length_sampler import BlockLengthSampler
from tsbootstrap.utils.types import DistributionTypes

sampler = BlockLengthSampler(avg_block_length=10, block_length_distribution=DistributionTypes.PARETO)
print(sampler.block_length_distribution)
```

--------------------------------

### Initialize Moving Block Bootstrap

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Use for general time series with unknown dependence structure. Requires specifying the number of bootstrap samples and the block length.

```python
bootstrap = MovingBlockBootstrap(n_bootstraps=1000, block_length=30)
```

--------------------------------

### Sample a block length from the configured distribution

Source: https://tsbootstrap.readthedocs.io/en/latest/block_length_sampler.html

Generate a single block length using the sampler's currently configured distribution and average block length. The output will vary based on the distribution and RNG.

```python
from tsbootstrap.block_length_sampler import BlockLengthSampler
from tsbootstrap.utils.types import DistributionTypes

sampler = BlockLengthSampler(avg_block_length=5, block_length_distribution=DistributionTypes.GEOMETRIC)

# Sample a block length
block_length = sampler.sample_block_length()
print(f"Sampled block length: {block_length}")
```

--------------------------------

### Initialize WholeResidualBootstrap for AR(2) Process

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/bootstrap.html

Use this when the time series follows a known Autoregressive (AR) process of a specific order. It initializes the bootstrap with a specified number of bootstraps and model order.

```python
bootstrap = WholeResidualBootstrap(n_bootstraps=1000, model_type='ar', order=2)
```

--------------------------------

### BlackmanBootstrap

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/block_bootstrap.html

Blackman Bootstrap using composition. Uses Blackman window for tapering.

```APIDOC
## BlackmanBootstrap

### Description
Blackman Bootstrap using composition. Uses Blackman window for tapering.

### Class
BlackmanBootstrap

### Methods
#### `__init__(self, services: Optional[BootstrapServices] = None, **data)`
Initialize with Blackman window. Sets `window_type` to "blackman", `wrap_around_flag` to False, and `overlap_flag` to True by default.

#### `get_test_params(cls)`
Return testing parameter settings for the estimator.
```

--------------------------------

### BlackmanBootstrap

Source: https://tsbootstrap.readthedocs.io/en/latest/block_bootstrap.html

Blackman Bootstrap using composition. Uses Blackman window for tapering.

```APIDOC
## BlackmanBootstrap

### Description
Blackman Bootstrap using composition. Uses Blackman window for tapering.

### Method
Instantiate the BlackmanBootstrap class.

### Parameters
- **n_bootstraps** (int) - Optional - The number of bootstrap replicates to generate. Defaults to 10.
- **block_length** (int) - Optional - The length of the blocks to be resampled. Defaults to 10.
- **overlap_flag** (bool) - Optional - Whether blocks can overlap. Defaults to False.
- **rng** (Generator) - Optional - A random number generator for reproducibility.

### Request Example
```python
bootstrap = BlackmanBootstrap(n_bootstraps=1000, block_length=20)
```

### Response
An instance of the BlackmanBootstrap class.
```

--------------------------------

### Initialize RankLags and Estimate Conservative Lag

Source: https://tsbootstrap.readthedocs.io/en/latest/_modules/tsbootstrap/ranklags.html

Demonstrates initializing RankLags with an AR(2) process and estimating a conservative lag order. This is useful for automatically determining a suitable model order.

```python
from tsbootstrap import RankLags
import numpy as np

# Generate AR(2) process for demonstration
np.random.seed(42)
X = np.random.normal(size=(100, 1))
rank_obj = RankLags(X, model_type='ar')

# Get conservative lag estimate
rank_obj.estimate_conservative_lag()
```
Tokens:
Raw