<a id="skfolio-prior-syntheticdata"></a>

# skfolio.prior.SyntheticData

<a id="skfolio.prior.SyntheticData"></a>

### *class* skfolio.prior.SyntheticData(distribution_estimator=None, n_samples=1000, sample_args=None)

Synthetic Data Estimator.

The Synthetic Data model estimates a [`ReturnDistribution`](https://skfolio.org/generated/skfolio.prior.ReturnDistribution.html.md#skfolio.prior.ReturnDistribution) by
fitting a `distribution_estimator` and sampling new returns data from it.

The default `distribution_estimator` is a Regular Vine Copula model. Other common
choices are Generative Adversarial Networks (GANs) or Variational Autoencoders
(VAEs).

This class is particularly useful when the historical distribution tail dependencies
are sparse and need extrapolation for tail optimizations or when optimizing under
conditional or stressed scenarios.

* **Parameters:**
  **distribution_estimator** *BaseEstimator, optional*
  : Estimator to model the distribution of asset returns. It must inherit from
    `BaseEstimator` and implements a `sample` method. If None, the default
    `VineCopula()` model is used.

  **n_samples** *int, default=1000*
  : Number of samples to generate from the `distribution_estimator`, default is
    1000.

  **sample_args** *dict, optional*
  : Additional keyword arguments to pass to the `sample` method of the
    `distribution_estimator`.
* **Attributes:**
  **return_distribution_** *ReturnDistribution*
  : Fitted [`ReturnDistribution`](https://skfolio.org/generated/skfolio.prior.ReturnDistribution.html.md#skfolio.prior.ReturnDistribution) to be used by the optimization
    estimators, containing the assets syntehtic data distribution and moments
    estimation.

  **distribution_estimator_** *BaseEstimator*
  : The fitted distribution estimator.

  **n_features_in_** *int*
  : Number of assets seen during `fit`.

  **feature_names_in_** *ndarray of shape (`n_features_in_`,)*
  : Names of features seen during `fit`. Defined only when `X`
    has feature names that are all strings.

### Methods

| [`fit`](#skfolio.prior.SyntheticData.fit)(X[, y])            | Fit the Synthetic Data estimator.     |
|-------------------------------------------------------------------------|---------------------------------------|
| [`get_metadata_routing`](#skfolio.prior.SyntheticData.get_metadata_routing)() | Get metadata routing of this object.  |
| [`get_params`](#skfolio.prior.SyntheticData.get_params)([deep])     | Get parameters for this estimator.    |
| [`set_params`](#skfolio.prior.SyntheticData.set_params)(\*\*params) | Set the parameters of this estimator. |

### Examples

```pycon
>>> import numpy as np
>>> from skfolio.datasets import load_sp500_dataset, load_factors_dataset
>>> from skfolio.preprocessing import prices_to_returns
>>> from skfolio.distribution import VineCopula
>>> from skfolio.optimization import MeanRisk
>>> from skfolio.prior import TimeSeriesFactorModel, SyntheticData
>>> from skfolio import RiskMeasure
>>>
>>> # Load historical prices and convert them to returns
>>> prices = load_sp500_dataset()
>>> factor_prices = load_factors_dataset()
>>> X, factors = prices_to_returns(prices, factor_prices)
>>>
>>> # Instantiate the SyntheticData model and fit it
>>> model = SyntheticData()
>>> model.fit(X)
SyntheticData()
>>> print(model.return_distribution_)
ReturnDistribution(...)
>>>
>>> # Minimum CVaR optimization on synthetic returns
>>> model = MeanRisk(
...    risk_measure=RiskMeasure.CVAR,
...    prior_estimator=SyntheticData(
...        distribution_estimator=VineCopula(
...            log_transform=True, n_jobs=-1, random_state=0
...        ),
...        n_samples=2000,
...    )
... )
>>> model.fit(X)
MeanRisk(...)
>>> print(model.weights_)
[0.0021 0.     0.     ... 0.     0.1559 0.0641]
>>>
>>> # Minimum CVaR optimization on Stressed Factors
>>> factor_model = TimeSeriesFactorModel(
...    factor_prior_estimator=SyntheticData(
...        distribution_estimator=VineCopula(
...            central_assets=["QUAL"],
...            log_transform=True,
...            n_jobs=-1,
...            random_state=0,
...        ),
...        n_samples=5000,
...        sample_args=dict(conditioning={"QUAL": -0.2}),
...    )
... )
>>> model = MeanRisk(risk_measure=RiskMeasure.CVAR, prior_estimator=factor_model)
>>> model.fit(X, factors=factors)
MeanRisk(...)
>>> print(model.weights_)
[0.     0.     0.     ... 0.0616 0.     0.9384 0.    ]
>>>
>>> # Stress Test the Portfolio
>>> factor_model.set_params(factor_prior_estimator__sample_args=dict(
...     conditioning={"QUAL": -0.5}
... ))
TimeSeriesFactorModel(...)
>>> factor_model.fit(X, factors=factors)
TimeSeriesFactorModel(...)
>>> stressed_dist = factor_model.return_distribution_
>>> stressed_ptf = model.predict(stressed_dist)
```

<a id="skfolio.prior.SyntheticData.fit"></a>

#### fit(X, y=None, \*\*fit_params)

Fit the Synthetic Data estimator.

* **Parameters:**
  **X** *array-like of shape (n_observations, n_assets)*
  : Price returns of the assets.

  **y** *Ignored*
  : Not used, present for API consistency by convention.

  **\*\*fit_params** *dict*
  : Parameters to pass to the underlying estimators.
    Only available if `enable_metadata_routing=True`, which can be
    set by using `sklearn.set_config(enable_metadata_routing=True)`.
    See [Metadata Routing User Guide](https://skfolio.org/user_guide/metadata_routing.html.md#metadata-routing) for
    more details.
* **Returns:**
  **self** *SyntheticData*
  : Fitted estimator.

<a id="skfolio.prior.SyntheticData.get_metadata_routing"></a>

#### get_metadata_routing()

Get metadata routing of this object.

Please check [User Guide](https://skfolio.org/user_guide/metadata_routing.html.md#metadata-routing) on how the routing
mechanism works.

* **Returns:**
  **routing** *MetadataRequest*
  : A `MetadataRequest` encapsulating
    routing information.

<a id="skfolio.prior.SyntheticData.get_params"></a>

#### get_params(deep=True)

Get parameters for this estimator.

* **Parameters:**
  **deep** *bool, default=True*
  : If True, will return the parameters for this estimator and
    contained subobjects that are estimators.
* **Returns:**
  **params** *dict*
  : Parameter names mapped to their values.

<a id="skfolio.prior.SyntheticData.set_params"></a>

#### set_params(\*\*params)

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects
(such as `Pipeline`). The latter have
parameters of the form `<component>__<parameter>` so that it’s
possible to update each component of a nested object.

* **Parameters:**
  **\*\*params** *dict*
  : Estimator parameters.
* **Returns:**
  **self** *estimator instance*
  : Estimator instance.