def test_daal_naive_bayes_save_load(tc):
logger.info("create frame")
frame = tc.frame.create(data, schema)
logger.info(frame.inspect())
logger.info("model training")
model = tc.daaltk.models.classification.naive_bayes.train(frame, 'Class', ['Dim_1','Dim_2'], num_classes=2)
save_path = get_sandbox_path("daal_naive_bayes_save")
# save model
model.save(save_path)
# load model
loaded_model = tc.load(save_path)
# compare properties in the loaded model to the original model that we saved
assert(model.class_log_prior == loaded_model.class_log_prior)
assert(model.feature_log_prob == loaded_model.feature_log_prob)
assert(model.lambda_parameter == loaded_model.lambda_parameter)
assert(model.label_column == loaded_model.label_column)
assert(model.observation_columns == loaded_model.observation_columns)
# load model through the daal model
daal_loaded_model = tc.daaltk.models.classification.naive_bayes.load(save_path)
# compare properties in the loaded model to the original model that we saved
assert(model.class_log_prior == daal_loaded_model.class_log_prior)
assert(model.feature_log_prob == daal_loaded_model.feature_log_prob)
assert(model.lambda_parameter == daal_loaded_model.lambda_parameter)
assert(model.label_column == daal_loaded_model.label_column)
assert(model.observation_columns == daal_loaded_model.observation_columns)
def test_daal_principal_components_save_load(tc):
logger.info("create frame")
frame = tc.frame.create(data, schema)
logger.info(frame.inspect())
logger.info("model training")
model = tc.daaltk.models.dimensionality_reduction.principal_components.train(
frame, ['1', '2', '3', '4', '5', '6'], mean_centered=True, k=3)
save_path = get_sandbox_path("daal_principal_components_save")
# save model
model.save(save_path)
# load model
loaded_model = tc.load(save_path)
# compare properties in the loaded model to the original model that we saved
assert (model.column_means == loaded_model.column_means)
assert (model.k == loaded_model.k)
assert (model.mean_centered == loaded_model.mean_centered)
assert (model.singular_values == loaded_model.singular_values)
assert (model.vfactor == loaded_model.vfactor)
# load though the daal model
daal_loaded_model = tc.daaltk.models.dimensionality_reduction.principal_components.load(
save_path)
# compare properties in the loaded model to the original model that we saved
assert (model.column_means == daal_loaded_model.column_means)
assert (model.k == daal_loaded_model.k)
assert (model.mean_centered == daal_loaded_model.mean_centered)
assert (model.singular_values == daal_loaded_model.singular_values)
assert (model.vfactor == daal_loaded_model.vfactor)
def test_kmeans_save_load(tc):
frame = tc.to_frame([[2, "ab"],
[1,"cd"],
[7,"ef"],
[1,"gh"],
[9,"ij"],
[2,"kl"],
[0,"mn"],
[6,"op"],
[5,"qr"]],
[("data", float), ("name", str)])
model = kmeans.train(frame, ["data"], 3, seed=5)
assert (model.k == 3)
assert (model.columns == [u'data'])
assert (model.scalings is None)
sizes = model.compute_sizes(frame)
assert (sizes == [4, 1, 4])
centroids = model.centroids
model.save("sandbox/km1")
restored = tc.load("sandbox/km1")
assert(restored.centroids == centroids)
restored_sizes = restored.compute_sizes(frame)
assert (restored_sizes == sizes)
def test_save_load(tc):
path = get_sandbox_path("smoke_save_load")
rm(path)
frame1 = tc.frame.create([[2,"ab"],[1.0,"cd"],[7.4,"ef"],[1.0,"gh"],[9.0,"ij"],[2.0,"kl"],[0,"mn"],[6.0,"op"],[5.0,"qr"]],
[("data", float),("name", str)])
frame1_inspect = frame1.inspect()
frame1.save(path)
frame2 = tc.load(path)
frame2_inspect = frame2.inspect()
assert(frame1_inspect, frame2_inspect)
assert(str(frame1.schema), str(frame2.schema))
def test_arima_save_load(tc):
ts = [12.88969427, 13.54964408, 13.8432745, 12.13843611, 12.81156092, 14.2499628, 15.12102595]
save_path = "sandbox/arima_save_test"
original_model = tc.models.timeseries.arima.train(ts, 1, 0, 1)
original_predict = original_model.predict(0)
# Save model
original_model.save(save_path)
# Load the model and check that it's the same type as the saved model
loaded_model = tc.load(save_path)
assert(type(original_model) == type(loaded_model))
assert(original_model.p == loaded_model.p)
assert(original_model.d == loaded_model.d)
assert(original_model.q == loaded_model.q)
assert(original_model.include_intercept == loaded_model.include_intercept)
assert(original_model.init_params == loaded_model.init_params)
assert(original_model.coefficients == loaded_model.coefficients)
assert(ts == loaded_model.ts_values)
assert(original_predict == loaded_model.predict(0))
def test_arima_save_load(tc):
ts = [
12.88969427, 13.54964408, 13.8432745, 12.13843611, 12.81156092,
14.2499628, 15.12102595
]
save_path = "sandbox/arima_save_test"
original_model = tc.models.timeseries.arima.train(ts, 1, 0, 1)
original_predict = original_model.predict(0)
# Save model
original_model.save(save_path)
# Load the model and check that it's the same type as the saved model
loaded_model = tc.load(save_path)
assert (type(original_model) == type(loaded_model))
assert (original_model.p == loaded_model.p)
assert (original_model.d == loaded_model.d)
assert (original_model.q == loaded_model.q)
assert (original_model.include_intercept == loaded_model.include_intercept)
assert (original_model.init_params == loaded_model.init_params)
assert (original_model.coefficients == loaded_model.coefficients)
assert (ts == loaded_model.ts_values)
assert (original_predict == loaded_model.predict(0))
def test_daal_linear_regression_save_load(tc):
logger.info("create frame")
data = [[0, 0], [1, 2.5], [2, 5.0], [3, 7.5], [4, 10], [5, 12.5],
[6, 13.0], [7, 17.15], [8, 18.5], [9, 23.5]]
schema = [("x1", float), ("y", float)]
frame = tc.frame.create(data, schema)
logger.info(frame.inspect())
logger.info("model training")
model = tc.daaltk.models.regression.linear_regression.train(
frame, 'y', ['x1'])
save_path = get_sandbox_path("daal_linear_reg_save")
# save model
model.save(save_path)
# load model
loaded_model = tc.load(save_path)
# compare properties in the loaded model to the original model that we saved
assert (model.explained_variance == loaded_model.explained_variance)
assert (model.intercept == loaded_model.intercept)
assert (model.mean_absolute_error == loaded_model.mean_absolute_error)
assert (model.r2 == loaded_model.r2)
assert (
model.root_mean_squared_error == loaded_model.root_mean_squared_error)
# load model through daal model
daal_loaded_model = tc.daaltk.models.regression.linear_regression.load(
save_path)
# compare properties in the loaded model to the original model that we saved
assert (model.explained_variance == daal_loaded_model.explained_variance)
assert (model.intercept == daal_loaded_model.intercept)
assert (model.mean_absolute_error == daal_loaded_model.mean_absolute_error)
assert (model.r2 == daal_loaded_model.r2)
assert (model.root_mean_squared_error ==
daal_loaded_model.root_mean_squared_error)
def test_daal_save_load(tc):
logger.info("create frame")
data = [[2, "ab"], [1, "cd"], [7, "ef"], [1, "gh"], [9, "ij"], [2, "kl"],
[0, "mn"], [6, "op"], [5, "qr"], [120, "outlier"]]
schema = [("data", float), ("name", str)]
frame = tc.frame.create(data, schema)
logger.info(frame.inspect())
logger.info("model training")
model = tc.daaltk.models.clustering.kmeans.train(frame, ["data"],
k=2,
max_iterations=20)
save_path = get_sandbox_path("daal_kmeans_save")
# save model
model.save(save_path)
# load model through tc
loaded_model = tc.load(save_path)
# compare properties in the loaded model to the original model that we saved
assert (model.k == loaded_model.k)
assert (model.column_scalings == loaded_model.column_scalings)
assert (model.label_column == loaded_model.label_column)
assert (model.centroids == loaded_model.centroids)
assert (model.cluster_sizes == loaded_model.cluster_sizes)
#load model through daal kmeans
daal_loaded_model = tc.daaltk.models.clustering.kmeans.load(save_path)
# compare properties in the loaded model to the original model that we saved
assert (model.k == daal_loaded_model.k)
assert (model.column_scalings == daal_loaded_model.column_scalings)
assert (model.label_column == daal_loaded_model.label_column)
assert (model.centroids == daal_loaded_model.centroids)
assert (model.cluster_sizes == daal_loaded_model.cluster_sizes)
