def test_binary_classification(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date')
df["sma"] = SMA(df["spy_Close"])
df["is_above"] = (df["spy_Close"] / df["sma"]) > 1
model = pdu.SkModel(
MLPClassifier(activation='tanh', hidden_layer_sizes=(60, 50), random_state=42),
pdu.FeaturesAndLabels(features=['vix_Close'],
labels=["is_above"],
targets=lambda frame: frame["sma"],
gross_loss=lambda frame: frame["spy_Close"] - frame["sma"]))
"""when"""
fit = df.fit(model, test_size=0.4, test_validate_split_seed=42)
fit_summary_df = fit.training_summary.df
bt_summary_df = df.backtest(fit.model).df
predict_df = df.predict(fit.model, tail=1)
"""then"""
self.assertListEqual(fit_summary_df.columns.tolist(), [(PREDICTION_COLUMN_NAME, 'is_above'), (LABEL_COLUMN_NAME, 'is_above'), (GROSS_LOSS_COLUMN_NAME, GROSS_LOSS_COLUMN_NAME), (TARGET_COLUMN_NAME, 'sma')])
self.assertEqual(len(fit_summary_df), 4023)
self.assertEqual(bt_summary_df.shape, (6706, 15))
self.assertListEqual(predict_df.columns.tolist(), [(PREDICTION_COLUMN_NAME, 'is_above'), (TARGET_COLUMN_NAME, 'sma')])
def test_binary_classification_kfold(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date')
df['label'] = df["spy_Close"] > df["spy_Open"]
"""and cross validation"""
called = False
cv = KFold(2)
def split(x, y=None, group=None):
nonlocal called
called = True
return cv.split(x, y, group)
"""when"""
fit = df.fit(pdu.SkModel(
MLPClassifier(activation='tanh',
hidden_layer_sizes=(60, 50),
alpha=0.001,
random_state=42),
pdu.FeaturesAndLabels(
features=['vix_Close'],
labels=['label'],
gross_loss=lambda df: df["spy_Close"] - df["spy_Open"])),
test_size=0.4,
cross_validation=(1, split),
test_validate_split_seed=42)
"""then"""
# no exception thrown
self.assertTrue(called)
def test_invalid_multi_model(self):
"""expect"""
self.assertRaises(
ValueError, lambda: pdu.MultiModel(
pdu.MultiModel(
pdu.SkModel(MLPClassifier(), pdu.FeaturesAndLabels([], {}))
)))
def test_hyper_parameter(self):
from hyperopt import hp
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date')
df['label'] = df["spy_Close"] > df["spy_Open"]
"""when fit with find hyper parameter"""
fit = df.fit(pdu.SkModel(
MLPClassifier(activation='tanh',
hidden_layer_sizes=(60, 50),
random_state=42),
pdu.FeaturesAndLabels(features=['vix_Close'],
labels=['label'],
target_columns=["vix_Open"],
loss_column="spy_Volume")),
test_size=0.4,
test_validate_split_seed=42,
hyper_parameter_space={
'alpha': hp.choice('alpha', [0.0001, 10]),
'early_stopping': True,
'max_iter': 50,
'__max_evals': 4,
'__rstate': np.random.RandomState(42)
})
"""then test best parameter"""
self.assertEqual(fit.model.skit_model.get_params()['alpha'], 0.0001)
def test__inderval_index_encoder(self):
"""given features and labels"""
df["sma_ratio"] = df["Close"].ta_future_pct_of_mean(0, 20)
df["forward_sma_ratio"] = df["Close"].ta_future_pct_of_mean(3, 20)
"""and an IntervalIndex"""
buckets = pd.IntervalIndex.from_breaks(
[-float("inf"), -0.05, 0.0, 0.05,
float("inf")])
"""and a model"""
model = pmu.SkModel(
MLPClassifier(activation='tanh',
hidden_layer_sizes=(60, 50),
random_state=42),
pmu.FeaturesAndLabels(features=['sma_ratio'],
labels=IntervalIndexEncoder(
"forward_sma_ratio", buckets)))
"""when"""
fit = df.fit(
model,
test_size=0.4,
test_validate_split_seed=42,
)
predicted = df.predict(fit.model)
"""then"""
print(predicted)
self.assertTrue(df.predict(fit.model).values[-1, -1] < 0.1)
def test_pre_processor(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date')
"""when"""
fit = df.fit(
pdu.SkModel(
MLPClassifier(activation='tanh', hidden_layer_sizes=(60, 50), alpha=0.001, random_state=42),
pdu.FeaturesAndLabels(features=['feature'], labels=['label'], label_type=int,
gross_loss=lambda df: df["spy_Close"] - df["spy_Open"],
pre_processor=lambda _df: pdu.LazyDataFrame(
_df,
feature=lambda f: f["vix_Close"].rolling(2).mean(),
label=lambda f: (f["spy_Close"].shift(1) > f["spy_Open"]).shift(-1)).to_dataframe())),
test_size=0.4,
test_validate_split_seed=42)
bt = df.backtest(fit.model)
p = df.predict(fit.model, 2)
"""then fit"""
self.assertListEqual(fit.test_summary.df.columns.tolist(), [(PREDICTION_COLUMN_NAME, 'label'), (LABEL_COLUMN_NAME, 'label'), (GROSS_LOSS_COLUMN_NAME, GROSS_LOSS_COLUMN_NAME)])
""" and backtest"""
self.assertListEqual(bt.df.columns.tolist(), [(PREDICTION_COLUMN_NAME, 'label'), (LABEL_COLUMN_NAME, 'label'), (GROSS_LOSS_COLUMN_NAME, GROSS_LOSS_COLUMN_NAME), *[(SOURCE_COLUMN_NAME, c) for c in df.columns], (SOURCE_COLUMN_NAME, "feature"), (SOURCE_COLUMN_NAME, "label")])
self.assertEqual(bt.df.index[-1], "2019-09-13")
""" and prediction"""
self.assertListEqual(p.columns.tolist(), [(PREDICTION_COLUMN_NAME, 'label')])
self.assertEqual(p.index[-1], "2019-09-16")
self.assertEqual(len(p), 2)
def test__2d_encoding(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date')
df["label"] = df["spy_Close"] > df["spy_Open"]
class ArrayEncoder(TargetLabelEncoder):
def __init__(self):
super().__init__()
@property
def labels_source_columns(self) -> List[str]:
return ["spy_Close"]
@property
def encoded_labels_columns(self) -> List[str]:
return ["2D"]
def encode(self, df: pd.DataFrame, **kwargs) -> pd.DataFrame:
res = pd.DataFrame({}, index=df.index)
res["2D"] = df["spy_Close"] = df["spy_Close"].apply(
lambda r: np.array([r, r]))
return res
"""when"""
model = MockModel(
pdu.FeaturesAndLabels(["spy_Close"],
ArrayEncoder(),
feature_lags=[0, 1, 2]))
fit = df.fit(model)
"""then"""
print(fit.test_summary.df)
self.assertEqual(fit.test_summary.df.shape, (2682, 2))
self.assertEqual(
integrate_nested_arrays(fit.test_summary.df.values).shape,
(2682, 2, 2))
def test_extractor(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date')
"""when"""
extractor = df.features_and_label_extractor(
pdu.SkModel(
MLPClassifier(activation='tanh', hidden_layer_sizes=(60, 50), alpha=0.001, random_state=42),
pdu.FeaturesAndLabels(features=['feature'], labels=['label'],
gross_loss=lambda df: df["spy_Close"] - df["spy_Open"],
targets=lambda df: df["spy_Close"],
pre_processor=lambda _df: pdu.LazyDataFrame(
_df,
feature=lambda f: f["vix_Close"].rolling(2).mean(),
label=lambda f: (f["spy_Close"].shift(1) > f["spy_Open"]).shift(-1)))))
fnl = extractor.features_labels_weights_df
"""then"""
self.assertListEqual(extractor.features_df.columns.tolist(), ['feature'])
self.assertListEqual(extractor.labels_df.columns.tolist(), ['label'])
self.assertListEqual(extractor.source_df[SOURCE_COLUMN_NAME].columns.tolist(), [*df.columns.tolist(), 'feature', 'label'])
self.assertListEqual(extractor.target_df.columns.tolist(), [(TARGET_COLUMN_NAME, "spy_Close")])
self.assertListEqual(extractor.gross_loss_df.columns.tolist(), [(GROSS_LOSS_COLUMN_NAME, GROSS_LOSS_COLUMN_NAME)])
self.assertEqual(fnl[0].shape, (6704, 1))
self.assertEqual(fnl[1].shape, (6704, 1))
self.assertIsNone(fnl[2])
def test_target_classification(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date')
df["sma"] = SMA(df["spy_Close"])
df["is_above_1.0"] = (df["spy_Close"] / df["sma"]) > 1
df["is_above_1.2"] = (df["spy_Close"] / df["sma"]) > 1.2
model = pdu.SkModel(
MLPClassifier(activation='tanh', hidden_layer_sizes=(60, 50), random_state=42),
pdu.FeaturesAndLabels(features=['vix_Close'],
labels={"a": ["is_above_1.0"], "b": ["is_above_1.2"]}))
"""when"""
fit = df.fit(model, test_size=0.4, test_validate_split_seed=42)
fit_summary_df = fit.training_summary.df
bt_summary_df = df.backtest(fit.model).df
predict_df = df.predict(fit.model, tail=1)
"""then"""
self.assertListEqual(fit_summary_df.columns.tolist(),
[('a', PREDICTION_COLUMN_NAME, 'is_above_1.0'), ('b', PREDICTION_COLUMN_NAME, 'is_above_1.2'),
('a', LABEL_COLUMN_NAME, 'is_above_1.0'), ('b', LABEL_COLUMN_NAME, 'is_above_1.2')])
self.assertListEqual(predict_df.columns.tolist(),
[('a', PREDICTION_COLUMN_NAME, 'is_above_1.0'), ('b', PREDICTION_COLUMN_NAME, 'is_above_1.2')])
self.assertEqual(bt_summary_df.shape, (6706, 16))
def test_save_load_models(self):
"""given"""
features_and_labels = pmu.FeaturesAndLabels(["a"], ["b"])
def keras_model_provider(optimizer='adam'):
model = Sequential()
model.add(Dense(1, input_dim=1, activation='sigmoid'))
model.compile(optimizer, loss='mse')
return model
providers = [
pmu.SkModel(MLPClassifier(activation='tanh',
hidden_layer_sizes=(1, 1),
alpha=0.001,
random_state=42),
features_and_labels,
foo='bar'),
pmu.SkModel(LogisticRegression(), features_and_labels),
pmu.SkModel(LinearSVC(), features_and_labels),
pmu.SkModel(RandomForestClassifier(), features_and_labels),
pmu.KerasModel(keras_model_provider, features_and_labels),
pmu.MultiModel(
pmu.SkModel(LogisticRegression(),
pmu.FeaturesAndLabels(["a"], {"b": ["b"]})))
]
"""when"""
fits = [df.fit(mp) for mp in providers]
models = []
for i, f in enumerate(fits):
f.save_model(f'/tmp/pandas-ml-utils-unittest-test_model_{i}')
models.append(
(f.model,
pmu.Model.load(
f'/tmp/pandas-ml-utils-unittest-test_model_{i}')))
"""then"""
for i, (fitted_model, restored_model) in enumerate(models):
print(f"test model ==> {i}")
pd.testing.assert_frame_equal(df.predict(fitted_model),
df.predict(restored_model))
pd.testing.assert_frame_equal(
df.backtest(fitted_model).df,
df.backtest(restored_model).df)
def test_binary_classification_summary(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date')
df['label'] = df["spy_Close"] > df["spy_Open"]
"""when"""
fit = df.fit(pdu.SkModel(
MLPClassifier(activation='tanh',
hidden_layer_sizes=(60, 50),
alpha=0.001,
random_state=42),
pdu.FeaturesAndLabels(
features=['vix_Close'],
labels=['label'],
gross_loss=lambda df: df["spy_Close"] - df["spy_Open"]),
BinaryClassificationSummary),
test_size=0.4,
test_validate_split_seed=42)
"""then confusion matrix"""
self.assertEqual(fit.model.features_and_labels.min_required_samples, 1)
np.testing.assert_array_equal(
fit.training_summary.get_confusion_matrix(),
np.array([[1067, 872], [1002, 1082]]))
np.testing.assert_array_equal(fit.test_summary.get_confusion_matrix(),
np.array([[744, 586], [655, 698]]))
""" and confusion loss"""
np.testing.assert_array_almost_equal(
fit.test_summary.get_confusion_loss(),
np.array([[374.90, -234.83], [561.48, -650.63]]), 2)
""" and ratios"""
np.testing.assert_array_almost_equal(
np.array(fit.test_summary.get_ratios()), np.array((0.78, 0.88)), 2)
""" and metrics"""
np.testing.assert_array_almost_equal(
np.array(list(fit.test_summary.get_metrics().values())),
np.array([0.78, 0.88, 0.54]), 2)
""" and plot_classification"""
self.assertDictEqual(
{
k: repr(v)
for k, v in fit.test_summary.plot_classification().items()
}, {None: '<Figure size 1600x900 with 2 Axes>'})
if os.environ.get('USER') == 'kic':
# FIXME nowadays this test fails on github while it still passes locally. we need a better assertion
self.assertDictEqual(
{
k: len(fig_to_png_base64(v))
for k, v in fit.test_summary.plot_classification().items()
}, {None: 141863})
""" and _repr_html_"""
self.assertEqual(len(fit.test_summary._repr_html_()), 145167)
def test_multi_model_binary_classifications(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date')
df["sma"] = SMA(df["spy_Close"])
df["is_above_1.0"] = (df["spy_Close"] / df["sma"]) > 1
df["is_above_1.2"] = (df["spy_Close"] / df["sma"]) > 1.2
model = pdu.MultiModel(
pdu.SkModel(
MLPClassifier(activation='tanh',
hidden_layer_sizes=(60, 50),
random_state=42),
pdu.FeaturesAndLabels(
features=['vix_Close'],
labels={
"a": ["is_above_1.0"],
"b": ["is_above_1.2"]
},
targets=lambda frame, t: frame["sma"].rename(f"sma {t}"),
gross_loss=lambda frame: frame["spy_Close"] - frame["sma"])
))
"""when"""
fit = df.fit(
model,
test_size=0.4,
test_validate_split_seed=42,
)
fit_summary_df = fit.training_summary.df
bt_summary_df = df.backtest(fit.model).df
predict_df = df.predict(fit.model, tail=1)
"""then"""
self.assertListEqual(fit_summary_df.columns.tolist(),
[('a', PREDICTION_COLUMN_NAME, 'is_above_1.0'),
('b', PREDICTION_COLUMN_NAME, 'is_above_1.2'),
('a', LABEL_COLUMN_NAME, 'is_above_1.0'),
('b', LABEL_COLUMN_NAME, 'is_above_1.2'),
('a', GROSS_LOSS_COLUMN_NAME, 'a'),
('b', GROSS_LOSS_COLUMN_NAME, 'b'),
('a', TARGET_COLUMN_NAME, 'sma a'),
('b', TARGET_COLUMN_NAME, 'sma b')])
self.assertListEqual(predict_df.columns.tolist(),
[('a', PREDICTION_COLUMN_NAME, 'is_above_1.0'),
('b', PREDICTION_COLUMN_NAME, 'is_above_1.2'),
('a', TARGET_COLUMN_NAME, 'sma a'),
('b', TARGET_COLUMN_NAME, 'sma b')])
self.assertEqual(bt_summary_df.shape, (6706, 20))
def test_model_with_LazyDataFrame_copy(self):
"""given"""
model = pmu.SkModel(MLPClassifier(activation='tanh',
hidden_layer_sizes=(1, 1),
alpha=0.001,
random_state=42),
pmu.FeaturesAndLabels([], []),
foo='bar',
ldf=LazyDataFrame(None, foo=lambda _f: 'bar'))
"""when"""
model.save(f'/tmp/pandas-ml-utils-unittest-test_model_LDF')
model2 = pmu.Model.load(
f'/tmp/pandas-ml-utils-unittest-test_model_LDF')
"""then"""
self.assertEqual(model.kwargs["ldf"], model2.kwargs["ldf"])
self.assertEqual(model.kwargs["ldf"].kwargs['foo'](None), 'bar')
self.assertEqual(model2.kwargs["ldf"].kwargs['foo'](None), 'bar')
def test_fit_and_co(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date').tail(100)
ldf = pdu.LazyDataFrame(df,
sma=lambda f: f["vix_Close"].rolling(2).mean(),
label=lambda f: f["spy_Close"] > f["spy_Open"])
model = pdu.SkModel(
MLPClassifier(activation='tanh',
hidden_layer_sizes=(60, 50),
random_state=42),
pdu.FeaturesAndLabels(["sma"], ["label"]))
"""when"""
fit = ldf.fit(model)
bt = ldf.backtest(fit.model)
p = ldf.predict(fit.model)
"""then"""
self.assertEqual(len(fit.test_summary.df), 40)
self.assertEqual(len(bt.df), 100 - 1)
self.assertEqual(len(p), 100 - 1)
def test_discrete_encoded_classes(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date')
df["sma"] = SMA(df["spy_Close"])
df["label"] = (((df["spy_Close"] / df["sma"] -1) > 0.02).astype(int) - ((df["spy_Close"] / df["sma"] -1) < -0.02).astype(int)) + 1
model = pdu.SkModel(
MLPClassifier(activation='tanh', hidden_layer_sizes=(60, 50), random_state=42),
pdu.FeaturesAndLabels(features=['vix_Close'],
labels=OneHotEncodedDiscrete("label", 3)))
"""when"""
fit = df.fit(model, test_size=0.4, test_validate_split_seed=42,)
predict_df = df.predict(fit.model, tail=1)
"""then"""
self.assertListEqual(predict_df.columns.tolist(),
[(PREDICTION_COLUMN_NAME, 'label_0'),
(PREDICTION_COLUMN_NAME, 'label_1'),
(PREDICTION_COLUMN_NAME, 'label_2')])
def test_fit_regressor_mutiple_target(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date') / 50.
"""when"""
fit = df.fit(pdu.SkModel(
MLPRegressor(activation='tanh',
hidden_layer_sizes=(4, 3, 2, 1, 2, 3, 4),
random_state=42),
pdu.FeaturesAndLabels(
features=['spy_Open', 'spy_High', 'spy_Low', 'spy_Close'],
labels={
"a": ['vix_Open'],
"b": ['vix_High', 'vix_Low', 'vix_Close']
},
targets=lambda frame, t: frame[['vix_High', 'vix_Low']
].add_prefix(f"{t}_"))),
test_size=0.4,
test_validate_split_seed=42)
fitted_model = fit.model
# backtest
backtest_regression = df.backtest(fitted_model)
self.assertIsNotNone(backtest_regression)
# regressed
regressed = df.predict(fitted_model)
"""then"""
self.assertListEqual(regressed.columns.tolist(),
[('a', 'prediction', 'vix_Open'),
('b', 'prediction', 'vix_High'),
('b', 'prediction', 'vix_Low'),
('b', 'prediction', 'vix_Close'),
('a', 'target', 'a_vix_High'),
('a', 'target', 'a_vix_Low'),
('b', 'target', 'b_vix_High'),
('b', 'target', 'b_vix_Low')])
self.assertEqual(len(regressed), 6706)
def test_multi_class_classification(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date')
df["sma"] = SMA(df["spy_Close"])
df["label"] = df["spy_Close"] / df["sma"] -1
def make_targets(frame):
space = np.array([-1, -0.05, 0.5, 1])
res = frame.apply(lambda x: x["sma"] - space, axis=1,
result_type='expand')
res.columns = ["close <0.1", "close <0.05", "close >0", "close >0.05"]
return res
model = pdu.SkModel(
MLPClassifier(activation='tanh', hidden_layer_sizes=(60, 50), random_state=42),
pdu.FeaturesAndLabels(features=['vix_Close'],
labels=OneHotEncodedTargets("label", np.linspace(-0.1, 0.1, 5, endpoint=True)),
targets=make_targets))
"""when"""
fit = df.fit(model, test_size=0.4, test_validate_split_seed=42,)
fit_summary_df = fit.training_summary.df
bt_summary_df = df.backtest(fit.model).df
predict_df = df.predict(fit.model, tail=1)
"""then"""
self.assertEqual(len(fit_summary_df), 4023)
self.assertListEqual(fit_summary_df.columns.tolist(),
[(PREDICTION_COLUMN_NAME, '(-inf, -0.05]'), (PREDICTION_COLUMN_NAME, '(-0.05, 0.0]'), (PREDICTION_COLUMN_NAME, '(0.0, 0.05000000000000002]'), (PREDICTION_COLUMN_NAME, '(0.05000000000000002, inf]'),
(LABEL_COLUMN_NAME, '(-inf, -0.05]'), (LABEL_COLUMN_NAME, '(-0.05, 0.0]'), (LABEL_COLUMN_NAME, '(0.0, 0.05000000000000002]'), (LABEL_COLUMN_NAME, '(0.05000000000000002, inf]'),
(TARGET_COLUMN_NAME, 'close <0.1'), (TARGET_COLUMN_NAME, 'close <0.05'), (TARGET_COLUMN_NAME, 'close >0'), (TARGET_COLUMN_NAME, 'close >0.05')])
self.assertListEqual(predict_df.columns.tolist(),
[(PREDICTION_COLUMN_NAME, '(-inf, -0.05]'), (PREDICTION_COLUMN_NAME, '(-0.05, 0.0]'), (PREDICTION_COLUMN_NAME, '(0.0, 0.05000000000000002]'), (PREDICTION_COLUMN_NAME, '(0.05000000000000002, inf]'),
(TARGET_COLUMN_NAME, 'close <0.1'), (TARGET_COLUMN_NAME, 'close <0.05'), (TARGET_COLUMN_NAME, 'close >0'), (TARGET_COLUMN_NAME, 'close >0.05')])
self.assertEqual(bt_summary_df.shape, (6706, 23))
def test_save_load_keras_custom_loss(self):
"""given"""
features_and_labels = pmu.FeaturesAndLabels(["a"], ["b"])
name = '/tmp/pandas-ml-utils-unittest-test_model_keras_custom_loss'
def loss_provider(foo):
def my_custom_loss(x, y):
print(foo)
import keras.backend as K
return K.sum(x - y)
return my_custom_loss
def keras_model_provider():
model = Sequential()
model.add(Dense(1, input_dim=1, activation='sigmoid'))
model.compile(optimizer='Adam', loss=loss_provider("bar"))
return model, loss_provider("bar")
"""when"""
fit = df.fit(
pmu.KerasModel(keras_model_provider,
features_and_labels,
optimizer='adam',
verbose=0))
fitted_model = fit.model
fit.save_model(name)
restored_model = pmu.Model.load(name)
"""then"""
pd.testing.assert_frame_equal(df.predict(fitted_model),
df.predict(restored_model))
pd.testing.assert_frame_equal(
df.backtest(fitted_model).df,
df.backtest(restored_model).df)
def test_multi_model_multi_class_classifications(self):
"""given"""
df = pd.read_csv(TEST_FILE, index_col='Date')
df["sma"] = SMA(df["spy_Close"])
df["is_above_1.0"] = (df["spy_Close"] / df["sma"]) + 1
df["is_above_1.2"] = (df["spy_Close"] / df["sma"]) + 2
model = pdu.MultiModel(
pdu.SkModel(
MLPClassifier(activation='tanh',
hidden_layer_sizes=(60, 50),
random_state=42),
pdu.FeaturesAndLabels(
features=['vix_Close'],
labels={
"1":
OneHotEncodedTargets(
"is_above_1.0",
np.linspace(-0.1, 0.1, 5, endpoint=True) + 1),
"2":
OneHotEncodedTargets(
"is_above_1.2",
np.linspace(-0.1, 0.1, 5, endpoint=True) + 2)
},
targets=lambda frame, t:
(frame["sma"] + int(t)).rename(f"sma {t}"),
gross_loss=lambda frame: frame["spy_Close"] - frame["sma"])
))
"""when"""
fit = df.fit(
model,
test_size=0.4,
test_validate_split_seed=42,
)
fit_summary_df = fit.training_summary.df
bt_summary_df = df.backtest(fit.model).df
predict_df = df.predict(fit.model, tail=1)
"""then"""
print(fit_summary_df.columns.tolist())
self.assertListEqual(fit_summary_df.columns.tolist(),
[('1', 'prediction', '(-inf, 0.95]'),
('1', 'prediction', '(0.95, 1.0]'),
('1', 'prediction', '(1.0, 1.05]'),
('1', 'prediction', '(1.05, inf]'),
('2', 'prediction', '(-inf, 1.95]'),
('2', 'prediction', '(1.95, 2.0]'),
('2', 'prediction', '(2.0, 2.05]'),
('2', 'prediction', '(2.05, inf]'),
('1', 'label', '(-inf, 0.95]'),
('1', 'label', '(0.95, 1.0]'),
('1', 'label', '(1.0, 1.05]'),
('1', 'label', '(1.05, inf]'),
('2', 'label', '(-inf, 1.95]'),
('2', 'label', '(1.95, 2.0]'),
('2', 'label', '(2.0, 2.05]'),
('2', 'label', '(2.05, inf]'),
('1', GROSS_LOSS_COLUMN_NAME, '1'),
('2', GROSS_LOSS_COLUMN_NAME, '2'),
('1', TARGET_COLUMN_NAME, 'sma 1'),
('2', TARGET_COLUMN_NAME, 'sma 2')])
self.assertListEqual(predict_df.columns.tolist(),
[('1', 'prediction', '(-inf, 0.95]'),
('1', 'prediction', '(0.95, 1.0]'),
('1', 'prediction', '(1.0, 1.05]'),
('1', 'prediction', '(1.05, inf]'),
('2', 'prediction', '(-inf, 1.95]'),
('2', 'prediction', '(1.95, 2.0]'),
('2', 'prediction', '(2.0, 2.05]'),
('2', 'prediction', '(2.05, inf]'),
('1', TARGET_COLUMN_NAME, 'sma 1'),
('2', TARGET_COLUMN_NAME, 'sma 2')])
self.assertEqual(bt_summary_df.shape, (6706, 32))