Skip to content

Bases: BaseSynthesizer

Source code in /opt/hostedtoolcache/Python/3.10.13/x64/lib/python3.10/site-packages/ydata/sdk/synthesizers/timeseries.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
class TimeSeriesSynthesizer(BaseSynthesizer):

    def sample(self, n_entities: int, condition_on: Optional[dict] = None) -> pdDataFrame:
        """Sample from a [`TimeSeriesSynthesizer`][ydata.sdk.synthesizers.TimeSeriesSynthesizer] instance.

        If a training dataset was not using any `entity` column, the Synthesizer assumes a single entity.
        A [`TimeSeriesSynthesizer`][ydata.sdk.synthesizers.TimeSeriesSynthesizer] always sample the full trajectory of its entities.

        Arguments:
            n_entities (int): number of entities to sample
            condition_on: (Optional[dict]): (optional) conditional sampling parameters

        Returns:
            synthetic data
        """
        if n_entities is not None and n_entities < 1:
            raise InputError("Parameter 'n_entities' must be greater than 0")

        payload = {"numberOfRecords": n_entities}
        if condition_on is not None:
            payload["extraData"] = {
                "condition_on": condition_on
            }
        return self._sample(payload=payload)

    def fit(self, X: Union[DataSource, pdDataFrame],
            sortbykey: Optional[Union[str, List[str]]],
            privacy_level: PrivacyLevel = PrivacyLevel.HIGH_FIDELITY,
            entities: Optional[Union[str, List[str]]] = None,
            generate_cols: Optional[List[str]] = None,
            exclude_cols: Optional[List[str]] = None,
            dtypes: Optional[Dict[str, Union[str, DataType]]] = None,
            target: Optional[str] = None,
            name: Optional[str] = None,
            anonymize: Optional[dict] = None,
            condition_on: Optional[List[str]] = None) -> None:
        """Fit the synthesizer.

        The synthesizer accepts as training dataset either a pandas [`DataFrame`][pandas.DataFrame] directly or a YData [`DataSource`][ydata.sdk.datasources.DataSource].

        Arguments:
            X (Union[DataSource, pandas.DataFrame]): Training dataset
            sortbykey (Union[str, List[str]]): column(s) to use to sort timeseries datasets
            privacy_level (PrivacyLevel): Synthesizer privacy level (defaults to high fidelity)
            entities (Union[str, List[str]]): (optional) columns representing entities ID
            generate_cols (List[str]): (optional) columns that should be synthesized
            exclude_cols (List[str]): (optional) columns that should not be synthesized
            dtypes (Dict[str, Union[str, DataType]]): (optional) datatype mapping that will overwrite the datasource metadata column datatypes
            target (Optional[str]): (optional) Metadata associated to the datasource
            name (Optional[str]): (optional) Synthesizer instance name
            anonymize (Optional[str]): (optional) fields to anonymize and the anonymization strategy
            condition_on: (Optional[List[str]]): (optional) list of features to condition upon
        """
        BaseSynthesizer.fit(self, X=X, datatype=DataSourceType.TIMESERIES, sortbykey=sortbykey,
                            entities=entities, generate_cols=generate_cols, exclude_cols=exclude_cols,
                            dtypes=dtypes, target=target, name=name, anonymize=anonymize, privacy_level=privacy_level,
                            condition_on=condition_on)

    def __repr__(self):
        if self._model is not None:
            return self._model.__repr__()
        else:
            return "TimeSeriesSynthesizer(Not Initialized)"

fit(X, sortbykey, privacy_level=PrivacyLevel.HIGH_FIDELITY, entities=None, generate_cols=None, exclude_cols=None, dtypes=None, target=None, name=None, anonymize=None, condition_on=None)

Fit the synthesizer.

The synthesizer accepts as training dataset either a pandas DataFrame directly or a YData DataSource.

Parameters:

Name Type Description Default
X Union[DataSource, DataFrame]

Training dataset

 required
sortbykey Union[str, List[str]]

column(s) to use to sort timeseries datasets

 required
privacy_level PrivacyLevel

Synthesizer privacy level (defaults to high fidelity)

 HIGH_FIDELITY
entities Union[str, List[str]]

(optional) columns representing entities ID

 None
generate_cols List[str]

(optional) columns that should be synthesized

 None
exclude_cols List[str]

(optional) columns that should not be synthesized

 None
dtypes Dict[str, Union[str, DataType]]

(optional) datatype mapping that will overwrite the datasource metadata column datatypes

 None
target Optional[str]

(optional) Metadata associated to the datasource

 None
name Optional[str]

(optional) Synthesizer instance name

 None
anonymize Optional[str]

(optional) fields to anonymize and the anonymization strategy

 None
condition_on Optional[List[str]]

(Optional[List[str]]): (optional) list of features to condition upon

 None
Source code in /opt/hostedtoolcache/Python/3.10.13/x64/lib/python3.10/site-packages/ydata/sdk/synthesizers/timeseries.py 
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
def fit(self, X: Union[DataSource, pdDataFrame],
        sortbykey: Optional[Union[str, List[str]]],
        privacy_level: PrivacyLevel = PrivacyLevel.HIGH_FIDELITY,
        entities: Optional[Union[str, List[str]]] = None,
        generate_cols: Optional[List[str]] = None,
        exclude_cols: Optional[List[str]] = None,
        dtypes: Optional[Dict[str, Union[str, DataType]]] = None,
        target: Optional[str] = None,
        name: Optional[str] = None,
        anonymize: Optional[dict] = None,
        condition_on: Optional[List[str]] = None) -> None:
    """Fit the synthesizer.

    The synthesizer accepts as training dataset either a pandas [`DataFrame`][pandas.DataFrame] directly or a YData [`DataSource`][ydata.sdk.datasources.DataSource].

    Arguments:
        X (Union[DataSource, pandas.DataFrame]): Training dataset
        sortbykey (Union[str, List[str]]): column(s) to use to sort timeseries datasets
        privacy_level (PrivacyLevel): Synthesizer privacy level (defaults to high fidelity)
        entities (Union[str, List[str]]): (optional) columns representing entities ID
        generate_cols (List[str]): (optional) columns that should be synthesized
        exclude_cols (List[str]): (optional) columns that should not be synthesized
        dtypes (Dict[str, Union[str, DataType]]): (optional) datatype mapping that will overwrite the datasource metadata column datatypes
        target (Optional[str]): (optional) Metadata associated to the datasource
        name (Optional[str]): (optional) Synthesizer instance name
        anonymize (Optional[str]): (optional) fields to anonymize and the anonymization strategy
        condition_on: (Optional[List[str]]): (optional) list of features to condition upon
    """
    BaseSynthesizer.fit(self, X=X, datatype=DataSourceType.TIMESERIES, sortbykey=sortbykey,
                        entities=entities, generate_cols=generate_cols, exclude_cols=exclude_cols,
                        dtypes=dtypes, target=target, name=name, anonymize=anonymize, privacy_level=privacy_level,
                        condition_on=condition_on)

sample(n_entities, condition_on=None)

Sample from a TimeSeriesSynthesizer instance.

If a training dataset was not using any entity column, the Synthesizer assumes a single entity. A TimeSeriesSynthesizer always sample the full trajectory of its entities.

Parameters:

Name Type Description Default
n_entities int

number of entities to sample

 required
condition_on Optional[dict]

(Optional[dict]): (optional) conditional sampling parameters

 None

Returns:

Type Description
DataFrame

synthetic data
Source code in /opt/hostedtoolcache/Python/3.10.13/x64/lib/python3.10/site-packages/ydata/sdk/synthesizers/timeseries.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
def sample(self, n_entities: int, condition_on: Optional[dict] = None) -> pdDataFrame:
    """Sample from a [`TimeSeriesSynthesizer`][ydata.sdk.synthesizers.TimeSeriesSynthesizer] instance.

    If a training dataset was not using any `entity` column, the Synthesizer assumes a single entity.
    A [`TimeSeriesSynthesizer`][ydata.sdk.synthesizers.TimeSeriesSynthesizer] always sample the full trajectory of its entities.

    Arguments:
        n_entities (int): number of entities to sample
        condition_on: (Optional[dict]): (optional) conditional sampling parameters

    Returns:
        synthetic data
    """
    if n_entities is not None and n_entities < 1:
        raise InputError("Parameter 'n_entities' must be greater than 0")

    payload = {"numberOfRecords": n_entities}
    if condition_on is not None:
        payload["extraData"] = {
            "condition_on": condition_on
        }
    return self._sample(payload=payload)

PrivacyLevel

Bases: StringEnum

Privacy level exposed to the end-user.

BALANCED_PRIVACY_FIDELITY = 'BALANCED_PRIVACY_FIDELITY' class-attribute instance-attribute

Balanced privacy/fidelity

HIGH_FIDELITY = 'HIGH_FIDELITY' class-attribute instance-attribute

High fidelity

HIGH_PRIVACY = 'HIGH_PRIVACY' class-attribute instance-attribute

High privacy