def test_zscore_shift():
    time = pd.date_range(start='2018-01-01', end='2020-01-01')
    data_X = np.zeros(len(time))
    data_y = np.ones(len(time))

    X = xr.DataArray(data_X,
                     name='foo',
                     dims=['index'],
                     coords={
                         'index': time
                     }).to_dataframe()
    y = xr.DataArray(data_y,
                     name='foo',
                     dims=['index'],
                     coords={
                         'index': time
                     }).to_dataframe()

    shift_expected = xr.DataArray(np.ones(364),
                                  name='foo',
                                  dims=['day'],
                                  coords={
                                      'day': np.arange(1, 365)
                                  }).to_series()

    zscore = ZScoreRegressor()
    zscore.fit(X, y)

    np.testing.assert_allclose(zscore.shift_, shift_expected)
def test_zscore_scale():
    time = pd.date_range(start='2018-01-01', end='2020-01-01')
    data_X = np.linspace(0, 1, len(time))
    data_y = data_X * 2

    X = xr.DataArray(data_X,
                     name='foo',
                     dims=['index'],
                     coords={
                         'index': time
                     }).to_dataframe()
    y = xr.DataArray(data_y,
                     name='foo',
                     dims=['index'],
                     coords={
                         'index': time
                     }).to_dataframe()

    data_scale_expected = [2 for i in np.zeros(364)]
    scale_expected = xr.DataArray(data_scale_expected,
                                  name='foo',
                                  dims=['day'],
                                  coords={
                                      'day': np.arange(1, 365)
                                  }).to_series()

    zscore = ZScoreRegressor()
    zscore.fit(X, y)

    np.testing.assert_allclose(zscore.scale_, scale_expected)
Exemple #3
0
def test_zscore_shift():
    time = pd.date_range(start="2018-01-01", end="2020-01-01")
    data_X = np.zeros(len(time))
    data_y = np.ones(len(time))

    X = xr.DataArray(data_X,
                     name="foo",
                     dims=["index"],
                     coords={
                         "index": time
                     }).to_dataframe()
    y = xr.DataArray(data_y,
                     name="foo",
                     dims=["index"],
                     coords={
                         "index": time
                     }).to_dataframe()

    shift_expected = xr.DataArray(np.ones(364),
                                  name="foo",
                                  dims=["day"],
                                  coords={
                                      "day": np.arange(1, 365)
                                  }).to_series()

    zscore = ZScoreRegressor()
    zscore.fit(X, y)

    np.testing.assert_allclose(zscore.shift_, shift_expected)
def test_zscore_predict():
    time = pd.date_range(start='2018-01-01', end='2020-01-01')
    data_X = np.linspace(0, 1, len(time))

    X = xr.DataArray(data_X,
                     name='foo',
                     dims=['index'],
                     coords={
                         'index': time
                     }).to_dataframe()

    shift = xr.DataArray(np.zeros(364),
                         name='foo',
                         dims=['day'],
                         coords={
                             'day': np.arange(1, 365)
                         }).to_series()
    scale = xr.DataArray(np.ones(364),
                         name='foo',
                         dims=['day'],
                         coords={
                             'day': np.arange(1, 365)
                         }).to_series()

    zscore = ZScoreRegressor()
    zscore.shift_ = shift
    zscore.scale_ = scale

    i = int(zscore.window_width / 2)
    expected = xr.DataArray(data_X,
                            name='foo',
                            dims=['index'],
                            coords={
                                'index': time
                            }).to_dataframe()
    expected[0:i] = 'NaN'
    expected[-i:] = 'NaN'

    out = zscore.predict(X)

    np.testing.assert_allclose(out.astype(float), expected.astype(float))
Exemple #5
0
def test_zscore_predict():
    time = pd.date_range(start="2018-01-01", end="2020-01-01")
    data_X = np.linspace(0, 1, len(time))

    X = xr.DataArray(data_X,
                     name="foo",
                     dims=["index"],
                     coords={
                         "index": time
                     }).to_dataframe()

    shift = xr.DataArray(np.zeros(364),
                         name="foo",
                         dims=["day"],
                         coords={
                             "day": np.arange(1, 365)
                         }).to_series()
    scale = xr.DataArray(np.ones(364),
                         name="foo",
                         dims=["day"],
                         coords={
                             "day": np.arange(1, 365)
                         }).to_series()

    zscore = ZScoreRegressor()
    zscore.shift_ = shift
    zscore.scale_ = scale

    i = int(zscore.window_width / 2)
    expected = xr.DataArray(data_X,
                            name="foo",
                            dims=["index"],
                            coords={
                                "index": time
                            }).to_dataframe()
    expected[0:i] = "NaN"
    expected[-i:] = "NaN"

    np.testing.assert_allclose(
        zscore.predict(X).astype(float), expected.astype(float))
    LinearTrendTransformer,
    PaddedDOYGrouper,
    PureAnalog,
    QuantileMapper,
    QuantileMappingReressor,
    ZScoreRegressor,
)


@parametrize_with_checks([
    # Regressors
    AnalogRegression(),
    BcsdPrecipitation(),
    BcsdTemperature(),
    PureAnalog(),
    ZScoreRegressor(),
    QuantileMappingReressor(n_endpoints=2),
    # transformers
    LinearTrendTransformer(),
    QuantileMapper(),
])
def test_sklearn_compatible_estimator(estimator, check):
    check(estimator)


def test_linear_trend_roundtrip():
    # TODO: there is probably a better analytic test here
    n = 100
    trend = 1
    yint = 15