def test_scenario5(self):
"""
Scenario: Successfully comparing association sets:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I update the source with params "<options>"
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the association is ready less than <time_3> secs
And I create a local association
When I create an association set for "<data_input>"
Then the association set is like the contents of "<association_set_file>"
And I create a local association set for "<data_input>"
Then the local association set is like the contents of "<association_set_file>"
"""
examples = [
['data/groceries.csv', '20', '20', '30', '{"fields": {"00000": {"optype": "text", "term_analysis": {"token_mode": "all", "language": "en"}}}}', 'data/associations/association_set.json', '{"field1": "cat food"}']]
show_doc(self.test_scenario5, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[4])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
association_create.i_create_an_association_from_dataset(self)
association_create.the_association_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_association(self)
prediction_create.i_create_an_association_set(self, example[6])
prediction_compare.the_association_set_is_like_file(self, example[5])
prediction_compare.i_create_a_local_association_set(self, example[6])
prediction_compare.the_local_association_set_is_like_file(self, example[5])
def test_scenario3(self):
"""
Scenario: Successfully comparing scores from anomaly detectors:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an anomaly detector
And I wait until the anomaly detector is ready less than <time_3> secs
And I create a local anomaly detector
When I create an anomaly score for "<data_input>"
Then the anomaly score is "<score>"
And I create a local anomaly score for "<data_input>"
Then the local anomaly score is "<score>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | score |
"""
examples = [
['data/tiny_kdd.csv', '20', '20', '30', '{"000020": 255.0, "000004": 183.0, "000016": 4.0, "000024": 0.04, "000025": 0.01, "000026": 0.0, "000019": 0.25, "000017": 4.0, "000018": 0.25, "00001e": 0.0, "000005": 8654.0, "000009": "0", "000023": 0.01, "00001f": 123.0}', '0.69802']]
show_doc(self.test_scenario3, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
anomaly_create.i_create_an_anomaly(self)
anomaly_create.the_anomaly_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_anomaly(self)
prediction_create.i_create_an_anomaly_score(self, example[4])
prediction_create.the_anomaly_score_is(self, example[5])
prediction_compare.i_create_a_local_anomaly_score(self, example[4])
prediction_compare.the_local_anomaly_score_is(self, example[5])
def test_scenario2(self):
"""
Scenario: Successfully comparing centroids with configuration options:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a cluster with options "<options>"
And I wait until the cluster is ready less than <time_3> secs
And I create a local cluster
When I create a centroid for "<data_input>"
Then the centroid is "<centroid>" with distance "<distance>"
And I create a local centroid for "<data_input>"
Then the local centroid is "<centroid>" with distance "<distance>"
Examples:
| data | time_1 | time_2 | time_3 | options | data_input | centroid | distance | full_data_input
"""
examples = [
['data/iris.csv', '30', '30', '30', '{"summary_fields": ["sepal width"]}', '{"petal length": 1, "petal width": 1, "sepal length": 1, "species": "Iris-setosa"}', 'Cluster 2', '1.16436', '{"petal length": 1, "petal width": 1, "sepal length": 1, "species": "Iris-setosa"}'],
['data/iris.csv', '20', '20', '30', '{"default_numeric_value": "zero"}', '{"petal length": 1}', 'Cluster 4', '1.41215', '{"petal length": 1, "petal width": 0, "sepal length": 0, "sepal width": 0, "species": ""}']]
show_doc(self.test_scenario2, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
cluster_create.i_create_a_cluster_with_options(self, example[4])
cluster_create.the_cluster_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_cluster(self)
prediction_create.i_create_a_centroid(self, example[8])
prediction_create.the_centroid_is_with_distance(self, example[6], example[7])
prediction_compare.i_create_a_local_centroid(self, example[5])
prediction_compare.the_local_centroid_is(self, example[6], example[7])
def test_scenario2(self):
"""
Scenario: Successfully comparing centroids with configuration options:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a cluster with options "<options>"
And I wait until the cluster is ready less than <time_3> secs
And I create a local cluster
When I create a centroid for "<data_input>"
Then the centroid is "<centroid>" with distance "<distance>"
And I create a local centroid for "<data_input>"
Then the local centroid is "<centroid>" with distance "<distance>"
Examples:
| data | time_1 | time_2 | time_3 | options | data_input | centroid | distance | full_data_input
"""
examples = [
['data/iris.csv', '20', '20', '30', '{"summary_fields": ["sepal width"]}', '{"petal length": 1, "petal width": 1, "sepal length": 1, "species": "Iris-setosa"}', 'Cluster 2', '1.16436', '{"petal length": 1, "petal width": 1, "sepal length": 1, "species": "Iris-setosa"}'],
['data/iris.csv', '20', '20', '30', '{"default_numeric_value": "zero"}', '{"petal length": 1}', 'Cluster 4', '1.41215', '{"petal length": 1, "petal width": 0, "sepal length": 0, "sepal width": 0, "species": ""}']]
show_doc(self.test_scenario2, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
cluster_create.i_create_a_cluster_with_options(self, example[4])
cluster_create.the_cluster_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_cluster(self)
prediction_create.i_create_a_centroid(self, example[8])
prediction_create.the_centroid_is_with_distance(self, example[6], example[7])
prediction_compare.i_create_a_local_centroid(self, example[5])
prediction_compare.the_local_centroid_is(self, example[6], example[7])
def test_scenario5(self):
"""
Scenario: Successfully comparing association sets:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I update the source with params "<options>"
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the association is ready less than <time_3> secs
And I create a local association
When I create an association set for "<data_input>"
Then the association set is like the contents of "<association_set_file>"
And I create a local association set for "<data_input>"
Then the local association set is like the contents of "<association_set_file>"
"""
examples = [
['data/groceries.csv', '20', '20', '30', '{"fields": {"00000": {"optype": "text", "term_analysis": {"token_mode": "all", "language": "en"}}}}', 'data/associations/association_set.json', '{"field1": "cat food"}']]
show_doc(self.test_scenario5, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[4])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
association_create.i_create_an_association_from_dataset(self)
association_create.the_association_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_association(self)
prediction_create.i_create_an_association_set(self, example[6])
prediction_compare.the_association_set_is_like_file(self, example[5])
prediction_compare.i_create_a_local_association_set(self, example[6])
prediction_compare.the_local_association_set_is_like_file(self, example[5])
def test_scenario3(self):
"""
Scenario: Successfully comparing scores from anomaly detectors:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an anomaly detector
And I wait until the anomaly detector is ready less than <time_3> secs
And I create a local anomaly detector
When I create an anomaly score for "<data_input>"
Then the anomaly score is "<score>"
And I create a local anomaly score for "<data_input>"
Then the local anomaly score is "<score>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | score |
"""
examples = [
['data/tiny_kdd.csv', '30', '30', '30', '{"000020": 255.0, "000004": 183.0, "000016": 4.0, "000024": 0.04, "000025": 0.01, "000026": 0.0, "000019": 0.25, "000017": 4.0, "000018": 0.25, "00001e": 0.0, "000005": 8654.0, "000009": "0", "000023": 0.01, "00001f": 123.0}', '0.69802']]
show_doc(self.test_scenario3, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
anomaly_create.i_create_an_anomaly(self)
anomaly_create.the_anomaly_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_anomaly(self)
prediction_create.i_create_an_anomaly_score(self, example[4])
prediction_create.the_anomaly_score_is(self, example[5])
prediction_compare.i_create_a_local_anomaly_score(self, example[4])
prediction_compare.the_local_anomaly_score_is(self, example[5])
def test_scenario5(self):
"""
Scenario: Successfully comparing projections for PCAs:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a PCA with "<params>"
And I wait until the PCA is ready less than <time_3> secs
And I create a local PCA
When I create a projection for "<input_data>"
Then the projection is "<projection>"
And I create a local projection for "<data_input>"
Then the local projection is "<projection>"
Examples:
| data | time_1 | time_2 | time_3 | input_data | projection | params
"""
examples = [
[
'data/iris.csv', '30', '30', '120', '{}',
'{"PC2": 0, "PC3": 0, "PC1": 0, "PC6": 0, "PC4": 5e-05, "PC5": 0}',
'{}'
],
[
'data/iris.csv', '30', '30', '120', '{"petal length": 1}',
'{"PC2": 0.08708, "PC3": 0.20929, "PC1": 1.56084, "PC6": -1.34463, "PC4": 0.7295, "PC5": -1.00876}',
'{}'
],
[
'data/iris.csv', '30', '30', '120',
'{"species": "Iris-versicolor"}',
'{"PC2": 1.8602, "PC3": -2.00864, "PC1": -0.61116, "PC6": -0.66983, "PC4": -2.44618, "PC5": 0.43414}',
'{}'
],
[
'data/iris.csv', '30', '30', '120',
'{"petal length": 1, "sepal length": 0, "petal width": 0, "sepal width": 0, "species": "Iris-versicolor"}',
'{"PC2": 7.18009, "PC3": 6.51511, "PC1": 2.78155, "PC6": 0.21372, "PC4": -1.94865, "PC5": 0.57646}',
'{}'
]
]
show_doc(self.test_scenario5, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
pca_create.i_create_a_pca_with_params(self, example[6])
pca_create.the_pca_is_finished_in_less_than(self, example[3])
compare_predictions.create_local_pca(self)
projection_create.i_create_a_projection(self, example[4])
projection_create.the_projection_is(self, example[5])
compare_predictions.i_create_a_local_projection(self, example[4])
compare_predictions.the_local_projection_is(self, example[5])
def test_scenario2(self):
"""
Scenario: Successfully comparing remote and local predictions
with raw date input for cluster
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a cluster
And I wait until the cluster is ready less than <time_3> secs
And I create a local cluster
When I create a centroid for "<data_input>"
Then the centroid is "<centroid>" with distance "<distance>"
And I create a local centroid for "<data_input>"
Then the local centroid is "<centroid>" with
distance "<distance>"
Examples headers:
|data|time_1|time_2|time_3|data_input|centroid|distance|
"""
examples = [
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"1910-05-08T19:10:23.106","cat-0":"cat2","target-2":0.4}',
"Cluster 2", 0.92112
],
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"1920-06-30T20:21:20.320","cat-0":"cat1","target-2":0.2}',
"Cluster 3", 0.77389
],
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"1932-01-30T19:24:11.440","cat-0":"cat2","target-2":0.1}',
"Cluster 0", 0.87855
],
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"1950-11-06T05:34:05.602","cat-0":"cat1" ,"target-2":0.9}',
"Cluster 6", 0.83506
]
]
show_doc(self.test_scenario2, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
cluster_create.i_create_a_cluster(self)
cluster_create.the_cluster_is_finished_in_less_than(
self, example[3])
prediction_compare.i_create_a_local_cluster(self)
prediction_create.i_create_a_centroid(self, example[4])
prediction_create.the_centroid_is_with_distance(
self, example[5], example[6])
prediction_compare.i_create_a_local_centroid(self, example[4])
prediction_compare.the_local_centroid_is(self, example[5],
example[6])
def test_scenario7(self):
"""
Scenario: Successfully comparing predictions with text options:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I update the source with params "<options>"
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a logistic regression model with objective "<objective>"
And I wait until the logistic regression model is ready less than <time_3> secs
And I create a local logistic regression model
When I create a logistic regression prediction for "<data_input>"
Then the logistic regression prediction is "<prediction>"
And the logistic regression probability for the prediction is "<probability>"
And I create a local logistic regression prediction for "<data_input>"
Then the local logistic regression prediction is "<prediction>"
And the local logistic regression probability for the prediction is "<probability>"
Examples:
| data | time_1 | time_2 | objective | time_3 | options | data_input | prediction | probability
"""
examples = [
[
'data/spam.csv', '20', '20', '180',
'{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}}',
'{"Message": "A normal message"}', 'ham', 0.9169, "000000"
],
[
'data/spam.csv', '20', '20', '180',
'{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "all", "language": "en"}}}}',
'{"Message": "mobile"}', 'ham', 0.815, "000000"
],
[
'data/movies.csv', '20', '20', '180',
'{"fields": {"000007": {"optype": "items", "item_analysis": {"separator": "$"}}}}',
'{"gender": "Female", "genres": "Adventure$Action", "timestamp": 993906291, "occupation": "K-12 student", "zipcode": 59583, "rating": 3}',
'Under 18', '0.8393', '000002'
]
]
show_doc(self.test_scenario7, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[4])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
model_create.i_create_a_logistic_model_with_objective_and_parms(
self, example[8])
model_create.the_logistic_model_is_finished_in_less_than(
self, example[3])
prediction_compare.i_create_a_local_logistic_model(self)
prediction_create.i_create_a_logistic_prediction(self, example[5])
prediction_create.the_logistic_prediction_is(self, example[6])
prediction_create.the_logistic_probability_is(self, example[7])
prediction_compare.i_create_a_local_prediction(self, example[5])
prediction_compare.the_local_prediction_is(self, example[6])
prediction_compare.the_local_probability_is(self, example[7])
def test_scenario10(self):
"""
Scenario: Successfully comparing predictions for linear regression:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a linear regression with objective "<objective>" and "<params>"
And I wait until the linear regression is ready less than <time_3> secs
And I create a local linear regression
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | params
"""
examples = [
[
'data/grades.csv', '10', '50', '30000',
'{"000000": 1, "000001": 1, "000002": 1}', '000005', 29.63024,
'{"input_fields": ["000000", "000001", "000002"]}'
],
[
'data/iris.csv', '10', '50', '30000',
'{"000000": 1, "000001": 1, "000004": "Iris-virginica"}',
'000003', 1.21187,
'{"input_fields": ["000000", "000001", "000004"]}'
],
[
'data/movies.csv', '10', '50', '30000', '{"000007": "Action"}',
'000009', 4.33333, '{"input_fields": ["000007"]}'
],
[
'data/movies.csv', '10', '50', '30000', '{"000006": "1999"}',
'000009', 3.28427,
'{"input_fields": ["000006"], "bias": false}'
]
]
show_doc(self.test_scenario10, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
linear_create.i_create_a_linear_regression_with_objective_and_params( \
self, example[5], example[7])
linear_create.the_linear_regression_is_finished_in_less_than( \
self, example[3])
prediction_compare.i_create_a_local_linear(self)
prediction_create.i_create_a_linear_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_local_linear_prediction(
self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario10(self):
"""
Scenario: Successfully comparing predictions for fusions:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I retrieve a list of remote models tagged with "<tag>"
And I create a fusion from a list of models
And I wait until the fusion is ready less than <time_4> secs
And I create a local fusion
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | params| tag | data_input | objective | prediction | params
"""
examples = [[
'data/iris_unbalanced.csv', '30', '30', '120', '120',
'{"tags":["my_fusion_tag"]}', 'my_fusion_tag',
'{"petal width": 4}', '000004', 'Iris-virginica'
],
[
'data/grades.csv', '30', '30', '120', '120',
'{"tags":["my_fusion_tag_reg"]}', 'my_fusion_tag_reg',
'{"Midterm": 20}', '000005', 43.65286
]]
show_doc(self.test_scenario10, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_retrieve_a_list_of_remote_models(
self, example[6])
model_create.i_create_a_fusion(self)
model_create.the_fusion_is_finished_in_less_than(self, example[4])
prediction_compare.i_create_a_local_fusion(self)
prediction_create.i_create_a_fusion_prediction(self, example[7])
prediction_create.the_prediction_is(self, example[8], example[9])
prediction_compare.i_create_a_local_prediction(self, example[7])
prediction_compare.the_local_prediction_is(self, example[9])
def test_scenario1(self):
"""
Scenario: Successfully comparing predictions for deepnets:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a deepnet with objective "<objective>" and "<params>"
And I wait until the deepnet is ready less than <time_3> secs
And I create a local deepnet
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | params,
"""
examples = [[
'data/iris.csv', '30', '50', '30000', '{"petal width": 4}',
'000004', 'Iris-virginica', '{}'
],
[
'data/iris.csv', '30', '50', '30000',
'{"sepal length": 4.1, "sepal width": 2.4}', '000004',
'Iris-setosa', '{}'
],
[
'data/iris_missing2.csv', '30', '50', '30000', '{}',
'000004', 'Iris-setosa', '{}'
],
[
'data/grades.csv', '30', '50', '30000', '{}', '000005',
42.15473, '{}'
],
[
'data/spam.csv', '30', '50', '30000', '{}', '000000',
'ham', '{}'
]]
show_doc(self.test_scenario1, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
model_create.i_create_a_deepnet_with_objective_and_params(
self, example[5], example[7])
model_create.the_deepnet_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_deepnet(self)
prediction_create.i_create_a_deepnet_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_local_deepnet_prediction(
self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario1c(self):
"""
Scenario: Successfully comparing remote and local predictions
with raw date input for anomaly detectors
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an anomaly detector
And I wait until the anomaly detector is ready less
than <time_3> secs
And I create a local anomaly detector
When I create an anomaly score for "<data_input>"
Then the anomaly score is "<score>"
And I create a local anomaly score for "<data_input>"
Then the local anomaly score is "<score>"
Examples:
|data|time_1|time_2|time_3|data_input|score|
"""
examples = [
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"2001-01-05T23:04:04.693","cat-0":"cat2","target-2":0.01}',
0.54911
],
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"2011-04-01T00:16:45.747","cat-0":"cat2","target-2":0.32}',
0.52477
],
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"1969-W29-1T17:36:39Z","cat-0":"cat1","target-2":0.87}',
0.93678
],
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"Mon Jul 14 17:36 +0000 1969","cat-0":"cat1","target-2":0}',
0.93717
]
]
show_doc(self.test_scenario1c, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
anomaly_create.i_create_an_anomaly(self)
anomaly_create.the_anomaly_is_finished_in_less_than(
self, example[3])
prediction_compare.i_create_a_local_anomaly(self)
prediction_create.i_create_an_anomaly_score(self, example[4])
prediction_create.the_anomaly_score_is(self, example[5])
prediction_compare.i_create_a_local_anomaly_score(self, example[4])
prediction_compare.the_local_anomaly_score_is(self, example[5])
def test_scenario11(self):
"""
Scenario: Successfully comparing remote and local predictions
with raw date input for linear regression:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a linear regression
And I wait until the linear regression is ready
less than <time_3> secs
And I create a local linear regression
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
|data|time_1|time_2|time_3|data_input|objective|prediction
"""
examples = [
['data/dates2.csv', '20', '20', '25',
'{"time-1": "1910-05-08T19:10:23.106", "cat-0":"cat2"}',
'000002', -0.01284],
['data/dates2.csv', '20', '20', '25',
'{"time-1": "1920-06-30T20:21:20.320", "cat-0":"cat1"}',
'000002', -0.09459],
['data/dates2.csv', '20', '20', '25',
'{"time-1": "1932-01-30T19:24:11.440", "cat-0":"cat2"}',
'000002', -0.02259],
['data/dates2.csv', '20', '20', '25',
'{"time-1": "1950-11-06T05:34:05.252", "cat-0":"cat1"}',
'000002', -0.06754],
['data/dates2.csv', '20', '20', '25',
'{"time-1": "2001-01-05T23:04:04.693", "cat-0":"cat2"}',
'000002', 0.05204],
['data/dates2.csv', '20', '20', '25',
'{"time-1": "2011-04-01T00:16:45.747", "cat-0":"cat2"}',
'000002', 0.05878]]
show_doc(self.test_scenario11, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self,
example[2])
linear_create.i_create_a_linear_regression(self)
linear_create.the_linear_regression_is_finished_in_less_than(self,
example[3])
prediction_compare.i_create_a_local_linear(self)
prediction_create.i_create_a_linear_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_local_linear_prediction(self,
example[4])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario6(self):
"""
Scenario: Successfully comparing predictions for ensembles:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an ensemble with "<params>"
And I wait until the ensemble is ready less than <time_3> secs
And I create a local ensemble
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | params
['data/iris.csv', '10', '10', '120', '{"petal width": 0.5}', '000004', 'Iris-versicolor', '{"number_of_models": 5}'],
['data/iris.csv', '10', '10', '120', '{"petal length": 6, "petal width": 2}', '000004', 'Iris-virginica', '{"number_of_models": 5}'],
['data/iris.csv', '10', '10', '120', '{"petal length": 4, "petal width": 1.5}', '000004', 'Iris-versicolor', '{"number_of_models": 5}'],
['data/grades.csv', '10', '10', '120', '{"Midterm": 20}', '000005', 46.261364, '{"number_of_models": 5}'],
['data/iris.csv', '10', '10', '120', '{"petal width": 0.5}', '000004', 'Iris-setosa', '{"boosting": {"iterations": 5}, "number_of_models": 5}'],
['data/iris.csv', '10', '10', '120', '{"petal length": 6, "petal width": 2}', '000004', 'Iris-virginica', '{"boosting": {"iterations": 5}, "number_of_models": 5}'],
['data/iris.csv', '10', '10', '120', '{"petal length": 4, "petal width": 1.5}', '000004', 'Iris-versicolor', '{"boosting": {"iterations": 5}, "number_of_models": 5}'],
"""
examples = [
[
'data/iris_unbalanced.csv', '10', '10', '120',
'{"petal width": 4}', '000004', 'Iris-virginica',
'{"boosting": {"iterations": 5}, "number_of_models": 5}'
],
[
'data/grades.csv', '10', '10', '120', '{"Midterm": 20}',
'000005', 61.61036,
'{"boosting": {"iterations": 5}, "number_of_models": 5}'
]
]
show_doc(self.test_scenario6, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
ensemble_create.i_create_an_ensemble_with_params(self, example[7])
ensemble_create.the_ensemble_is_finished_in_less_than(
self, example[3])
ensemble_create.create_local_ensemble(self)
prediction_create.i_create_an_ensemble_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_local_ensemble_prediction(
self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario5(self):
"""
Scenario: Successfully comparing predictions in operating kind for models:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the model is ready less than <time_3> secs
And I create a local model
When I create a prediction for "<data_input>" in "<operating_kind>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>" in "<operating_kind>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | prediction | operating_point
"""
examples = [[
'data/iris.csv', '10', '50', '50',
'{"petal length": 2.46, "sepal length": 5}', 'Iris-versicolor',
"probability", "000004"
],
[
'data/iris.csv', '10', '50', '50',
'{"petal length": 2.46, "sepal length": 5}',
'Iris-versicolor', "confidence", "000004"
],
[
'data/iris.csv', '10', '50', '50',
'{"petal length": 2}', 'Iris-setosa', "probability",
"000004"
],
[
'data/iris.csv', '10', '50', '50',
'{"petal length": 2}', 'Iris-setosa', "confidence",
"000004"
]]
show_doc(self.test_scenario5, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
model_create.i_create_a_model(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_model(self)
prediction_create.i_create_a_prediction_op_kind(
self, example[4], example[6])
prediction_create.the_prediction_is(self, example[7], example[5])
prediction_compare.i_create_a_local_prediction_op_kind(
self, example[4], example[6])
prediction_compare.the_local_prediction_is(self, example[5])
def test_scenario3(self):
"""
Scenario: Successfully comparing predictions with proportional missing strategy:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the model is ready less than <time_3> secs
And I create a local model
When I create a proportional missing strategy prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And the confidence for the prediction is "<confidence>"
And I create a proportional missing strategy local prediction for "<data_input>"
Then the local prediction is "<prediction>"
And the local prediction's confidence is "<confidence>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | confidence |
"""
examples = [[
'data/iris.csv', '10', '10', '10', '{}', '000004', 'Iris-setosa',
'0.2629'
],
[
'data/grades.csv', '10', '10', '10', '{}', '000005',
'68.62224', '27.5358'
],
[
'data/grades.csv', '10', '10', '10', '{"Midterm": 20}',
'000005', '40.46667', '54.89713'
],
[
'data/grades.csv', '10', '10', '10',
'{"Midterm": 20, "Tutorial": 90, "TakeHome": 100}',
'000005', '28.06', '25.65806'
]]
show_doc(self.test_scenario3, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
model_create.i_create_a_model(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_model(self)
prediction_create.i_create_a_proportional_prediction(
self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_create.the_confidence_is(self, example[7])
prediction_compare.i_create_a_proportional_local_prediction(
self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
prediction_compare.the_local_prediction_confidence_is(
self, example[7])
def test_scenario2(self):
"""
Scenario: Successfully comparing forecasts from time series with "A" seasonality
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a time series with "<params>"
And I wait until the time series is ready less than <time_3> secs
And I create a local time series
When I create a forecast for "<input_data>"
Then the forecast is "<forecasts>"
And I create a local forecast for "<data_input>"
Then the local forecast is "<forecasts>"
Examples:
| data | time_1 | time_2 | time_3 | input_data | forecasts | params
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["A,Ad,A"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast":[66.16225, 72.17308, 66.65573, 73.09698, 70.51449], "model": "A,Ad,A"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}']
"""
examples = [
[
'data/grades.csv', '30', '30', '120',
'{"000005": {"horizon": 5}}',
'{"000005": [{"point_forecast": [73.96192, 74.04106, 74.12029, 74.1996, 74.27899], "model": "M,M,N"}]}',
'{"objective_fields": ["000001", "000005"], "period": 12}'
],
[
'data/grades.csv', '30', '30', '120',
'{"000005": {"horizon": 5, "ets_models": {"names": ["M,N,A"], "criterion": "aic", "limit": 3}}}',
'{"000005": [{"point_forecast": [67.43222, 68.24468, 64.14437, 67.5662, 67.79028], "model": "M,N,A"}]}',
'{"objective_fields": ["000001", "000005"], "period": 12}'
],
[
'data/grades.csv', '30', '30', '120',
'{"000005": {"horizon": 5, "ets_models": {"names": ["A,A,A"], "criterion": "aic", "limit": 3}}}',
'{"000005": [{"point_forecast": [74.73553, 71.6163, 71.90264, 76.4249, 75.06982], "model": "A,A,A"}]}',
'{"objective_fields": ["000001", "000005"], "period": 12}'
]
]
show_doc(self.test_scenario2, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
time_series_create.i_create_a_time_series_with_params(
self, example[6])
time_series_create.the_time_series_is_finished_in_less_than(
self, example[3])
time_series_create.create_local_time_series(self)
forecast_create.i_create_a_forecast(self, example[4])
forecast_create.the_forecast_is(self, example[5])
forecast_compare.i_create_a_local_forecast(self, example[4])
forecast_compare.the_local_forecast_is(self, example[5])
def test_scenario9(self):
"""
Scenario: Successfully comparing predictions for ensembles with proportional missing strategy in a supervised model:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an esemble with "<params>"
And I wait until the ensemble is ready less than <time_3> secs
And I create a local ensemble
When I create a proportional missing strategy prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And the confidence for the prediction is "<confidence>"
And I create a proportional missing strategy local prediction for "<data_input>"
Then the local prediction is "<prediction>"
And the local prediction's confidence is "<confidence>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | confidence | params
['data/iris.csv', '10', '10', '50', '{}', '000004', 'Iris-virginica', '0.33784', '{"boosting": {"iterations": 5}}'],
"""
examples = [[
'data/iris.csv', '10', '10', '50', '{}', '000004',
'Iris-virginica', '0.33784', '{"boosting": {"iterations": 5}}', {}
],
[
'data/iris.csv', '10', '10', '50', '{}', '000004',
'Iris-versicolor', '0.27261',
'{"number_of_models": 5"}', {
"operating_kind": "confidence"
}
]]
show_doc(self.test_scenario7, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
ensemble_create.i_create_an_ensemble_with_params(self, example[8])
ensemble_create.the_ensemble_is_finished_in_less_than(
self, example[3])
ensemble_create.create_local_supervised_ensemble(self)
prediction_create.i_create_an_ensemble_proportional_prediction(
self, example[4], example[9])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_create.the_confidence_is(self, example[7])
prediction_create.create_local_ensemble_proportional_prediction_with_confidence(
self, example[4], example[9])
prediction_compare.the_local_ensemble_prediction_is(
self, example[6])
prediction_compare.the_local_prediction_confidence_is(
self, example[7])
def test_scenario10(self):
"""
Scenario: Successfully comparing predictions with proportional missing strategy and balanced models:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a balanced model
And I wait until the model is ready less than <time_3> secs
And I create a local model
When I create a proportional missing strategy prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And the confidence for the prediction is "<confidence>"
And I create a proportional missing strategy local prediction for "<data_input>"
Then the local prediction is "<prediction>"
And the local prediction's confidence is "<confidence>"
And I create local probabilities for "<data_input>"
Then the local probabilities are "<probabilities>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | confidence |
"""
examples = [
[
'data/iris_unbalanced.csv', '10', '10', '10', '{}', '000004',
'Iris-setosa', '0.25284', '[0.33333, 0.33333, 0.33333]'
],
[
'data/iris_unbalanced.csv', '10', '10', '10',
'{"petal length":1, "sepal length":1, "petal width": 1, "sepal width": 1}',
'000004', 'Iris-setosa', '0.7575', '[1.0, 0.0, 0.0]'
]
]
show_doc(self.test_scenario10, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
model_create.i_create_a_balanced_model(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_model(self)
prediction_create.i_create_a_proportional_prediction(
self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_proportional_local_prediction(
self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
prediction_create.the_confidence_is(self, example[7])
prediction_compare.the_local_prediction_confidence_is(
self, example[7])
prediction_compare.i_create_local_probabilities(self, example[4])
prediction_compare.the_local_probabilities_are(self, example[8])
def test_scenario13(self):
"""
Scenario: Successfully comparing predictions for fusions:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I retrieve a list of remote models tagged with "<tag>"
And I create a fusion from a list of models
And I wait until the fusion is ready less than <time_4> secs
And I create a local fusion
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | params| tag | data_input | objective | prediction | params
"""
examples = [[
'data/grades.csv', '30', '30', '120', '120', 'my_fusion_tag_lreg',
'{"000000": 10, "000001": 10, "000002": 10, "000003": 10, "000004": 10}',
'000005', 21.01712
]]
show_doc(self.test_scenario13, examples)
for example in examples:
print "\nTesting with:\n", example
tag = "%s_%s" % (example[5], PY3)
tag_args = '{"tags":["%s"]}' % tag
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
linear_create.i_create_a_linear_regression_with_params(
self, tag_args)
linear_create.the_linear_regression_is_finished_in_less_than(
self, example[3])
prediction_compare.i_retrieve_a_list_of_remote_linear_regressions(
self, tag)
model_create.i_create_a_fusion(self)
model_create.the_fusion_is_finished_in_less_than(self, example[4])
prediction_compare.i_create_a_local_fusion(self)
prediction_create.i_create_a_fusion_prediction(self, example[6])
prediction_create.the_prediction_is(self, example[7], example[8])
prediction_compare.i_create_a_local_prediction(self, example[6])
prediction_compare.the_local_prediction_is(self, example[8])
def test_scenario1b(self):
"""
Scenario: Successfully comparing remote and local predictions
with raw date input for anomaly detectors
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an anomaly detector
And I wait until the anomaly detector is ready less
than <time_3> secs
And I create a local anomaly detector
When I create an anomaly score for "<data_input>"
Then the anomaly score is "<score>"
And I create a local anomaly score for "<data_input>"
Then the local anomaly score is "<score>"
Examples:
|data|time_1|time_2|time_3|data_input|score|
"""
examples = [
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"1932-01-30T19:24:11.440","cat-0":"cat2","target-2":0.1}',
0.54343
],
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"1950-11-06T05:34:05.602","cat-0":"cat1" ,"target-2":0.9}',
0.5202
],
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"1969-7-14 17:36","cat-0":"cat2","target-2":0.9}',
0.93639
]
]
show_doc(self.test_scenario1b, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
anomaly_create.i_create_an_anomaly(self)
anomaly_create.the_anomaly_is_finished_in_less_than(
self, example[3])
prediction_compare.i_create_a_local_anomaly(self)
prediction_create.i_create_an_anomaly_score(self, example[4])
prediction_create.the_anomaly_score_is(self, example[5])
prediction_compare.i_create_a_local_anomaly_score(self, example[4])
prediction_compare.the_local_anomaly_score_is(self, example[5])
def test_scenario12(self):
"""
Scenario: Successfully comparing predictions for fusions:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I retrieve a list of remote models tagged with "<tag>"
And I create a fusion from a list of models
And I wait until the fusion is ready less than <time_4> secs
And I create a local fusion
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | params| tag | data_input | objective | prediction | params
"""
tag = "my_fusion_tag_12_%s" % PY3
tag_reg = "my_fusion_tag_12_reg_%s" % PY3
examples = [
['data/iris_unbalanced.csv', '30', '30', '120', '120', '{"tags":["%s"], "sample_rate": 0.8, "seed": "bigml"}' % tag, tag, '{"petal width": 4}', '000004', 'Iris-virginica'],
['data/grades.csv', '30', '30', '120', '120', '{"tags":["%s"], "sample_rate": 0.8, "seed": "bigml"}' % tag_reg, tag_reg, '{"Midterm": 20}', '000005', 44.37625]]
show_doc(self.test_scenario12, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_retrieve_a_list_of_remote_models(self, example[6])
model_create.i_create_a_fusion_with_weights(self)
model_create.the_fusion_is_finished_in_less_than(self, example[4])
prediction_compare.i_create_a_local_fusion(self)
prediction_create.i_create_a_fusion_prediction(self, example[7])
prediction_create.the_prediction_is(self, example[8], example[9])
prediction_compare.i_create_a_local_prediction(self, example[7])
prediction_compare.the_local_prediction_is(self, example[9])
def test_scenario11(self):
"""
Scenario: Successfully comparing predictions in operating points for fusions:
Scenario: Successfully comparing predictions for fusions:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I retrieve a list of remote models tagged with "<tag>"
And I create a fusion from a list of models
And I wait until the fusion is ready less than <time_4> secs
And I create a local fusion
When I create a prediction for "<data_input>" in "<operating_point>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local fusion prediction for "<data_input>" in "<operating_point>"
Then the local ensemble prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | params| tag | data_input | objective | prediction | params | operating_point
"""
examples = [
['data/iris_unbalanced.csv', '30', '30', '120', '120', '{"tags":["my_fusion_tag_11"]}', 'my_fusion_tag_11', '{"petal width": 4}', '000004', 'Iris-virginica', {"kind": "probability", "threshold": 0.1, "positive_class": "Iris-setosa"}],
['data/iris_unbalanced.csv', '30', '30', '120', '120', '{"tags":["my_fusion_tag_11_b"]}', 'my_fusion_tag_11_b', '{"petal width": 4}', '000004', 'Iris-virginica', {"kind": "probability", "threshold": 0.9, "positive_class": "Iris-setosa"}]]
show_doc(self.test_scenario11, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_retrieve_a_list_of_remote_models(self, example[6])
model_create.i_create_a_fusion(self)
model_create.the_fusion_is_finished_in_less_than(self, example[4])
prediction_compare.i_create_a_local_fusion(self)
prediction_create.i_create_a_fusion_prediction_op(self, example[7], example[10])
prediction_create.the_prediction_is(self, example[8], example[9])
prediction_compare.i_create_a_local_prediction_op(self, example[7], example[10])
prediction_compare.the_local_prediction_is(self, example[9])
def test_scenario14(self):
"""
Scenario: Successfully comparing predictions with supervised model:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the model is ready less than <time_3> secs
And I create a local supervised model
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction |
"""
examples = [[
'data/iris.csv', '10', '10', '10', '{"petal width": 0.5}',
'000004', 'Iris-setosa'
],
[
'data/iris.csv', '10', '10', '10',
'{"petal length": 6, "petal width": 2}', '000004',
'Iris-virginica'
],
[
'data/iris.csv', '10', '10', '10',
'{"petal length": 4, "petal width": 1.5}', '000004',
'Iris-versicolor'
],
[
'data/iris_sp_chars.csv', '10', '10', '10',
'{"pétal.length": 4, "pétal&width\u0000": 1.5}',
'000004', 'Iris-versicolor'
]]
show_doc(self.test_scenario14, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
model_create.i_create_a_model(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_supervised_model(self)
prediction_create.i_create_a_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_local_prediction(self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario4(self):
"""
Scenario: Successfully comparing topic distributions:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I update the source with params "<options>"
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a topic model
And I wait until the topic model is ready less than <time_3> secs
And I create a local topic model
When I create a topic distribution for "<data_input>"
Then the topic distribution is "<topic_distribution>"
And I create a local topic distribution for "<data_input>"
Then the local topic distribution is "<topic_distribution>"
Examples headers:
| data | time_1 | time_2 | time_3 | options | data_input | topic distribution |
"""
examples = [
[
'data/spam.csv', '20', '20', '30',
'{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}',
'{"Type": "ham", "Message": "Mobile call"}',
'[0.01878, 0.00388, 0.00388, 0.00388, 0.20313, 0.47315, 0.00574, 0.05695, 0.00388, 0.19382, 0.00388, 0.02902]'
],
[
'data/spam.csv', '20', '20', '30',
'{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}',
'{"Type": "ham", "Message": "Go until jurong point, crazy.. Available only in bugis n great world la e buffet... Cine there got amore wat..."}',
'[0.00263, 0.01083, 0.00831, 0.06004, 0.33701, 0.00263, 0.01209, 0.44553, 0.0531, 0.00326, 0.06193, 0.00263]'
]
]
show_doc(self.test_scenario4, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[4])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
topic_create.i_create_a_topic_model(self)
topic_create.the_topic_model_is_finished_in_less_than(
self, example[3])
prediction_compare.i_create_a_local_topic_model(self)
topic_create.i_create_a_local_topic_distribution(self, example[5])
prediction_compare.the_local_topic_distribution_is(
self, example[6])
topic_create.i_create_a_topic_distribution(self, example[5])
prediction_compare.the_topic_distribution_is(self, example[6])
def test_scenario3(self):
"""
Scenario: Successfully comparing predictions:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the model is ready less than <time_3> secs
And I create a local model
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction |
"""
examples = [
[
'data/iris_missing.csv', '30',
'{"fields": {"000000": {"optype": "numeric"}}, "source_parser": {"missing_tokens": ["foo"]}}',
'30', '{"sepal length": "foo", "petal length": 3}', '000004',
'Iris-versicolor'
],
[
'data/iris_missing.csv', '30',
'{"fields": {"000000": {"optype": "numeric"}}, "source_parser": {"missing_tokens": ["foo"]}}',
'30',
'{"sepal length": "foo", "petal length": 5, "petal width": 1.5}',
'000004', 'Iris-virginica'
]
]
show_doc(self.test_scenario3, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[2])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[3])
model_create.i_create_a_model(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_model(self)
prediction_create.i_create_a_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_local_prediction(self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario6(self):
"""
Scenario: Successfully comparing projections for PCAs:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a PCA with "<params>"
And I wait until the PCA is ready less than <time_3> secs
And I create a local PCA
When I create a projection for "<input_data>"
Then the projection is "<projection>"
And I create a local projection for "<data_input>"
Then the local projection is "<projection>"
Examples:
| data | time_1 | time_2 | time_3 | input_data | projection | params
"""
examples = [
[
'data/spam_tiny.csv', '30', '30', '30',
'{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "all"}}}}',
'{"Message": "early"}', '{}',
'{"PC40": 0.00416, "PC38": 0.08267, "PC39": 0.00033, "PC18": 0.28094, "PC19": -0.15056, "PC14": 0.20643, "PC15": 0.23931, "PC16": 0.03251, "PC17": 0.02776, "PC10": 0.1424, "PC11": 0.4059, "PC12": -0.1238, "PC13": 0.15131, "PC43": 0.29617, "PC42": 1.0091, "PC41": 0, "PC25": 0.07164, "PC24": -0.29904, "PC27": -0.1331, "PC26": -0.18572, "PC21": 0.25616, "PC20": 0.30424, "PC23": -0.45775, "PC22": -0.3362, "PC47": -0.13757, "PC49": 0.01864, "PC48": 0.04742, "PC29": -0.16286, "PC28": 0.42207, "PC32": -0.05917, "PC46": -0.05018, "PC31": -0.13973, "PC45": -0.05015, "PC36": 0.03017, "PC44": 0, "PC37": -0.06093, "PC34": 0.25821, "PC35": -0.22194, "PC33": -0.23398, "PC8": 0.01159, "PC9": -0.16042, "PC2": -0.09202, "PC3": 0.14371, "PC1": 0.65114, "PC6": -0.43034, "PC7": -0.02563, "PC4": -0.04947, "PC5": -0.07796, "PC50": -0.00769, "PC30": 0.07813}'
],
[
'data/spam_tiny.csv', '30', '30', '30',
'{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "all"}}}}',
'{"Message": "mobile call"}', '{}',
'{"PC40": 0.31818, "PC38": 0.06912, "PC39": -0.14342, "PC18": 0.22382, "PC19": 0.18518, "PC14": 0.89231, "PC15": 0.05046, "PC16": -0.00241, "PC17": 0.54501, "PC10": -0.26463, "PC11": 0.30251, "PC12": 1.16327, "PC13": 0.16973, "PC43": 0.11952, "PC42": 1.05499, "PC41": 0.51263, "PC25": 0.02467, "PC24": -0.65128, "PC27": 0.48916, "PC26": -0.45228, "PC21": -0.44167, "PC20": 0.76896, "PC23": 0.29398, "PC22": 0.06425, "PC47": 0.70416, "PC49": -0.30313, "PC48": 0.12976, "PC29": -0.34, "PC28": 0.17406, "PC32": -0.06411, "PC46": 0.69257, "PC31": 0.07523, "PC45": -0.03461, "PC36": 0.29732, "PC44": 0.14516, "PC37": -0.19109, "PC34": 0.58399, "PC35": 0.37608, "PC33": -0.00378, "PC8": -0.88156, "PC9": 0.38233, "PC2": -0.56685, "PC3": 0.56321, "PC1": 0.49171, "PC6": -0.09854, "PC7": -1.24639, "PC4": 1.50134, "PC5": -0.03161, "PC50": 0.17349, "PC30": -1.29612}'
]
]
show_doc(self.test_scenario6, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[4])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
pca_create.i_create_a_pca_with_params(self, example[6])
pca_create.the_pca_is_finished_in_less_than(self, example[3])
projection_create.i_create_a_projection(self, example[5])
projection_create.the_projection_is(self, example[7])
compare_predictions.create_local_pca(self)
compare_predictions.i_create_a_local_projection(self, example[5])
compare_predictions.the_local_projection_is(self, example[7])
def test_scenario8(self):
"""
Scenario: Successfully comparing predictions with text options and proportional missing strategy:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I update the source with params "<options>"
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the model is ready less than <time_3> secs
And I create a local model
When I create a proportional missing strategy prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a proportional missing strategy local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
"""
examples = [
[
'data/text_missing.csv', '20', '20', '30',
'{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "all", "language": "en"}}, "000000": {"optype": "text", "term_analysis": {"token_mode": "all", "language": "en"}}}}',
'{}', "000003", 'swap'
],
[
'data/text_missing.csv', '20', '20', '30',
'{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "all", "language": "en"}}, "000000": {"optype": "text", "term_analysis": {"token_mode": "all", "language": "en"}}}}',
'{"category1": "a"}', "000003", 'paperwork'
]
]
show_doc(self.test_scenario8, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[4])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
model_create.i_create_a_model(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_model(self)
prediction_create.i_create_a_proportional_prediction(
self, example[5])
prediction_create.the_prediction_is(self, example[6], example[7])
prediction_compare.i_create_a_proportional_local_prediction(
self, example[5])
prediction_compare.the_local_prediction_is(self, example[7])
def test_scenario1(self):
"""
Scenario: Successfully comparing centroids with or without text options:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I update the source with params "<options>"
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a cluster
And I wait until the cluster is ready less than <time_3> secs
And I create a local cluster
When I create a centroid for "<data_input>"
Then the centroid is "<centroid>" with distance "<distance>"
And I create a local centroid for "<data_input>"
Then the local centroid is "<centroid>" with distance "<distance>"
Examples headers:
| data | time_1 | time_2 | time_3 | options | data_input | centroid | distance |
"""
examples = [
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}', '{"Type": "ham", "Message": "Mobile call"}', 'Cluster 7', '0.36637'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false}}}}', '{"Type": "ham", "Message": "A normal message"}', 'Cluster 0', '0.5'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": false, "use_stopwords": false, "language": "en"}}}}', '{"Type": "ham", "Message": "Mobile calls"}', 'Cluster 0', '0.5'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": false, "use_stopwords": false, "language": "en"}}}}', '{"Type": "ham", "Message": "A normal message"}', 'Cluster 0', '0.5'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": true, "use_stopwords": true, "language": "en"}}}}', '{"Type": "ham", "Message": "Mobile call"}', 'Cluster 0', '0.5'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": true, "use_stopwords": true, "language": "en"}}}}', '{"Type": "ham", "Message": "A normal message"}', 'Cluster 1', '0.36637'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}}', '{"Type": "ham", "Message": "FREE for 1st week! No1 Nokia tone 4 ur mob every week just txt NOKIA to 87077 Get txting and tell ur mates. zed POBox 36504 W45WQ norm150p/tone 16+"}', 'Cluster 0', '0.5'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}}', '{"Type": "ham", "Message": "Ok"}', 'Cluster 0', '0.478833312167'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}', '{"Type": "", "Message": ""}', 'Cluster 1', '0.5'],
['data/diabetes.csv', '20', '20', '30', '{"fields": {}}', '{"pregnancies": 0, "plasma glucose": 118, "blood pressure": 84, "triceps skin thickness": 47, "insulin": 230, "bmi": 45.8, "diabetes pedigree": 0.551, "age": 31, "diabetes": "true"}', 'Cluster 3', '0.5033378686559257'],
['data/diabetes.csv', '20', '20', '30', '{"fields": {}}', '{"pregnancies": 0, "plasma glucose": 118, "blood pressure": 84, "triceps skin thickness": 47, "insulin": 230, "bmi": 45.8, "diabetes pedigree": 0.551, "age": 31, "diabetes": true}', 'Cluster 3', '0.5033378686559257'],
['data/iris_sp_chars.csv', '20', '20', '30', '{"fields": {}}', '{"pétal.length":1, "pétal&width\u0000": 2, "sépal.length":1, "sépal&width": 2, "spécies": "Iris-setosa"}', 'Cluster 7', '0.8752380218327035'],
['data/movies.csv', '20', '20', '30', '{"fields": {"000007": {"optype": "items", "item_analysis": {"separator": "$"}}}}', '{"gender": "Female", "age_range": "18-24", "genres": "Adventure$Action", "timestamp": 993906291, "occupation": "K-12 student", "zipcode": 59583, "rating": 3}', 'Cluster 1', '0.7294650227133437']]
show_doc(self.test_scenario1, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[4])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
cluster_create.i_create_a_cluster(self)
cluster_create.the_cluster_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_cluster(self)
prediction_create.i_create_a_centroid(self, example[5])
prediction_create.the_centroid_is_with_distance(self, example[6], example[7])
prediction_compare.i_create_a_local_centroid(self, example[5])
prediction_compare.the_local_centroid_is(self, example[6], example[7])
def test_scenario4(self):
"""
Scenario: Successfully comparing predictions with proportional missing strategy for missing_splits models:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model with missing splits
And I wait until the model is ready less than <time_3> secs
And I create a local model
When I create a proportional missing strategy prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And the confidence for the prediction is "<confidence>"
And I create a proportional missing strategy local prediction for "<data_input>"
Then the local prediction is "<prediction>"
And the local prediction's confidence is "<confidence>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | confidence |
"""
examples = [[
'data/iris_missing2.csv', '10', '10', '10', '{"petal width": 1}',
'000004', 'Iris-setosa', '0.8064'
],
[
'data/iris_missing2.csv', '10', '10', '10',
'{"petal width": 1, "petal length": 4}', '000004',
'Iris-versicolor', '0.7847'
]]
show_doc(self.test_scenario4, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
model_create.i_create_a_model_with_missing_splits(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_model(self)
prediction_create.i_create_a_proportional_prediction(
self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_create.the_confidence_is(self, example[7])
prediction_compare.i_create_a_proportional_local_prediction(
self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
prediction_compare.the_local_prediction_confidence_is(
self, example[7])
def test_scenario9(self):
"""
Scenario: Successfully comparing predictions for logistic regressions with operating kind and supervised model:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a logistic regression with objective "<objective>"
And I wait until the logistic regression is ready less than <time_3> secs
And I create a local supervised model
When I create a prediction with operating kind "<operating_kind>" for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction with operating point "<operating_kind>" for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | params | operating_point,
"""
examples = [[
'data/iris.csv', '10', '50', '30000', '{"petal length": 5}',
'000004', 'Iris-versicolor', '{}', "probability"
],
[
'data/iris.csv', '10', '50', '30000',
'{"petal length": 2}', '000004', 'Iris-setosa', '{}',
"probability"
]]
show_doc(self.test_scenario9, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
model_create.i_create_a_logistic_model(self)
model_create.the_logistic_model_is_finished_in_less_than(
self, example[3])
prediction_compare.i_create_a_local_supervised_model(
self, model_type="logistic_regression")
prediction_create.i_create_a_logistic_prediction_with_op_kind(
self, example[4], example[8])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_local_logistic_prediction_op_kind(
self, example[4], example[8])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario1(self):
"""
Scenario: Successfully comparing remote and local predictions
with raw date input for anomaly detectors
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an anomaly detector
And I wait until the anomaly detector is ready less
than <time_3> secs
And I create a local anomaly detector
When I create an anomaly score for "<data_input>"
Then the anomaly score is "<score>"
And I create a local anomaly score for "<data_input>"
Then the local anomaly score is "<score>"
Examples:
|data|time_1|time_2|time_3|data_input|score|
"""
examples = [
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"1910-05-08T19:10:23.106","cat-0":"cat2","target-2":0.4}',
0.52477
],
[
'data/dates2.csv', '20', '30', '60',
'{"time-1":"1920-06-30T20:21:20.320","cat-0":"cat1","target-2":0.2}',
0.50654
]
]
show_doc(self.test_scenario1, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
anomaly_create.i_create_an_anomaly(self)
anomaly_create.the_anomaly_is_finished_in_less_than(
self, example[3])
prediction_compare.i_create_a_local_anomaly(self)
prediction_create.i_create_an_anomaly_score(self, example[4])
prediction_create.the_anomaly_score_is(self, example[5])
prediction_compare.i_create_a_local_anomaly_score(self, example[4])
prediction_compare.the_local_anomaly_score_is(self, example[5])
def test_scenario1(self):
"""
Scenario: Successfully comparing centroids with or without text options:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I update the source with params "<options>"
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a cluster
And I wait until the cluster is ready less than <time_3> secs
And I create a local cluster
When I create a centroid for "<data_input>"
Then the centroid is "<centroid>" with distance "<distance>"
And I create a local centroid for "<data_input>"
Then the local centroid is "<centroid>" with distance "<distance>"
Examples headers:
| data | time_1 | time_2 | time_3 | options | data_input | centroid | distance |
"""
examples = [
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}', '{"Type": "ham", "Message": "Mobile call"}', 'Cluster 0', '0.25'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false}}}}', '{"Type": "ham", "Message": "A normal message"}', 'Cluster 0', '0.5'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": false, "use_stopwords": false, "language": "en"}}}}', '{"Type": "ham", "Message": "Mobile calls"}', 'Cluster 0', '0.5'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": false, "use_stopwords": false, "language": "en"}}}}', '{"Type": "ham", "Message": "A normal message"}', 'Cluster 0', '0.5'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": true, "use_stopwords": true, "language": "en"}}}}', '{"Type": "ham", "Message": "Mobile call"}', 'Cluster 0', '0.5'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": true, "use_stopwords": true, "language": "en"}}}}', '{"Type": "ham", "Message": "A normal message"}', 'Cluster 1', '0.36637'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}}', '{"Type": "ham", "Message": "FREE for 1st week! No1 Nokia tone 4 ur mob every week just txt NOKIA to 87077 Get txting and tell ur mates. zed POBox 36504 W45WQ norm150p/tone 16+"}', 'Cluster 0', '0.5'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}}', '{"Type": "ham", "Message": "Ok"}', 'Cluster 0', '0.478833312167'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}', '{"Type": "", "Message": ""}', 'Cluster 6', '0.5'],
['data/diabetes.csv', '20', '20', '30', '{"fields": {}}', '{"pregnancies": 0, "plasma glucose": 118, "blood pressure": 84, "triceps skin thickness": 47, "insulin": 230, "bmi": 45.8, "diabetes pedigree": 0.551, "age": 31, "diabetes": "true"}', 'Cluster 3', '0.5033378686559257'],
['data/diabetes.csv', '20', '20', '30', '{"fields": {}}', '{"pregnancies": 0, "plasma glucose": 118, "blood pressure": 84, "triceps skin thickness": 47, "insulin": 230, "bmi": 45.8, "diabetes pedigree": 0.551, "age": 31, "diabetes": true}', 'Cluster 3', '0.5033378686559257'],
['data/iris_sp_chars.csv', '20', '20', '30', '{"fields": {}}', '{"pétal.length":1, "pétal&width\u0000": 2, "sépal.length":1, "sépal&width": 2, "spécies": "Iris-setosa"}', 'Cluster 7', '0.8752380218327035'],
['data/movies.csv', '20', '20', '30', '{"fields": {"000007": {"optype": "items", "item_analysis": {"separator": "$"}}}}', '{"gender": "Female", "age_range": "18-24", "genres": "Adventure$Action", "timestamp": 993906291, "occupation": "K-12 student", "zipcode": 59583, "rating": 3}', 'Cluster 1', '0.7294650227133437']]
show_doc(self.test_scenario1, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[4])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
cluster_create.i_create_a_cluster(self)
cluster_create.the_cluster_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_cluster(self)
prediction_create.i_create_a_centroid(self, example[5])
prediction_create.the_centroid_is_with_distance(self, example[6], example[7])
prediction_compare.i_create_a_local_centroid(self, example[5])
prediction_compare.the_local_centroid_is(self, example[6], example[7])
def test_scenario6(self):
"""
Scenario: Successfully comparing predictions for deepnets with operating kind:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a deepnet with objective "<objective>" and "<params>"
And I wait until the deepnet is ready less than <time_3> secs
And I create a local deepnet
When I create a prediction with operating kind "<operating_kind>" for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction with operating point "<operating_kind>" for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | params | operating_point,
"""
examples = [[
'data/iris.csv', '10', '50', '60', '{"petal length": 2.46}',
'000004', 'Iris-setosa', '{}', "probability"
],
[
'data/iris.csv', '10', '50', '60',
'{"petal length": 2}', '000004', 'Iris-setosa', '{}',
"probability"
]]
show_doc(self.test_scenario6, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
model_create.i_create_a_deepnet_with_objective_and_params(
self, example[5], example[7])
model_create.the_deepnet_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_deepnet(self)
prediction_create.i_create_a_deepnet_prediction_op_kind(
self, example[4], example[8])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_local_deepnet_prediction_op_kind(
self, example[4], example[8])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario7(self):
"""
Scenario: Successfully comparing predictions for ensembles with proportional missing strategy:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an esemble with "<params>"
And I wait until the ensemble is ready less than <time_3> secs
And I create a local ensemble
When I create a proportional missing strategy prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And the confidence for the prediction is "<confidence>"
And I create a proportional missing strategy local prediction for "<data_input>"
Then the local prediction is "<prediction>"
And the local prediction's confidence is "<confidence>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | confidence | params
['data/iris.csv', '10', '10', '50', '{}', '000004', 'Iris-virginica', '0.33784', '{"boosting": {"iterations": 5}}'],
"""
examples = [
['data/iris.csv', '30', '30', '50', '{}', '000004', 'Iris-virginica', '0.33784', '{"boosting": {"iterations": 5}}', {}],
['data/iris.csv', '30', '30', '50', '{}', '000004', 'Iris-versicolor', '0.27261', '{"number_of_models": 5"}', {"operating_kind": "confidence"}],
['data/grades.csv', '30', '30', '50', '{}', '000005', '70.505792', '30.7161', '{"number_of_models": 5}', {}],
['data/grades.csv', '30', '30', '50', '{"Midterm": 20}', '000005', '54.82214', '25.89672', '{"number_of_models": 5}', {"operating_kind": "confidence"}],
['data/grades.csv', '30', '30', '50', '{"Midterm": 20}', '000005', '45.4573', '29.58403', '{"number_of_models": 5}', {}],
['data/grades.csv', '30', '30', '50', '{"Midterm": 20, "Tutorial": 90, "TakeHome": 100}', '000005', '42.814', '31.51804', '{"number_of_models": 5}', {}]]
show_doc(self.test_scenario7, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
ensemble_create.i_create_an_ensemble_with_params(self, example[8])
ensemble_create.the_ensemble_is_finished_in_less_than(self, example[3])
ensemble_create.create_local_ensemble(self)
prediction_create.i_create_an_ensemble_proportional_prediction(self, example[4], example[9])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_create.the_confidence_is(self, example[7])
prediction_create.create_local_ensemble_proportional_prediction_with_confidence(self, example[4], example[9])
prediction_compare.the_local_ensemble_prediction_is(self, example[6])
prediction_compare.the_local_prediction_confidence_is(self, example[7])
def test_scenario12(self):
"""
Scenario: Successfully comparing logistic regression predictions with constant fields:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I update the dataset with "<params>"
And I wait until the dataset is ready less than <time_4> secs
And I create a logistic regression model
And I wait until the logistic regression model is ready less than <time_3> secs
And I create a local logistic regression model
When I create a logistic regression prediction for "<data_input>"
Then the logistic regression prediction is "<prediction>"
And I create a local logistic regression prediction for "<data_input>"
Then the local logistic regression prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 |time_4| data_input | prediction | field_id
"""
examples = [[
'data/constant_field.csv', '10', '10', '50', '10',
'{"a": 1, "b": 1, "c": 1}', 'a',
'{"fields": {"000000": {"preferred": true}}}'
]]
show_doc(self.test_scenario12, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
dataset_create.i_update_dataset_with(self, example[7])
dataset_create.the_dataset_is_finished_in_less_than(
self, example[4])
model_create.i_create_a_logistic_model(self)
model_create.the_logistic_model_is_finished_in_less_than(
self, example[3])
prediction_compare.i_create_a_local_logistic_model(self)
prediction_create.i_create_a_logistic_prediction(self, example[5])
prediction_create.the_logistic_prediction_is(self, example[6])
prediction_compare.i_create_a_local_prediction(self, example[5])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario6(self):
"""
Scenario: Successfully comparing predictions for ensembles:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an ensemble with "<params>"
And I wait until the ensemble is ready less than <time_3> secs
And I create a local ensemble
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | params
['data/iris.csv', '10', '10', '120', '{"petal width": 0.5}', '000004', 'Iris-versicolor', '{"number_of_models": 5}'],
['data/iris.csv', '10', '10', '120', '{"petal length": 6, "petal width": 2}', '000004', 'Iris-virginica', '{"number_of_models": 5}'],
['data/iris.csv', '10', '10', '120', '{"petal length": 4, "petal width": 1.5}', '000004', 'Iris-versicolor', '{"number_of_models": 5}'],
['data/grades.csv', '10', '10', '120', '{"Midterm": 20}', '000005', 46.261364, '{"number_of_models": 5}'],
['data/iris.csv', '10', '10', '120', '{"petal width": 0.5}', '000004', 'Iris-setosa', '{"boosting": {"iterations": 5}, "number_of_models": 5}'],
['data/iris.csv', '10', '10', '120', '{"petal length": 6, "petal width": 2}', '000004', 'Iris-virginica', '{"boosting": {"iterations": 5}, "number_of_models": 5}'],
['data/iris.csv', '10', '10', '120', '{"petal length": 4, "petal width": 1.5}', '000004', 'Iris-versicolor', '{"boosting": {"iterations": 5}, "number_of_models": 5}'],
"""
examples = [
['data/iris_unbalanced.csv', '30', '30', '120', '{"petal width": 4}', '000004', 'Iris-virginica', '{"boosting": {"iterations": 5}, "number_of_models": 5}'],
['data/grades.csv', '30', '30', '120', '{"Midterm": 20}', '000005', 61.61036, '{"boosting": {"iterations": 5}, "number_of_models": 5}']]
show_doc(self.test_scenario6, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
ensemble_create.i_create_an_ensemble_with_params(self, example[7])
ensemble_create.the_ensemble_is_finished_in_less_than(self, example[3])
ensemble_create.create_local_ensemble(self)
prediction_create.i_create_an_ensemble_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_local_ensemble_prediction(self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario2(self):
"""
Scenario: Successfully comparing predictions with text options:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I update the source with params "<options>"
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the model is ready less than <time_3> secs
And I create a local model
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | options | data_input | objective | prediction |
"""
examples = [
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}', '{"Message": "Mobile call"}', '000000', 'ham'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}', '{"Message": "A normal message"}', '000000', 'ham'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": false, "use_stopwords": false, "language": "en"}}}}', '{"Message": "Mobile calls"}', '000000', 'spam'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": false, "use_stopwords": false, "language": "en"}}}}', '{"Message": "A normal message"}', '000000', 'ham'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": true, "use_stopwords": true, "language": "en"}}}}', '{"Message": "Mobile call"}', '000000', 'spam'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": true, "use_stopwords": true, "language": "en"}}}}', '{"Message": "A normal message"}', '000000', 'ham'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}}', '{"Message": "FREE for 1st week! No1 Nokia tone 4 ur mob every week just txt NOKIA to 87077 Get txting and tell ur mates. zed POBox 36504 W45WQ norm150p/tone 16+"}', '000000', 'spam'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}}', '{"Message": "Ok"}', '000000', 'ham'],
['data/movies.csv', '20', '20', '30', '{"fields": {"000007": {"optype": "items", "item_analysis": {"separator": "$"}}}}', '{"genres": "Adventure$Action", "timestamp": 993906291, "occupation": "K-12 student"}', '000009', '3.93064'],
['data/text_missing.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "all", "language": "en"}}, "000000": {"optype": "text", "term_analysis": {"token_mode": "all", "language": "en"}}}}', '{}', "000003", 'swap']]
show_doc(self.test_scenario2, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[4])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_model(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_model(self)
prediction_create.i_create_a_prediction(self, example[5])
prediction_create.the_prediction_is(self, example[6], example[7])
prediction_compare.i_create_a_local_prediction(self, example[5])
prediction_compare.the_local_prediction_is(self, example[7])
def test_scenario13(self):
"""
Scenario: Successfully comparing predictions:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the model is ready less than <time_3> secs
And I create a local model
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction |
"""
examples = [
['data/iris.csv', '10', '10', '10', '{"petal width": 0.5}', '000004', 'Iris-setosa', "tmp/my_model.json", "my_test"],
['data/iris.csv', '10', '10', '10', '{"petal length": 6, "petal width": 2}', '000004', 'Iris-virginica', "tmp/my_model.json", "my_test"],
['data/iris.csv', '10', '10', '10', '{"petal length": 4, "petal width": 1.5}', '000004', 'Iris-versicolor', "tmp/my_model.json", "my_test"],
['data/iris_sp_chars.csv', '10', '10', '10', '{"pétal.length": 4, "pétal&width\u0000": 1.5}', '000004', 'Iris-versicolor', "tmp/my_model.json", "my_test"]]
show_doc(self.test_scenario13, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
args = '{"tags": ["%s"]}' % example[8]
model_create.i_create_a_model_with(self, data=args)
model_create.the_model_is_finished_in_less_than(self, example[3])
model_create.i_export_model(self, False, example[7]) # no pmml
prediction_compare.i_create_a_local_model_from_file(self, example[7])
prediction_create.i_create_a_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_local_prediction(self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
model_create.i_export_tags_model(self, example[7], example[8])
prediction_compare.i_create_a_local_model_from_file(self, example[7])
prediction_compare.i_create_a_local_prediction(self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario5(self):
"""
Scenario: Successfully comparing projections for PCAs:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a PCA with "<params>"
And I wait until the PCA is ready less than <time_3> secs
And I create a local PCA
When I create a projection for "<input_data>"
Then the projection is "<projection>"
And I create a local projection for "<data_input>"
Then the local projection is "<projection>"
Examples:
| data | time_1 | time_2 | time_3 | input_data | projection | params
"""
examples = [
['data/iris.csv', '30', '30', '120', '{}',
'{"PC2": 0, "PC3": 0, "PC1": 0, "PC6": 0, "PC4": 5e-05, "PC5": 0}', '{}'],
['data/iris.csv', '30', '30', '120', '{"petal length": 1}',
'{"PC2": 0.08708, "PC3": 0.20929, "PC1": 1.56084, "PC6": -1.34463, "PC4": 0.7295, "PC5": -1.00876}', '{}'],
['data/iris.csv', '30', '30', '120', '{"species": "Iris-versicolor"}',
'{"PC2": 1.8602, "PC3": -2.00864, "PC1": -0.61116, "PC6": -0.66983, "PC4": -2.44618, "PC5": 0.43414}', '{}'],
['data/iris.csv', '30', '30', '120', '{"petal length": 1, "sepal length": 0, "petal width": 0, "sepal width": 0, "species": "Iris-versicolor"}',
'{"PC2": 7.18009, "PC3": 6.51511, "PC1": 2.78155, "PC6": 0.21372, "PC4": -1.94865, "PC5": 0.57646}', '{}']]
show_doc(self.test_scenario5, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
pca_create.i_create_a_pca_with_params(self, example[6])
pca_create.the_pca_is_finished_in_less_than(self, example[3])
compare_predictions.create_local_pca(self)
projection_create.i_create_a_projection(self, example[4])
projection_create.the_projection_is(self, example[5])
compare_predictions.i_create_a_local_projection(self, example[4])
compare_predictions.the_local_projection_is(self, example[5])
def test_scenario6(self):
"""
Scenario: Successfully comparing predictions with text options:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I update the source with params "<options>"
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a logistic regression model
And I wait until the logistic regression model is ready less than <time_3> secs
And I create a local logistic regression model
When I create a logistic regression prediction for "<data_input>"
Then the logistic regression prediction is "<prediction>"
And I create a local logistic regression prediction for "<data_input>"
Then the local logistic regression prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | options | data_input | prediction |
"""
examples = [
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}', '{"Message": "Mobile call"}', 'ham'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}', '{"Message": "A normal message"}', 'ham'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": false, "use_stopwords": false, "language": "en"}}}}', '{"Message": "Mobile calls"}', 'ham'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": false, "use_stopwords": false, "language": "en"}}}}', '{"Message": "A normal message"}', 'ham'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": true, "use_stopwords": true, "language": "en"}}}}', '{"Message": "Mobile call"}', 'ham'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": true, "use_stopwords": true, "language": "en"}}}}', '{"Message": "A normal message"}', 'ham'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}}', '{"Message": "FREE for 1st week! No1 Nokia tone 4 ur mob every week just txt NOKIA to 87077 Get txting and tell ur mates. zed POBox 36504 W45WQ norm150p/tone 16+"}', 'ham'],
['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}}', '{"Message": "Ok"}', 'ham']]
show_doc(self.test_scenario6, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[4])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_logistic_model(self)
model_create.the_logistic_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_logistic_model(self)
prediction_create.i_create_a_logistic_prediction(self, example[5])
prediction_create.the_logistic_prediction_is(self, example[6])
prediction_compare.i_create_a_local_prediction(self, example[5])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario10(self):
"""
Scenario: Successfully comparing predictions with proportional missing strategy and balanced models:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a balanced model
And I wait until the model is ready less than <time_3> secs
And I create a local model
When I create a proportional missing strategy prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And the confidence for the prediction is "<confidence>"
And I create a proportional missing strategy local prediction for "<data_input>"
Then the local prediction is "<prediction>"
And the local prediction's confidence is "<confidence>"
And I create local probabilities for "<data_input>"
Then the local probabilities are "<probabilities>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | confidence |
"""
examples = [
['data/iris_unbalanced.csv', '10', '10', '10', '{}', '000004', 'Iris-setosa', '0.25284', '[0.33333, 0.33333, 0.33333]'],
['data/iris_unbalanced.csv', '10', '10', '10', '{"petal length":1, "sepal length":1, "petal width": 1, "sepal width": 1}', '000004', 'Iris-setosa', '0.7575', '[1.0, 0.0, 0.0]']]
show_doc(self.test_scenario10, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_balanced_model(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_model(self)
prediction_create.i_create_a_proportional_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_proportional_local_prediction(self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
prediction_create.the_confidence_is(self, example[7])
prediction_compare.the_local_prediction_confidence_is(self, example[7])
prediction_compare.i_create_local_probabilities(self, example[4])
prediction_compare.the_local_probabilities_are(self, example[8])
def test_scenario7(self):
"""
Scenario: Successfully comparing predictions with text options:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I update the source with params "<options>"
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a logistic regression model with objective "<objective>"
And I wait until the logistic regression model is ready less than <time_3> secs
And I create a local logistic regression model
When I create a logistic regression prediction for "<data_input>"
Then the logistic regression prediction is "<prediction>"
And the logistic regression probability for the prediction is "<probability>"
And I create a local logistic regression prediction for "<data_input>"
Then the local logistic regression prediction is "<prediction>"
And the local logistic regression probability for the prediction is "<probability>"
Examples:
| data | time_1 | time_2 | objective | time_3 | options | data_input | prediction | probability
"""
examples = [
['data/spam.csv', '20', '20', '180', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}}', '{"Message": "A normal message"}', 'ham', 0.9169, "000000"],
['data/spam.csv', '20', '20', '180', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "all", "language": "en"}}}}', '{"Message": "mobile"}', 'ham', 0.815, "000000"],
['data/movies.csv', '20', '20', '180', '{"fields": {"000007": {"optype": "items", "item_analysis": {"separator": "$"}}}}', '{"gender": "Female", "genres": "Adventure$Action", "timestamp": 993906291, "occupation": "K-12 student", "zipcode": 59583, "rating": 3}', 'Under 18', '0.8393', '000002']]
show_doc(self.test_scenario7, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[4])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_logistic_model_with_objective_and_parms(self, example[8])
model_create.the_logistic_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_logistic_model(self)
prediction_create.i_create_a_logistic_prediction(self, example[5])
prediction_create.the_logistic_prediction_is(self, example[6])
prediction_create.the_logistic_probability_is(self, example[7])
prediction_compare.i_create_a_local_prediction(self, example[5])
prediction_compare.the_local_prediction_is(self, example[6])
prediction_compare.the_local_probability_is(self, example[7])
def test_scenario3(self):
"""
Scenario: Successfully comparing forecasts from time series with "M" seasonality
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a time series with "<params>"
And I wait until the time series is ready less than <time_3> secs
And I create a local time series
When I create a forecast for "<input_data>"
Then the forecast is "<forecasts>"
And I create a local forecast for "<data_input>"
Then the local forecast is "<forecasts>"
Examples:
| data | time_1 | time_2 | time_3 | input_data | forecasts | params
,
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,Ad,M"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [73.75816, 74.60699, 66.71212, 72.49586, 71.76787], "model": "M,Ad,M"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}'],
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,Md,M"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [74.3725, 75.02963, 67.15826, 73.19628, 71.66919], "model": "M,Md,M"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}']
"""
examples = [
['data/grades.csv', '30', '30', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,N,M"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [68.99775, 72.76777, 66.5556, 70.90818, 70.92998], "model": "M,N,M"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}'],
['data/grades.csv', '30', '30', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,A,M"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [70.65993, 78.20652, 69.64806, 75.43716, 78.13556], "model": "M,A,M"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}'],
['data/grades.csv', '30', '30', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,M,M"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [71.75055, 80.67195, 70.81368, 79.84999, 78.27634], "model": "M,M,M"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}']]
show_doc(self.test_scenario3, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
time_series_create.i_create_a_time_series_with_params(self, example[6])
time_series_create.the_time_series_is_finished_in_less_than(self, example[3])
time_series_create.create_local_time_series(self)
forecast_create.i_create_a_forecast(self, example[4])
forecast_create.the_forecast_is(self, example[5])
forecast_compare.i_create_a_local_forecast(self, example[4])
forecast_compare.the_local_forecast_is(self, example[5])
def test_scenario3(self):
"""
Scenario: Successfully comparing predictions with proportional missing strategy:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the model is ready less than <time_3> secs
And I create a local model
When I create a proportional missing strategy prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And the confidence for the prediction is "<confidence>"
And I create a proportional missing strategy local prediction for "<data_input>"
Then the local prediction is "<prediction>"
And the local prediction's confidence is "<confidence>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | confidence |
"""
examples = [
['data/iris.csv', '10', '10', '10', '{}', '000004', 'Iris-setosa', '0.2629'],
['data/grades.csv', '10', '10', '10', '{}', '000005', '68.62224', '27.5358'],
['data/grades.csv', '10', '10', '10', '{"Midterm": 20}', '000005', '40.46667', '54.89713'],
['data/grades.csv', '10', '10', '10', '{"Midterm": 20, "Tutorial": 90, "TakeHome": 100}', '000005', '28.06', '25.65806']]
show_doc(self.test_scenario3, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_model(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_model(self)
prediction_create.i_create_a_proportional_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_create.the_confidence_is(self, example[7])
prediction_compare.i_create_a_proportional_local_prediction(self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
prediction_compare.the_local_prediction_confidence_is(self, example[7])
def test_scenario3(self):
"""
Scenario: Successfully comparing forecasts from time series with "M" seasonality
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a time series with "<params>"
And I wait until the time series is ready less than <time_3> secs
And I create a local time series
When I create a forecast for "<input_data>"
Then the forecast is "<forecasts>"
And I create a local forecast for "<data_input>"
Then the local forecast is "<forecasts>"
Examples:
| data | time_1 | time_2 | time_3 | input_data | forecasts | params
"""
examples = [
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,N,M"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [72.17615, 72.03876, 66.47413, 69.65207, 68.69178], "model": "M,N,M"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}'],
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,A,M"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [74.64993, 76.14421, 68.47124, 74.19305, 73.51855], "model": "M,A,M"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}'],
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,M,M"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [74.22947, 78.06875, 69.96644, 75.98277, 75.92554], "model": "M,M,M"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}'],
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,Ad,M"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast":[73.80787, 74.61327, 67.30521, 73.12079, 72.03179], "model": "M,Ad,M"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}'],
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,Md,M"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [74.65602, 74.79726, 67.07633, 72.56983, 72.23638], "model": "M,Md,M"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}']]
show_doc(self.test_scenario3, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
time_series_create.i_create_a_time_series_with_params(self, example[6])
time_series_create.the_time_series_is_finished_in_less_than(self, example[3])
time_series_create.create_local_time_series(self)
forecast_create.i_create_a_forecast(self, example[4])
forecast_create.the_forecast_is(self, example[5])
forecast_compare.i_create_a_local_forecast(self, example[4])
forecast_compare.the_local_forecast_is(self, example[5])
def test_scenario9(self):
"""
Scenario: Successfully comparing predictions with text options:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I update the source with params "<options>"
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a logistic regression model with objective "<objective>" and parms "<parms>"
And I wait until the logistic regression model is ready less than <time_3> secs
And I create a local logistic regression model
When I create a logistic regression prediction for "<data_input>"
Then the logistic regression prediction is "<prediction>"
And the logistic regression probability for the prediction is "<probability>"
And I create a local logistic regression prediction for "<data_input>"
Then the local logistic regression prediction is "<prediction>"
And the local logistic regression probability for the prediction is "<probability>"
"""
examples = [
['data/iris.csv', '20', '20', '130', '{"fields": {"000000": {"optype": "categorical"}}}', '{"species": "Iris-setosa"}', '5.0', 0.0394, "000000", '{"field_codings": [{"field": "species", "coding": "dummy", "dummy_class": "Iris-setosa"}]}'],
['data/iris.csv', '20', '20', '130', '{"fields": {"000000": {"optype": "categorical"}}}', '{"species": "Iris-setosa"}', '5.0', 0.0511, "000000", '{"balance_fields": false, "field_codings": [{"field": "species", "coding": "contrast", "coefficients": [[1, 2, -1, -2]]}]}'],
['data/iris.csv', '20', '20', '130', '{"fields": {"000000": {"optype": "categorical"}}}', '{"species": "Iris-setosa"}', '5.0', 0.0511, "000000", '{"balance_fields": false, "field_codings": [{"field": "species", "coding": "other", "coefficients": [[1, 2, -1, -2]]}]}'],
['data/iris.csv', '20', '20', '130', '{"fields": {"000000": {"optype": "categorical"}}}', '{"species": "Iris-setosa"}', '5.0', 0.0417, "000000", '{"bias": false}']]
show_doc(self.test_scenario9, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
source_create.i_update_source_with(self, example[4])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_logistic_model_with_objective_and_parms(self, example[8], example[9])
model_create.the_logistic_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_logistic_model(self)
prediction_create.i_create_a_logistic_prediction(self, example[5])
prediction_create.the_logistic_prediction_is(self, example[6])
prediction_create.the_logistic_probability_is(self, example[7])
prediction_compare.i_create_a_local_prediction(self, example[5])
prediction_compare.the_local_prediction_is(self, example[6])
prediction_compare.the_local_probability_is(self, example[7])
def test_scenario7(self):
"""
Scenario: Successfully comparing predictions in operating points for ensembles:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an ensemble
And I wait until the ensemble is ready less than <time_3> secs
And I create a local ensemble
When I create a prediction for "<data_input>" in "<operating_kind>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local ensemble prediction for "<data_input>" in "<operating_kind>"
Then the local ensemble prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | prediction | operating_kind
"""
examples = [
['data/iris.csv', '10', '50', '50', '{"petal length": 2.46}', 'Iris-versicolor', "probability", "000004"],
['data/iris.csv', '10', '50', '50', '{"petal length": 2}', 'Iris-setosa', "probability", "000004"],
['data/iris.csv', '10', '50', '50', '{"petal length": 2.46}', 'Iris-versicolor', "confidence", "000004"],
['data/iris.csv', '10', '50', '50', '{"petal length": 2}', 'Iris-setosa', "confidence", "000004"],
['data/iris.csv', '10', '50', '50', '{"petal length": 2.46}', 'Iris-versicolor', "votes", "000004"],
['data/iris.csv', '10', '50', '50', '{"petal length": 1}', 'Iris-setosa', "votes", "000004"]]
show_doc(self.test_scenario7, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
ensemble_create.i_create_an_ensemble(self)
ensemble_create.the_ensemble_is_finished_in_less_than(self, example[3])
ensemble_create.create_local_ensemble(self)
prediction_create.i_create_an_ensemble_prediction_op_kind(self, example[4], example[6])
prediction_create.the_prediction_is(self, example[7], example[5])
prediction_compare.i_create_a_local_ensemble_prediction_op_kind(self, example[4], example[6])
prediction_compare.the_local_prediction_is(self, example[5])
def test_scenario10(self):
"""
Scenario: Successfully comparing predictions for linear regression:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a linear regression with objective "<objective>" and "<params>"
And I wait until the linear regression is ready less than <time_3> secs
And I create a local linear regression
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | params
"""
examples = [
['data/grades.csv', '10', '50', '30000', '{"000000": 1, "000001": 1, "000002": 1}', '000005', 29.63024, '{"input_fields": ["000000", "000001", "000002"]}'],
['data/iris.csv', '10', '50', '30000', '{"000000": 1, "000001": 1, "000004": "Iris-virginica"}', '000003', 1.21187, '{"input_fields": ["000000", "000001", "000004"]}'],
['data/movies.csv', '10', '50', '30000', '{"000007": "Action"}', '000009', 4.33333, '{"input_fields": ["000007"]}'],
['data/movies.csv', '10', '50', '30000', '{"000006": "1999"}', '000009', 0, '{"input_fields": ["000006"], "bias": false}']]
show_doc(self.test_scenario10, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
linear_create.i_create_a_linear_regression_with_objective_and_params( \
self, example[5], example[7])
linear_create.the_linear_regression_is_finished_in_less_than( \
self, example[3])
prediction_compare.i_create_a_local_linear(self)
prediction_create.i_create_a_linear_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_local_linear_prediction(self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario8(self):
"""
Scenario: Successfully comparing predictions for ensembles:
Given I create a local ensemble predictor from "<directory>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| directory | data_input | prediction
"""
examples = [
['bigml/tests/my_ensemble', '{"petal width": 4}', 68.1258030739]]
show_doc(self.test_scenario6, examples)
for example in examples:
print "\nTesting with:\n", example
ensemble_create.create_local_ensemble_predictor(self, example[0])
prediction_compare.i_create_a_local_ensemble_prediction(self, example[1])
prediction_compare.the_local_ensemble_prediction_is(self, example[2])
def test_scenario1(self):
"""
Scenario: Successfully comparing forecasts from time series:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a time series with "<params>"
And I wait until the time series is ready less than <time_3> secs
And I create a local time series
When I create a forecast for "<input_data>"
Then the forecast is "<forecasts>"
And I create a local forecast for "<data_input>"
Then the local forecast is "<forecasts>"
Examples:
| data | time_1 | time_2 | time_3 | input_data | forecasts | params
"""
examples = [
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5}}', '{"000005": [{"point_forecast": [68.53181, 68.53181, 68.53181, 68.53181, 68.53181], "model": "A,N,N"}]}', '{"objective_fields": ["000001", "000005"]}'],
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,N,N"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [68.50838, 68.50838, 68.50838, 68.50838, 68.50838], "model": "M,N,N"}]}', '{"objective_fields": ["000001", "000005"]}'],
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["A,A,N"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [75.00015, 75.16225, 75.32435, 75.48645, 75.64855], "model": "A,A,N"}]}', '{"objective_fields": ["000001", "000005"]}'],
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["A,Ad,N"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [73.32521, 73.38823, 73.45, 73.51052, 73.56984], "model": "A,Ad,N"}]}', '{"objective_fields": ["000001", "000005"]}'],
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5}, "000001": {"horizon": 3, "ets_models": {"criterion": "aic", "limit": 2}}}', '{"000005": [{"point_forecast": [68.53181, 68.53181, 68.53181, 68.53181, 68.53181], "model": "A,N,N"}], "000001": [{"point_forecast": [54.77665, 90.00943, 83.59285], "model": "A,N,A"}, {"point_forecast": [55.88282, 90.52555, 83.44909], "model": "A,Ad,A"}]}', '{"objective_fields": ["000001", "000005"]}']]
show_doc(self.test_scenario1, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
time_series_create.i_create_a_time_series_with_params(self, example[6])
time_series_create.the_time_series_is_finished_in_less_than(self, example[3])
time_series_create.create_local_time_series(self)
forecast_create.i_create_a_forecast(self, example[4])
forecast_create.the_forecast_is(self, example[5])
forecast_compare.i_create_a_local_forecast(self, example[4])
forecast_compare.the_local_forecast_is(self, example[5])
def test_scenario1(self):
"""
Scenario: Successfully comparing forecasts from time series:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a time series with "<params>"
And I wait until the time series is ready less than <time_3> secs
And I create a local time series
When I create a forecast for "<input_data>"
Then the forecast is "<forecasts>"
And I create a local forecast for "<data_input>"
Then the local forecast is "<forecasts>"
Examples:
| data | time_1 | time_2 | time_3 | input_data | forecasts | params
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["A,Ad,N"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [69.90959, 69.92755, 69.94514, 69.96236, 69.97922], "model": "A,Ad,N"}]}', '{"objective_fields": ["000001", "000005"]}'],
"""
examples = [
['data/grades.csv', '30', '30', '120', '{"000005": {"horizon": 5}}', '{"000005": [{"point_forecast": [73.96192, 74.04106, 74.12029, 74.1996, 74.27899], "model": "M,M,N"}]}', '{"objective_fields": ["000001", "000005"]}'],
['data/grades.csv', '30', '30', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,N,N"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [68.39832, 68.39832, 68.39832, 68.39832, 68.39832], "model": "M,N,N"}]}', '{"objective_fields": ["000001", "000005"]}'],
['data/grades.csv', '30', '30', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["A,A,N"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [72.46247, 72.56247, 72.66247, 72.76247, 72.86247], "model": "A,A,N"}]}', '{"objective_fields": ["000001", "000005"]}'],
['data/grades.csv', '30', '30', '120', '{"000005": {"horizon": 5}, "000001": {"horizon": 3, "ets_models": {"criterion": "aic", "limit": 2}}}', '{"000005": [{"point_forecast": [73.96192, 74.04106, 74.12029, 74.1996, 74.27899], "model": "M,M,N"}], "000001": [{"point_forecast": [55.51577, 89.69111, 82.04935], "model": "A,N,A"}, {"point_forecast": [56.67419, 91.89657, 84.70017], "model": "A,A,A"}]}', '{"objective_fields": ["000001", "000005"]}']]
show_doc(self.test_scenario1, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
time_series_create.i_create_a_time_series_with_params(self, example[6])
time_series_create.the_time_series_is_finished_in_less_than(self, example[3])
time_series_create.create_local_time_series(self)
forecast_create.i_create_a_forecast(self, example[4])
forecast_create.the_forecast_is(self, example[5])
forecast_compare.i_create_a_local_forecast(self, example[4])
forecast_compare.the_local_forecast_is(self, example[5])
def test_scenario12(self):
"""
Scenario: Successfully comparing logistic regression predictions with constant fields:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I update the dataset with "<params>"
And I wait until the dataset is ready less than <time_4> secs
And I create a logistic regression model
And I wait until the logistic regression model is ready less than <time_3> secs
And I create a local logistic regression model
When I create a logistic regression prediction for "<data_input>"
Then the logistic regression prediction is "<prediction>"
And I create a local logistic regression prediction for "<data_input>"
Then the local logistic regression prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 |time_4| data_input | prediction | field_id
"""
examples = [
['data/constant_field.csv', '10', '10', '50', '10','{"a": 1, "b": 1, "c": 1}', 'a', '{"fields": {"000000": {"preferred": true}}}']]
show_doc(self.test_scenario12, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
dataset_create.i_update_dataset_with(self, example[7])
dataset_create.the_dataset_is_finished_in_less_than(self, example[4])
model_create.i_create_a_logistic_model(self)
model_create.the_logistic_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_logistic_model(self)
prediction_create.i_create_a_logistic_prediction(self, example[5])
prediction_create.the_logistic_prediction_is(self, example[6])
prediction_compare.i_create_a_local_prediction(self, example[5])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario4(self):
"""
Scenario: Successfully comparing forecasts from time series with trivial models
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a time series with "<params>"
And I wait until the time series is ready less than <time_3> secs
And I create a local time series
When I create a forecast for "<input_data>"
Then the forecast is "<forecasts>"
And I create a local forecast for "<data_input>"
Then the local forecast is "<forecasts>"
Examples:
| data | time_1 | time_2 | time_3 | input_data | forecasts | params
"""
examples = [
['data/grades.csv', '10', '1000', '1000', '{"000005": {"horizon": 5, "ets_models": {"names": ["naive"]}}}', '{"000005": [{"point_forecast": [61.39, 61.39, 61.39, 61.39, 61.39], "model": "naive"}]}', '{"objective_fields": ["000001", "000005"], "period": 1}'],
['data/grades.csv', '10', '1000', '1000', '{"000005": {"horizon": 5, "ets_models": {"names": ["naive"]}}}', '{"000005": [{"point_forecast": [78.89, 61.39, 78.89, 61.39, 78.89], "model": "naive"}]}', '{"objective_fields": ["000001", "000005"], "period": 2}'],
['data/grades.csv', '10', '1000', '1000', '{"000005": {"horizon": 5, "ets_models": {"names": ["mean"]}}}', '{"000005": [{"point_forecast": [68.45974, 68.45974, 68.45974, 68.45974, 68.45974], "model": "mean"}]}', '{"objective_fields": ["000001", "000005"], "period": 1}'],
['data/grades.csv', '10', '1000', '1000', '{"000005": {"horizon": 5, "ets_models": {"names": ["mean"]}}}', '{"000005": [{"point_forecast": [69.79553, 67.15821, 69.79553, 67.15821, 69.79553], "model": "mean"}]}', '{"objective_fields": ["000001", "000005"], "period": 2}'],
['data/grades.csv', '10', '1000', '1000', '{"000005": {"horizon": 5, "ets_models": {"names": ["drift"]}}}', '{"000005": [{"point_forecast": [61.50545, 61.6209, 61.73635, 61.8518, 61.96725], "model": "drift"}]}', '{"objective_fields": ["000001", "000005"], "period": 1}'],
['data/grades.csv', '10', '1000', '1000', '{"000005": {"horizon": 5, "ets_models": {"names": ["drift"]}}}', '{"000005": [{"point_forecast": [61.50545, 61.6209, 61.73635, 61.8518, 61.96725], "model": "drift"}]}', '{"objective_fields": ["000001", "000005"], "period": 2}']]
show_doc(self.test_scenario4, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
time_series_create.i_create_a_time_series_with_params(self, example[6])
time_series_create.the_time_series_is_finished_in_less_than(self, example[3])
time_series_create.create_local_time_series(self)
forecast_create.i_create_a_forecast(self, example[4])
forecast_create.the_forecast_is(self, example[5])
forecast_compare.i_create_a_local_forecast(self, example[4])
forecast_compare.the_local_forecast_is(self, example[5])
def test_scenario1(self):
"""
Scenario: Successfully comparing predictions for deepnets:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a deepnet with objective "<objective>" and "<params>"
And I wait until the deepnet is ready less than <time_3> secs
And I create a local deepnet
When I create a prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | params,
"""
examples = [
['data/iris.csv', '30', '50', '30000', '{"petal width": 4}', '000004', 'Iris-virginica', '{}'],
['data/iris.csv', '30', '50', '30000', '{"sepal length": 4.1, "sepal width": 2.4}', '000004', 'Iris-setosa', '{}'],
['data/iris_missing2.csv', '30', '50', '30000', '{}', '000004', 'Iris-setosa', '{}'],
['data/grades.csv', '30', '50', '30000', '{}', '000005', 42.15473, '{}'],
['data/spam.csv', '30', '50', '30000', '{}', '000000', 'ham', '{}']]
show_doc(self.test_scenario1, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_deepnet_with_objective_and_params(self, example[5], example[7])
model_create.the_deepnet_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_deepnet(self)
prediction_create.i_create_a_deepnet_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_compare.i_create_a_local_deepnet_prediction(self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario2(self):
"""
Scenario: Successfully comparing forecasts from time series with "A" seasonality
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a time series with "<params>"
And I wait until the time series is ready less than <time_3> secs
And I create a local time series
When I create a forecast for "<input_data>"
Then the forecast is "<forecasts>"
And I create a local forecast for "<data_input>"
Then the local forecast is "<forecasts>"
Examples:
| data | time_1 | time_2 | time_3 | input_data | forecasts | params
"""
examples = [
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5}}', '{"000005": [{"point_forecast": [68.53181, 68.53181, 68.53181, 68.53181, 68.53181], "model": "A,N,N"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}'],
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["M,N,A"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [72.51702, 72.29175, 66.73389, 72.20277, 69.47615], "model": "M,N,A"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}'],
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["A,A,A"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast": [69.60446, 74.28786, 67.46402, 75.91042, 72.52807], "model": "A,A,A"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}'],
['data/grades.csv', '10', '10', '120', '{"000005": {"horizon": 5, "ets_models": {"names": ["A,Ad,A"], "criterion": "aic", "limit": 3}}}', '{"000005": [{"point_forecast":[66.28032, 71.15014, 65.99847, 73.28416, 71.04533], "model": "A,Ad,A"}]}', '{"objective_fields": ["000001", "000005"], "period": 12}']]
show_doc(self.test_scenario2, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
time_series_create.i_create_a_time_series_with_params(self, example[6])
time_series_create.the_time_series_is_finished_in_less_than(self, example[3])
time_series_create.create_local_time_series(self)
forecast_create.i_create_a_forecast(self, example[4])
forecast_create.the_forecast_is(self, example[5])
forecast_compare.i_create_a_local_forecast(self, example[4])
forecast_compare.the_local_forecast_is(self, example[5])
def test_scenario2(self):
"""
Scenario: Successfully comparing predictions in operating points for models:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the model is ready less than <time_3> secs
And I create a local model
When I create a prediction for "<data_input>" in "<operating_point>"
Then the prediction for "<objective>" is "<prediction>"
And I create a local prediction for "<data_input>" in "<operating_point>"
Then the local prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | prediction | operating_point
"""
examples = [
['data/iris.csv', '10', '50', '50', '{"petal width": 4}', 'Iris-setosa', {"kind": "probability", "threshold": 0.1, "positive_class": "Iris-setosa"}, "000004"],
['data/iris.csv', '10', '50', '50', '{"petal width": 4}', 'Iris-versicolor', {"kind": "probability", "threshold": 0.9, "positive_class": "Iris-setosa"}, "000004"],
['data/iris.csv', '10', '50', '50', '{"sepal length": 4.1, "sepal width": 2.4}', 'Iris-setosa', {"kind": "confidence", "threshold": 0.1, "positive_class": "Iris-setosa"}, "000004"],
['data/iris.csv', '10', '50', '50', '{"sepal length": 4.1, "sepal width": 2.4}', 'Iris-versicolor', {"kind": "confidence", "threshold": 0.9, "positive_class": "Iris-setosa"}, "000004"]]
show_doc(self.test_scenario2, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_model(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_model(self)
prediction_create.i_create_a_prediction_op(self, example[4], example[6])
prediction_create.the_prediction_is(self, example[7], example[5])
prediction_compare.i_create_a_local_prediction_op(self, example[4], example[6])
prediction_compare.the_local_prediction_is(self, example[5])
def test_scenario4(self):
"""
Scenario: Successfully comparing predictions with proportional missing strategy for missing_splits models:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model with missing splits
And I wait until the model is ready less than <time_3> secs
And I create a local model
When I create a proportional missing strategy prediction for "<data_input>"
Then the prediction for "<objective>" is "<prediction>"
And the confidence for the prediction is "<confidence>"
And I create a proportional missing strategy local prediction for "<data_input>"
Then the local prediction is "<prediction>"
And the local prediction's confidence is "<confidence>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | objective | prediction | confidence |
"""
examples = [
['data/iris_missing2.csv', '10', '10', '10', '{"petal width": 1}', '000004', 'Iris-setosa', '0.8064'],
['data/iris_missing2.csv', '10', '10', '10', '{"petal width": 1, "petal length": 4}', '000004', 'Iris-versicolor', '0.7847']]
show_doc(self.test_scenario4, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_model_with_missing_splits(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_model(self)
prediction_create.i_create_a_proportional_prediction(self, example[4])
prediction_create.the_prediction_is(self, example[5], example[6])
prediction_create.the_confidence_is(self, example[7])
prediction_compare.i_create_a_proportional_local_prediction(self, example[4])
prediction_compare.the_local_prediction_is(self, example[6])
prediction_compare.the_local_prediction_confidence_is(self, example[7])
def test_scenario5(self):
"""
Scenario: Successfully comparing logistic regression predictions:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a logistic regression model
And I wait until the logistic regression model is ready less than <time_3> secs
And I create a local logistic regression model
When I create a logistic regression prediction for "<data_input>"
Then the logistic regression prediction is "<prediction>"
And I create a local logistic regression prediction for "<data_input>"
Then the local logistic regression prediction is "<prediction>"
Examples:
| data | time_1 | time_2 | time_3 | data_input | prediction |
"""
examples = [
['data/iris.csv', '10', '10', '50', '{"petal width": 0.5, "petal length": 0.5, "sepal width": 0.5, "sepal length": 0.5}', 'Iris-versicolor'],
['data/iris.csv', '10', '10', '50', '{"petal width": 2, "petal length": 6, "sepal width": 0.5, "sepal length": 0.5}', 'Iris-versicolor'],
['data/iris.csv', '10', '10', '50', '{"petal width": 1.5, "petal length": 4, "sepal width": 0.5, "sepal length": 0.5}', 'Iris-versicolor'],
['data/iris.csv', '10', '10', '50', '{"petal length": 1}', 'Iris-setosa'],
['data/iris_sp_chars.csv', '10', '10', '50', '{"pétal.length": 4, "pétal&width\u0000": 1.5, "sépal&width": 0.5, "sépal.length": 0.5}', 'Iris-versicolor'],
['data/price.csv', '10', '10', '50', '{"Price": 1200}', 'Product1']]
show_doc(self.test_scenario5, examples)
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_logistic_model(self)
model_create.the_logistic_model_is_finished_in_less_than(self, example[3])
prediction_compare.i_create_a_local_logistic_model(self)
prediction_create.i_create_a_logistic_prediction(self, example[4])
prediction_create.the_logistic_prediction_is(self, example[5])
prediction_compare.i_create_a_local_prediction(self, example[4])
prediction_compare.the_local_prediction_is(self, example[5])