bootstrapped_input_data¶

def __iter__(self):
    """Resets the iterator and returns itself."""
    self._current_index = 0
    return self

def __next__(self) -> tuple[np.ndarray, np.ndarray]:
    """
    Provides the next bootstrap sample for iteration.

    :return: Tuple of (sample_indices, sample_weights).
    :raises StopIteration: When all bootstrap samples are exhausted.

    """
    if self._current_index >= self.n_bootstraps:
        raise StopIteration

    sample_indices, sample_weights = self.get_bootstrap_sample(self._current_index)

    self._current_index += 1
    return sample_indices, sample_weights

@classmethod
def deserialize(cls, filename: str):
    """
    Loads the object from a JSON file.

    :param filename: Path to the BootstrapModelingData JSON file.

    """
    with open(filename) as f:
        data = json.load(f)

    response_df = pd.DataFrame(**data["response_df"]).rename_axis(
        index=data["index_name"]
    )
    model_df = pd.DataFrame(**data["model_df"]).rename_axis(
        index=data["index_name"]
    )
    n_bootstraps = data["n_bootstraps"]

    normalize_sample_weights = data["normalize_sample_weights"]

    random_state = data["random_state"]

    instance = cls(
        response_df,
        model_df,
        n_bootstraps,
        normalize_sample_weights=normalize_sample_weights,
        random_state=random_state,
    )

    return instance

def get_bootstrap_sample(self, i: int) -> tuple[np.ndarray, np.ndarray]:
    """
    Retrieves a bootstrap sample by index.

    :param i: Bootstrap sample index.
    :return: Tuple of (sample_indices, sample_weights).
    :raises IndexError: If the index exceeds the number of bootstraps.

    """
    if i >= self.n_bootstraps or i < 0:
        raise IndexError(
            f"Bootstrap index {i} out of range. Max: {self.n_bootstraps - 1}"
        )

    sampled_indices = self.bootstrap_indices[i]
    sample_weights = self.get_sample_weight(i)

    return (
        sampled_indices,
        sample_weights,
    )

def get_sample_weight(self, i: int) -> np.ndarray:
    """
    Retrieves sample weights for a bootstrap sample.

    :param i: Bootstrap sample index.
    :return: Array of sample weights.

    """
    if i >= self.n_bootstraps or i < 0:
        raise IndexError(f"Sample weight index {i} out of range.")
    return self.sample_weights[i]

def regenerate(self) -> None:
    """
    Re-generate, randomly, bootstrap samples and sample weights.

    This should be called if the response or predictors change.

    """
    self._generate_bootstrap_indices()

def save_indices(self, filename: str) -> None:
    """
    Saves only the bootstrap indices to a JSON file.

    Saves the bootstrap indices to a JSON file. This can be used to persist the
    bootstrap indices for later use, allowing for reproducibility in analyses.

    :param filename: Path to the JSON file where the bootstrap indices will be
        saved. This will overwrite the file if it exists.

    """
    data = {
        "n_bootstraps": self.n_bootstraps,
        "bootstrap_indices": [
            indices.tolist() for indices in self._bootstrap_indices
        ],
    }
    with open(filename, "w") as f:
        json.dump(data, f)

def serialize(self, filename: str) -> None:
    """
    Saves the object as a JSON file.

    Serializes the current state of the BootstrappedModelingInputData object to a
    JSON file, including the response and model DataFrames, number of bootstraps,
    bootstrap indices, and sample weights.

    :param filename: Path to the JSON file where the object will be saved.
    :raises ValueError: If the filename is not a valid path or if the object cannot
        be serialized. This method will overwrite the file if it exists.

    """
    data = {
        "response_df": self.response_df.to_dict(orient="split"),
        "index_name": self.response_df.index.name,
        "model_df": self.model_df.to_dict(orient="split"),
        "n_bootstraps": self.n_bootstraps,
        "normalize_sample_weights": self.normalize_sample_weights,
        "random_state": self.random_state,
    }

    with open(filename, "w") as f:
        json.dump(data, f)