def test_random_forest_regressor(self):
# Train model
training_data = datasets.make_regression(n_features=5)
regressor = RandomForestRegressor()
regressor.fit(training_data[0], training_data[1])
# Get some test results
test_data = [[0.1, 0.2, 0.3, -0.5, 1.0], [1.6, 2.1, -10, 50, -1.0]]
test_results = regressor.predict(test_data)
# Serialise the models to Elasticsearch
feature_names = ["f0", "f1", "f2", "f3", "f4"]
model_id = "test_random_forest_regressor"
es_model = ImportedMLModel(ES_TEST_CLIENT,
model_id,
regressor,
feature_names,
overwrite=True)
es_results = es_model.predict(test_data)
np.testing.assert_almost_equal(test_results, es_results, decimal=2)
# Clean up
es_model.delete_model()
def test_predict_single_feature_vector(self):
# Train model
training_data = datasets.make_regression(n_features=1)
regressor = XGBRegressor()
regressor.fit(training_data[0], training_data[1])
# Get some test results
test_data = [[0.1]]
test_results = regressor.predict(np.asarray(test_data))
# Serialise the models to Elasticsearch
feature_names = ["f0"]
model_id = "test_xgb_regressor"
es_model = ImportedMLModel(
ES_TEST_CLIENT, model_id, regressor, feature_names, overwrite=True
)
# Single feature
es_results = es_model.predict(test_data[0])
np.testing.assert_almost_equal(test_results, es_results, decimal=2)
# Clean up
es_model.delete_model()
def test_lgbm_classifier_objectives_and_booster(
self, compress_model_definition, objective, booster
):
# test both multiple and binary classification
if objective.startswith("multi"):
training_data = datasets.make_classification(
n_features=5, n_classes=3, n_informative=3
)
classifier = LGBMClassifier(boosting_type=booster, objective=objective)
else:
training_data = datasets.make_classification(n_features=5)
classifier = LGBMClassifier(boosting_type=booster, objective=objective)
# Train model
classifier.fit(training_data[0], training_data[1])
# Serialise the models to Elasticsearch
feature_names = ["Column_0", "Column_1", "Column_2", "Column_3", "Column_4"]
model_id = "test_lgbm_classifier"
es_model = ImportedMLModel(
ES_TEST_CLIENT,
model_id,
classifier,
feature_names,
overwrite=True,
es_compress_model_definition=compress_model_definition,
)
check_prediction_equality(
es_model, classifier, random_rows(training_data[0], 20)
)
# Clean up
es_model.delete_model()
def test_xgb_classifier(self):
# Train model
training_data = datasets.make_classification(n_features=5)
classifier = XGBClassifier()
classifier.fit(training_data[0], training_data[1])
# Get some test results
test_data = [[0.1, 0.2, 0.3, -0.5, 1.0], [1.6, 2.1, -10, 50, -1.0]]
test_results = classifier.predict(np.asarray(test_data))
# Serialise the models to Elasticsearch
feature_names = ["f0", "f1", "f2", "f3", "f4"]
model_id = "test_xgb_classifier"
es_model = ImportedMLModel(ES_TEST_CLIENT,
model_id,
classifier,
feature_names,
overwrite=True)
es_results = es_model.predict(test_data)
np.testing.assert_almost_equal(test_results, es_results, decimal=2)
# Clean up
es_model.delete_model()
def test_lgbm_regressor(self, compress_model_definition, objective, booster):
# Train model
training_data = datasets.make_regression(n_features=5)
if booster == "rf":
regressor = LGBMRegressor(
boosting_type=booster,
objective=objective,
bagging_fraction=0.5,
bagging_freq=3,
)
else:
regressor = LGBMRegressor(boosting_type=booster, objective=objective)
regressor.fit(training_data[0], training_data[1])
# Serialise the models to Elasticsearch
feature_names = ["Column_0", "Column_1", "Column_2", "Column_3", "Column_4"]
model_id = "test_lgbm_regressor"
es_model = ImportedMLModel(
ES_TEST_CLIENT,
model_id,
regressor,
feature_names,
overwrite=True,
es_compress_model_definition=compress_model_definition,
)
# Get some test results
check_prediction_equality(
es_model, regressor, random_rows(training_data[0], 20)
)
# Clean up
es_model.delete_model()
def test_xgb_regressor(self, compress_model_definition, objective, booster):
# Train model
training_data = datasets.make_regression(n_features=5)
regressor = XGBRegressor(objective=objective, booster=booster)
regressor.fit(
training_data[0],
np.exp(training_data[1] - np.max(training_data[1]))
/ sum(np.exp(training_data[1])),
)
# Serialise the models to Elasticsearch
feature_names = ["f0", "f1", "f2", "f3", "f4"]
model_id = "test_xgb_regressor"
es_model = ImportedMLModel(
ES_TEST_CLIENT,
model_id,
regressor,
feature_names,
overwrite=True,
es_compress_model_definition=compress_model_definition,
)
# Get some test results
check_prediction_equality(
es_model, regressor, random_rows(training_data[0], 20)
)
# Clean up
es_model.delete_model()
def test_xgb_classifier_objectives_and_booster(self, objective, booster):
# test both multiple and binary classification
if objective.startswith("multi"):
training_data = datasets.make_classification(
n_features=5, n_classes=3, n_informative=3
)
classifier = XGBClassifier(booster=booster, objective=objective)
else:
training_data = datasets.make_classification(n_features=5)
classifier = XGBClassifier(booster=booster, objective=objective)
# Train model
classifier.fit(training_data[0], training_data[1])
# Serialise the models to Elasticsearch
feature_names = ["f0", "f1", "f2", "f3", "f4"]
model_id = "test_xgb_classifier"
es_model = ImportedMLModel(
ES_TEST_CLIENT, model_id, classifier, feature_names, overwrite=True
)
# Get some test results
check_prediction_equality(
es_model, classifier, random_rows(training_data[0], 20)
)
# Clean up
es_model.delete_model()
def test_xgb_classifier(self, compress_model_definition, multi_class):
# test both multiple and binary classification
if multi_class:
training_data = datasets.make_classification(
n_features=5, n_classes=3, n_informative=3
)
classifier = XGBClassifier(booster="gbtree", objective="multi:softmax")
else:
training_data = datasets.make_classification(n_features=5)
classifier = XGBClassifier(booster="gbtree")
# Train model
classifier.fit(training_data[0], training_data[1])
# Serialise the models to Elasticsearch
feature_names = ["f0", "f1", "f2", "f3", "f4"]
model_id = "test_xgb_classifier"
es_model = ImportedMLModel(
ES_TEST_CLIENT,
model_id,
classifier,
feature_names,
overwrite=True,
es_compress_model_definition=compress_model_definition,
)
# Get some test results
check_prediction_equality(
es_model, classifier, random_rows(training_data[0], 20)
)
# Clean up
es_model.delete_model()
def test_random_forest_regressor(self, compress_model_definition):
# Train model
training_data = datasets.make_regression(n_features=5)
regressor = RandomForestRegressor()
regressor.fit(training_data[0], training_data[1])
# Serialise the models to Elasticsearch
feature_names = ["f0", "f1", "f2", "f3", "f4"]
model_id = "test_random_forest_regressor"
es_model = ImportedMLModel(
ES_TEST_CLIENT,
model_id,
regressor,
feature_names,
overwrite=True,
es_compress_model_definition=compress_model_definition,
)
# Get some test results
check_prediction_equality(
es_model, regressor, random_rows(training_data[0], 20)
)
# Clean up
es_model.delete_model()
def test_unpack_and_raise_errors_in_ingest_simulate(self, mocker):
# Train model
training_data = datasets.make_classification(n_features=5)
classifier = DecisionTreeClassifier()
classifier.fit(training_data[0], training_data[1])
# Serialise the models to Elasticsearch
feature_names = ["f0", "f1", "f2", "f3", "f4"]
model_id = "test_decision_tree_classifier"
test_data = [[0.1, 0.2, 0.3, -0.5, 1.0], [1.6, 2.1, -10, 50, -1.0]]
es_model = ImportedMLModel(
ES_TEST_CLIENT,
model_id,
classifier,
feature_names,
overwrite=True,
es_compress_model_definition=True,
)
# Mock the ingest.simulate API to return an error within {'docs': [...]}
mock = mocker.patch.object(ES_TEST_CLIENT.ingest, "simulate")
mock.return_value = {
"docs": [
{
"error": {
"type": "x_content_parse_exception",
"reason": "[1:1052] [inference_model_definition] failed to parse field [trained_model]",
}
}
]
}
with pytest.raises(RuntimeError) as err:
es_model.predict(test_data)
assert repr(err.value) == (
'RuntimeError("Failed to run prediction for model ID '
"'test_decision_tree_classifier'\", {'type': 'x_content_parse_exception', "
"'reason': '[1:1052] [inference_model_definition] failed to parse "
"field [trained_model]'})"
)
# create es connection
es = Elasticsearch(es_url, http_auth=(es_user, es_pass))
# In[ ]:
# Serialise the trained RandomForestClassifier model to Elasticsearch
# pick short feature names for the docs
feature_names = ['sl', 'sw', 'pl', 'pw']
# name model
model_id = "jeffs-rfc-flower-type"
# load model into elasticsearch
es_model = ImportedMLModel(es, model_id, clf, feature_names, overwrite=True)
# In[ ]:
# verify model exists in es
MlClient.get_trained_models(es)
# In[ ]:
## Test out the pipeline and new model
# In[ ]:
# configure ingest pipeline with inference processor using our model
body = {
"pipeline": {
