def test_scenario2(self): """ Scenario: Successfully creating a model and exporting it: 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 export the <"pmml"> model to file "<expected_file>" Then I check the model is stored in "<expected_file>" file in <"pmml"> Examples: | data | time_1 | time_2 | time_3 | expected_file | pmml | data/iris.csv | 10 | 10 | 10 | tmp/model/iris.json | false | data/iris_sp_chars.csv | 10 | 10 | 10 | tmp/model/iris_sp_chars.pmml | true """ print self.test_scenario2.__doc__ examples = [ ['data/iris.csv', '30', '30', '30', 'tmp/model/iris.json', False], ['data/iris_sp_chars.csv', '30', '30', '30', 'tmp/model/iris_sp_chars.pmml', True]] 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]) model_create.i_export_model(self, example[5], example[4]) model_create.i_check_model_stored(self, example[4], 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_scenario1(self): """ Scenario: Successfully creating a prediction with a user's project connection: Given I create a data source uploading a "<data>" file And I wait until the source is ready less than <time_1> secs And the source is in the project 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 When I create a prediction for "<data_input>" Then the prediction for "<objective>" is "<prediction>" Examples: | data | time_1 | time_2 | time_3 | data_input | objective | prediction | | ../data/iris.csv | 10 | 10 | 10 | {"petal width": 0.5} | 000004 | Iris-setosa | """ print self.test_scenario1.__doc__ examples = [ ['data/iris.csv', '10', '10', '10', '{"petal width": 0.5}', '000004', 'Iris-setosa']] for example in examples: print "\nTesting with:\n", example source_create.i_upload_a_file_with_project_conn(self, example[0]) source_create.the_source_is_finished(self, example[1]) assert world.source['project'] == world.project_id dataset_create.i_create_a_dataset(self) dataset_create.the_dataset_is_finished_in_less_than(self, example[2]) assert world.dataset['project'] == world.project_id model_create.i_create_a_model(self) model_create.the_model_is_finished_in_less_than(self, example[3]) assert world.model['project'] == world.project_id prediction_create.i_create_a_prediction(self, example[4]) prediction_create.the_prediction_is(self, example[5], example[6]) assert world.prediction['project'] == world.project_id
def test_scenario1(self): """ Scenario: Successfully exporting a dataset: 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 download the dataset file to "<local_file>" Then file "<local_file>" is like file "<data>" Examples: | data | time_1 | time_2 | local_file | | ../data/iris.csv | 30 | 30 | ./tmp/exported_iris.csv | """ print self.test_scenario1.__doc__ examples = [ ['data/iris.csv', '30', '30', 'tmp/exported_iris.csv']] 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_export_a_dataset(self, example[3]) dataset_create.files_equal(self, example[3], example[0])
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_scenario2(self): """ Scenario: Successfully creating a prediction from a source in a remote location Given I create a data source using the url "<url>" 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 When I create a prediction for "<data_input>" Then the prediction for "<objective>" is "<prediction>" Examples: | url | time_1 | time_2 | time_3 | data_input | objective | prediction | | s3://bigml-public/csv/iris.csv | 10 | 10 | 10 | {"petal width": 0.5} | 000004 | Iris-setosa | """ print self.test_scenario2.__doc__ examples = [ ['s3://bigml-public/csv/iris.csv', '10', '10', '10', '{"petal width": 0.5}', '000004', 'Iris-setosa']] for example in examples: print "\nTesting with:\n", example source_create.i_create_using_url(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_create.i_create_a_prediction(self, example[4]) prediction_create.the_prediction_is(self, example[5], example[6])
def test_scenario1(self): """ Scenario: Successfully creating a model from a dataset list: 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 store the dataset id in a list And I create a dataset And I wait until the dataset is ready less than <time_3> secs And I store the dataset id in a list Then I create a model from a dataset list And I wait until the model is ready less than <time_4> secs And I check the model stems from the original dataset list Examples: | data | time_1 | time_2 | time_3 | time_4 | | ../data/iris.csv | 10 | 10 | 10 | 10 """ print self.test_scenario1.__doc__ examples = [["data/iris.csv", "10", "10", "10", "10"]] 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]) multimodel_create.i_store_dataset_id(self) dataset_create.i_create_a_dataset(self) dataset_create.the_dataset_is_finished_in_less_than(self, example[3]) multimodel_create.i_store_dataset_id(self) model_create.i_create_a_model_from_dataset_list(self) model_create.the_model_is_finished_in_less_than(self, example[4]) multimodel_create.i_check_model_datasets_and_datasets_ids(self)
def test_scenario2(self): """ Scenario 2: Successfully creating Topic Model from a dataset: 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 topic model from a dataset And I wait until the topic model is ready less than <time_3> secs And I update the topic model name to "<topic_model_name>" When I wait until the topic_model is ready less than <time_4> secs Then the topic model name is "<topic_model_name>" Examples: | data | time_1 | time_2 | time_3 | time_4 | topic_model_name | params | ../data/spam.csv | 100 | 100 | 200 | 500 | my new topic model name | '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}' """ print self.test_scenario2.__doc__ examples = [ ['data/spam.csv', '100', '100', '10000', '500', 'my new topic model name', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}']] 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[6]) 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]) topic_create.i_update_topic_model_name(self, example[5]) topic_create.the_topic_model_is_finished_in_less_than(self, example[4]) topic_create.i_check_topic_model_name(self, example[5])
def test_scenario1(self): """ Scenario: Successfully creating a split dataset: 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 dataset extracting a <rate> sample And I wait until the dataset is ready less than <time_3> secs When I compare the datasets' instances Then the proportion of instances between datasets is <rate> Examples: | data | time_1 | time_2 | time_3 | rate | | ../data/iris.csv | 10 | 10 | 10 | 0.8 | """ print self.test_scenario1.__doc__ examples = [ ['data/iris.csv', '10', '10', '10', '0.8']] 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_create_a_split_dataset(self, example[4]) dataset_create.the_dataset_is_finished_in_less_than(self, example[3]) dataset_create.i_compare_datasets_instances(self) dataset_create.proportion_datasets_instances(self, example[4])
def test_scenario2(self): """ Scenario: Successfully creating a batch prediction for an ensemble: 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 of <number_of_models> models and <tlp> tlp And I wait until the ensemble is ready less than <time_3> secs When I create a batch prediction for the dataset with the ensemble And I wait until the batch prediction is ready less than <time_4> secs And I download the created predictions file to "<local_file>" Then the batch prediction file is like "<predictions_file>" Examples: | data | time_1 | time_2 | number_of_models | tlp | time_3 | time_4 | local_file | predictions_file | | ../data/iris.csv | 30 | 30 | 5 | 1 | 80 | 50 | ./tmp/batch_predictions.csv | ./data/batch_predictions_e.csv | """ print self.test_scenario2.__doc__ examples = [ ['data/iris.csv', '30', '30', '5', '1', '80', '50', 'tmp/batch_predictions.csv', 'data/batch_predictions_e.csv']] 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, example[3], example[4]) ensemble_create.the_ensemble_is_finished_in_less_than(self, example[5]) batch_pred_create.i_create_a_batch_prediction_ensemble(self) batch_pred_create.the_batch_prediction_is_finished_in_less_than(self, example[6]) batch_pred_create.i_download_predictions_file(self, example[7]) batch_pred_create.i_check_predictions(self, example[8])
def test_scenario2(self): """ Scenario: Successfully creating a model from a dataset list and predicting with it using median: 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 multi model When I create a local multimodel batch prediction using median for <input_data> Then the local prediction is <prediction> Examples: | data | time_1 | time_2 | time_3 | input_data | prediction | ../data/grades.csv | 10 | 10 | 10 | {'Tutorial': 99.47, 'Midterm': 53.12, 'TakeHome': 87.96} | 50 """ print self.test_scenario2.__doc__ examples = [ ["data/grades.csv", "10", "10", "10", '{"Tutorial": 99.47, "Midterm": 53.12, "TakeHome": 87.96}', 50] ] 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]) world.list_of_models = [world.model] compare_pred.i_create_a_local_multi_model(self) compare_pred.i_create_a_local_mm_median_batch_prediction(self, example[4]) compare_pred.the_local_prediction_is(self, example[5])
def test_scenario1(self): """ Scenario: Successfully creating an evaluation: 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 When I create an evaluation for the model with the dataset And I wait until the evaluation is ready less than <time_4> secs Then the measured "<measure>" is <value> Examples: | data | time_1 | time_2 | time_3 | time_4 | measure | value | | ../data/iris.csv | 30 | 30 | 30 | 30 | average_phi | 1 | """ print self.test_scenario1.__doc__ examples = [ ['data/iris.csv', '50', '50', '50', '50', 'average_phi', '1']] 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]) evaluation_create.i_create_an_evaluation(self) evaluation_create.the_evaluation_is_finished_in_less_than(self, example[4]) evaluation_create.the_measured_measure_is_value(self, example[5], example[6])
def test_scenario2(self): """ Scenario: Successfully creating local association object: 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 association from a dataset And I wait until the association is ready less than <time_3> secs And I create a local association When I get the rules for <"item_list"> Then the first rule is "<JSON_rule>" Examples: | data | time_1 | time_2 | time_3 | item_list | JSON_rule | | ../data/tiny_mushrooms.csv | 10 | 20 | 50 | ["Edible"] | {'p_value': 2.08358e-17, 'confidence': 1, 'lift': 1.12613, 'lhs': [14], 'leverage': 0.07885, 'lhs_cover': [0.704, 176], 'rhs_cover': [0.888, 222], 'rhs': [1], 'support': [0.704, 176], 'rule_id': u'000038'} """ print self.test_scenario2.__doc__ examples = [ ['data/tiny_mushrooms.csv', '10', '20', '50', ["Edible"], {'p_value': 5.26971e-31, 'confidence': 1, 'rhs_cover': [0.488, 122], 'leverage': 0.24986, 'rhs': [19], 'rule_id': u'000002', 'lift': 2.04918, 'lhs': [0, 21, 16, 7], 'lhs_cover': [0.488, 122], 'support': [0.488, 122]}]] 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]) association_create.i_create_an_association_from_dataset(self) association_create.the_association_is_finished_in_less_than(self, example[3]) association_create.i_create_a_local_association(self) association_create.i_get_rules_for_item_list(self, example[4]) association_create.the_first_rule_is(self, example[5])
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_scenario5(self): """ Scenario: Successfully creating a local prediction from an Ensemble: 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 of <number_of_models> models and <tlp> tlp And I wait until the ensemble is ready less than <time_3> secs And I create a local Ensemble When I create a local ensemble prediction using median with confidence for "<data_input>" Then the local prediction is "<prediction>" Examples: | data | time_1 | time_2 | time_3 | number_of_models | tlp | data_input |prediction | | ../data/grades.csv | 10 | 10 | 50 | 2 | 1 | {} | 67.5 | """ print self.test_scenario5.__doc__ examples = [ ['data/grades.csv', '30', '30', '50', '2', '1', '{}', 69.0934]] 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, example[4], example[5]) ensemble_create.the_ensemble_is_finished_in_less_than(self, example[3]) ensemble_create.create_local_ensemble(self) prediction_create.create_local_ensemble_prediction_using_median_with_confidence(self, example[6]) compare_pred.the_local_prediction_is(self, example[7])
def test_scenario4(self): """ Scenario: Successfully creating a source from a batch prediction: 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 When I create a batch prediction for the dataset with the model And I wait until the batch prediction is ready less than <time_4> secs Then I create a source from the batch prediction And I wait until the source is ready less than <time_1> secs Examples: | data | time_1 | time_2 | time_3 | time_4 | | ../data/iris.csv | 30 | 30 | 50 | 50 | """ print self.test_scenario4.__doc__ examples = [ ['data/diabetes.csv', '30', '30', '50', '50']] 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]) batch_pred_create.i_create_a_batch_prediction(self) batch_pred_create.the_batch_prediction_is_finished_in_less_than(self, example[4]) batch_pred_create.i_create_a_source_from_batch_prediction(self) source_create.the_source_is_finished(self, example[1])
def test_scenario2(self): """ Scenario: Successfully creating a Fields object and a summary fields file: 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 Fields object from the dataset with objective column "<objective_column>" And I export a summary fields file "<summary_file>" Then I check that the file "<summary_file>" is like "<expected_file>" Examples: | data | time_1 | objective_column | summary_file| expected_file | time_2 | ../data/iris.csv | 10 | 0 | fields_summary.csv | data/fields/fields_summary.csv | 10 """ print self.test_scenario2.__doc__ examples = [ ['data/iris.csv', '10', '0', 'fields_summary.csv', 'data/fields/fields_summary.csv', '10']] 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[5]) fields_steps.create_fields_from_dataset(self, example[2]) fields_steps.generate_summary(self, example[3]) fields_steps.check_summary_like_expected(self, example[3], example[4])
def test_scenario2(self): """ Scenario: Successfully creating a model with missing values and translate the tree model into a set of IF-THEN rules: 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 And I translate the tree into IF_THEN rules Then I check the output is like "<expected_file>" expected file Examples: | data | time_1 | time_2 | time_3 | expected_file | | data/iris_missing2.csv | 10 | 10 | 10 | data/model/if_then_rules_iris_missing2_MISSINGS.txt | """ print self.test_scenario2.__doc__ examples = [["data/iris_missing2.csv", "10", "10", "10", "data/model/if_then_rules_iris_missing2_MISSINGS.txt"]] 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) inspect_model.i_translate_the_tree_into_IF_THEN_rules(self) inspect_model.i_check_if_the_output_is_like_expected_file(self, example[4])
def test_scenario2(self): """ Scenario: Successfully obtaining parsing error counts: 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 "<params>" And I create a dataset And I wait until the dataset is ready less than <time_2> secs When I ask for the error counts in the fields Then the error counts dict is "<error_values>" Examples: | data | time_1 | params | time_2 |error_values | | ../data/iris_missing.csv | 30 | {"fields": {"000000": {"optype": "numeric"}}} |30 |{"000000": 1} | """ print self.test_scenario2.__doc__ examples = [ ['data/iris_missing.csv', '30', '{"fields": {"000000": {"optype": "numeric"}}}', '30', '{"000000": 1}']] 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]) dataset_read.i_get_the_errors_values(self) dataset_read.i_get_the_properties_values( self, 'error counts', example[4])
def test_scenario1(self): """ Scenario: Successfully creating a prediction in DEV mode: Given I want to use api in DEV mode When I create a data source uploading a "<data>" file And I wait until the source is ready less than <time_1> secs And the source has DEV True 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 When I create a prediction for "<data_input>" Then the prediction for "<objective>" is "<prediction>" Examples: | data | time_1 | time_2 | time_3 | data_input | objective | prediction | | ../data/iris.csv | 10 | 10 | 10 | {"petal width": 0.5} | 000004 | Iris-setosa | """ print self.test_scenario1.__doc__ examples = [ ['data/iris.csv', '10', '10', '10', '{"petal width": 0.5}', '000004', 'Iris-setosa']] 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_read.source_has_dev(self, True) 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_create.i_create_a_prediction(self, example[4]) prediction_create.the_prediction_is(self, example[5], example[6])
def test_scenario1(self): """ Scenario: Successfully creating a batch prediction: 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 When I create a batch prediction for the dataset with the model And I wait until the batch prediction is ready less than <time_4> secs And I download the created predictions file to "<local_file>" Then the batch prediction file is like "<predictions_file>" Examples: | data | time_1 | time_2 | time_3 | time_4 | local_file | predictions_file | | ../data/iris.csv | 30 | 30 | 50 | 50 | ./tmp/batch_predictions.csv |./data/batch_predictions.csv | """ print self.test_scenario1.__doc__ examples = [ ['data/iris.csv', '30', '30', '50', '50', 'tmp/batch_predictions.csv', 'data/batch_predictions.csv']] 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]) batch_pred_create.i_create_a_batch_prediction(self) batch_pred_create.the_batch_prediction_is_finished_in_less_than(self, example[4]) batch_pred_create.i_download_predictions_file(self, example[5]) batch_pred_create.i_check_predictions(self, example[6])
def test_scenario5(self): """ Scenario: Successfully creating a batch anomaly score from an anomaly detector: 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 When I create a batch anomaly score And I check the batch anomaly score is ok And I wait until the batch anomaly score is ready less than <time_4> secs And I download the created anomaly score file to "<local_file>" Then the batch anomaly score file is like "<predictions_file>" Examples: | data | time_1 | time_2 | time_3 | time_4 | local_file | predictions_file | | ../data/tiny_kdd.csv | 30 | 30 | 50 | 50 | ./tmp/batch_predictions.csv |./data/batch_predictions_a.csv | """ print self.test_scenario5.__doc__ examples = [ ['data/tiny_kdd.csv', '30', '30', '50', '50', 'tmp/batch_predictions.csv', 'data/batch_predictions_a.csv']] 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]) batch_pred_create.i_create_a_batch_prediction_with_anomaly(self) batch_pred_create.the_batch_anomaly_score_is_finished_in_less_than(self, example[4]) batch_pred_create.i_download_anomaly_score_file(self, example[5]) batch_pred_create.i_check_predictions(self, example[6])
def test_scenario1(self): """ Scenario: Successfully creating a local prediction from an Ensemble: 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 of <number_of_models> models and <tlp> tlp And I wait until the ensemble is ready less than <time_3> secs And I create a local Ensemble When I create a local ensemble prediction with confidence for "<data_input>" Then the local prediction is "<prediction>" And the local prediction's confidence is "<confidence>" And the local probabilities are "<probabilities>" Examples: | data | time_1 | time_2 | time_3 | number_of_models | tlp | data_input |prediction | confidence | ../data/iris.csv | 10 | 10 | 50 | 5 | 1 | {"petal width": 0.5} | Iris-versicolor | 0.3687 | [0.3403, 0.4150, 0.2447] """ print self.test_scenario1.__doc__ examples = [ ['data/iris.csv', '10', '10', '50', '5', '1', '{"petal width": 0.5}', 'Iris-versicolor', '0.415', '["0.3403", "0.4150", "0.2447"]' ]] 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, example[4], example[5]) ensemble_create.the_ensemble_is_finished_in_less_than(self, example[3]) ensemble_create.create_local_ensemble(self) prediction_create.create_local_ensemble_prediction_with_confidence(self, example[6]) compare_pred.the_local_prediction_is(self, example[7]) compare_pred.the_local_prediction_confidence_is(self, example[8]) compare_pred.the_local_probabilities_are(self, example[9])
def test_scenario2(self): """ Scenario: Successfully creating an evaluation for an ensemble: 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 of <number_of_models> models and <tlp> tlp And I wait until the ensemble is ready less than <time_3> secs When I create an evaluation for the ensemble with the dataset And I wait until the evaluation is ready less than <time_4> secs Then the measured "<measure>" is <value> Examples: | data | time_1 | time_2 | number_of_models | tlp | time_3 | time_4 | measure | value | | ../data/iris.csv | 30 | 30 | 5 | 1 | 50 | 30 | average_phi | 0.98029 | """ print self.test_scenario2.__doc__ examples = [ ['data/iris.csv', '50', '50', '5', '1', '80', '80', 'average_phi', '0.98029']] 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, example[3], example[4]) ensemble_create.the_ensemble_is_finished_in_less_than(self, example[5]) evaluation_create.i_create_an_evaluation_ensemble(self) evaluation_create.the_evaluation_is_finished_in_less_than(self, example[6]) evaluation_create.the_measured_measure_is_value(self, example[7], example[8])
def test_scenario3(self): """ Scenario: Successfully creating a Fields object and a modified fields structure from a file: 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 Fields object from the dataset with objective column "<objective_column>" And I import a summary fields file "<summary_file>" as a fields structure Then I check the new field structure has field "<field_id>" as "<optype>" Examples: | data | time_1 | objective_column | summary_file| field_id | optype | time_2 | ../data/iris.csv | 10 | 0 | fields_summary_modified.csv | 000000 | categorical | 10 """ print self.test_scenario3.__doc__ examples = [ ['data/iris.csv', '10', '0', 'data/fields/fields_summary_modified.csv', '000000', 'categorical', '10']] 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[6]) fields_steps.create_fields_from_dataset(self, example[2]) fields_steps.import_summary_file(self, example[3]) fields_steps.check_field_type(self, example[4], example[5])
def test_scenario1(self): """ Scenario: Successfully creating an statistical test from a dataset: 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 statistical test from a dataset And I wait until the statistical test is ready less than <time_3> secs And I update the statistical test name to "<test_name>" When I wait until the statistical test is ready less than <time_4> secs Then the statistical test name is "<correlation_name>" Examples: | data | time_1 | time_2 | time_3 | time_4 | test_name | | ../data/iris.csv | 10 | 10 | 10 | 10 | my new statistical test name | """ print self.test_scenario1.__doc__ examples = [ ['data/iris.csv', '10', '10', '10', '10', 'my new statistical test name']] 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]) statistical_tst_create.i_create_a_tst_from_dataset(self) statistical_tst_create.the_tst_is_finished_in_less_than(self, example[3]) statistical_tst_create.i_update_tst_name(self, example[5]) statistical_tst_create.the_tst_is_finished_in_less_than(self, example[4]) statistical_tst_create.i_check_tst_name(self, example[5])
def test_scenario6(self): """ Scenario: Successfully creating an anomaly score: 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 from a dataset And I wait until the anomaly detector is ready less than <time_3> secs When I create an anomaly score for "<data_input>" Then the anomaly score is "<score>" Examples: | data | time_1 | time_2 | time_3 | data_input | score | | ../data/tiny_kdd.csv | 10 | 10 | 100 | {"src_bytes": 350} | 0.92618 | | ../data/iris_sp_chars.csv | 10 | 10 | 100 | {"pétal&width\u0000": 300} | 0.90198 | """ print self.test_scenario6.__doc__ examples = [ ['data/tiny_kdd.csv', '10', '10', '100', '{"src_bytes": 350}', '0.92846'], ['data/iris_sp_chars.csv', '10', '10', '100', '{"pétal&width\u0000": 300}', '0.89313']] 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_create.i_create_an_anomaly_score(self, example[4]) prediction_create.the_anomaly_score_is(self, example[5])
def test_scenario1(self): """ Scenario: Successfully creating and reading a public dataset: 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 make the dataset public And I wait until the dataset is ready less than <time_3> secs When I get the dataset status using the dataset's public url Then the dataset's status is FINISHED Examples: | data | time_1 | time_2 | time_3 | | ../data/iris.csv | 10 | 10 | 10 | """ print self.test_scenario1.__doc__ examples = [ ['data/iris.csv', '10', '10', '10']] 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.make_the_dataset_public(self) dataset_create.the_dataset_is_finished_in_less_than(self, example[3]) dataset_create.build_local_dataset_from_public_url(self) dataset_create.dataset_status_finished(self)
def test_scenario5(self): """ Scenario: Successfully creating a centroid and the associated dataset: 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 And I wait until the cluster is ready less than <time_3> secs When I create a centroid for "<data_input>" And I check the centroid is ok Then the centroid is "<centroid>" And I create a dataset from the cluster and the centroid And I wait until the dataset is ready less than <time_2> secs And I check that the dataset is created for the cluster and the centroid Examples: | data | time_1 | time_2 | time_3 | data_input | centroid | | ../data/diabetes.csv | 10 | 20 | 20 | {"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 | """ print self.test_scenario5.__doc__ examples = [ ['data/diabetes.csv', '10', '20', '20', '{"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']] 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_create.i_create_a_centroid(self, example[4]) prediction_create.the_centroid_is(self, example[5])
def test_scenario1(self): """ Scenario: Successfully creating a prediction using a public 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 make the model public And I wait until the model is ready less than <time_3> secs And I check the model status using the model's public url When I create a prediction for "<data_input>" Then the prediction for "<objective>" is "<prediction>" Examples: | data | time_1 | time_2 | time_3 | data_input | objective | prediction | | ../data/iris.csv | 10 | 10 | 10 | {"petal width": 0.5} | 000004 | Iris-setosa | """ print self.test_scenario1.__doc__ examples = [ ['data/iris.csv', '10', '10', '10', '{"petal width": 0.5}', '000004', 'Iris-setosa']] 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]) model_create.make_the_model_public(self) model_create.the_model_is_finished_in_less_than(self, example[3]) model_create.model_from_public_url(self) prediction_create.i_create_a_prediction(self, example[4]) prediction_create.the_prediction_is(self, example[5], example[6])
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_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', '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"}], ['data/grades.csv', '10', '10', '50', '{}', '000005', '70.505792', '30.7161', '{"number_of_models": 5}', {}], ['data/grades.csv', '10', '10', '50', '{"Midterm": 20}', '000005', '54.82214', '25.89672', '{"number_of_models": 5}', {"operating_kind": "confidence"}], ['data/grades.csv', '10', '10', '50', '{"Midterm": 20}', '000005', '45.4573', '29.58403', '{"number_of_models": 5}', {}], ['data/grades.csv', '10', '10', '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_scenario3(self): """ Scenario: Successfully comparing predictions for deepnets with operating point: 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 point "<operating_point>" for "<data_input>" Then the prediction for "<objective>" is "<prediction>" And I create a local prediction with operating point "<operating_point>" 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 width": 4}', '000004', 'Iris-versicolor', '{}', { "kind": "probability", "threshold": 1, "positive_class": "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]) 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_with_op( self, example[4], example[8]) prediction_create.the_prediction_is(self, example[5], example[6]) prediction_compare.i_create_a_local_deepnet_prediction_with_op( self, example[4], example[8]) prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario2(self): """ Scenario: Successfully creating a local batch prediction from a multi 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 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 local multi model When I create a batch multimodel prediction for "<data_inputs>" Then the predictions are "<predictions>" Examples: | data | time_1 | time_2 | time_3 | params | tag | data_inputs | predictions | | ../data/iris.csv | 10 | 10 | 10 | {"tags":["mytag"]} | mytag | [{"petal width": 0.5}, {"petal length": 6, "petal width": 2}] | ["Iris-setosa", "Iris-virginica"] | """ print self.test_scenario2.__doc__ examples = [[ 'data/iris.csv', '10', '10', '10', '{"tags":["mytag"]}', 'mytag', '[{"petal width": 0.5}, {"petal length": 6, "petal width": 2}]', '["Iris-setosa", "Iris-virginica"]' ]] 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[4]) model_create.the_model_is_finished_in_less_than(self, example[3]) model_create.i_create_a_model_with(self, example[4]) model_create.the_model_is_finished_in_less_than(self, example[3]) model_create.i_create_a_model_with(self, example[4]) model_create.the_model_is_finished_in_less_than(self, example[3]) compare_pred.i_retrieve_a_list_of_remote_models(self, example[5]) compare_pred.i_create_a_local_multi_model(self) compare_pred.i_create_a_batch_prediction_from_a_multi_model( self, example[6]) compare_pred.the_batch_mm_predictions_are(self, example[7])
def test_scenario8(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 regresssion 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 | | ../data/iris.csv | 10 | 10 | 10 | {"petal width": 0.5, "petal length": 0.5, "sepal width": 0.5, "sepal length": 0.5} | 'Iris-virginica' | | ../data/iris.csv | 10 | 10 | 10 | {"petal width": 2, "petal length": 6, "sepal width": 0.5, "sepal length": 0.5} | Iris-virginica | | ../data/iris.csv | 10 | 10 | 10 | {"petal width": 1.5, "petal length": 4, "sepal width": 0.5, "sepal length": 0.5} | Iris-virginica | | ../data/iris.csv | 10 | 10 | 10 | {"petal width": 1} | Iris-versicolor | | ../data/iris_sp_chars.csv | 10 | 10 | 10 | {"pétal.length": 4, "pétal&width\u0000": 1.5, "sépal&width": 0.5, "sépal.length": 0.5}| Iris-virginica | | ../data/price.csv | 10 | 10 | 10 | {"Price": 1200}| Product1 | """ print self.test_scenario8.__doc__ examples = [ ['data/iris.csv', '10', '10', '50', '{"petal width": 0.5, "petal length": 0.5, "sepal width": 0.5, "sepal length": 0.5}', 'Iris-virginica'], ['data/iris.csv', '10', '10', '50', '{"petal width": 2, "petal length": 6, "sepal width": 0.5, "sepal length": 0.5}', 'Iris-virginica'], ['data/iris.csv', '10', '10', '50', '{"petal width": 1.5, "petal length": 4, "sepal width": 0.5, "sepal length": 0.5}', 'Iris-virginica'], ['data/iris.csv', '10', '10', '50', '{"petal length": 1}', 'Iris-virginica'], ['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-virginica'], ['data/price.csv', '10', '10', '50', '{"Price": 1200}', 'Product2']] 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])
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', 'spam'], ['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_scenario15(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 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/iris.csv', '20', '20', '180', '{"weight_field": "000000", "missing_numerics": false}', '{"petal width": 1.5, "petal length": 2, "sepal width":1}', 'Iris-versicolor', '0.9547', '000004' ]] show_doc(self.test_scenario15, 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_with_objective_and_parms( self, example[8], example[4]) 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_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_scenario1(self): """ Scenario: Successfully creating a batch prediction from a multi 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 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 local multi model When I create a batch prediction for "<data_input>" and save it in "<path>" And I combine the votes in "<path>" Then the plurality combined predictions are "<predictions>" And the confidence weighted predictions are "<predictions>" Examples: | data | time_1 | time_2 | time_3 | params | tag | data_input | path | predictions | | ../data/iris.csv | 10 | 10 | 10 | {"tags":["mytag"]} | mytag | [{"petal width": 0.5}, {"petal length": 6, "petal width": 2}, {"petal length": 4, "petal width": 1.5}] | ./tmp | ["Iris-setosa", "Iris-virginica", "Iris-versicolor"] | """ print self.test_scenario1.__doc__ examples = [ ['data/iris.csv', '10', '10', '10', '{"tags":["mytag"]}', 'mytag', '[{"petal width": 0.5}, {"petal length": 6, "petal width": 2}, {"petal length": 4, "petal width": 1.5}]', './tmp', '["Iris-setosa", "Iris-virginica", "Iris-versicolor"]']] 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[4]) model_create.the_model_is_finished_in_less_than(self, example[3]) model_create.i_create_a_model_with(self, example[4]) model_create.the_model_is_finished_in_less_than(self, example[3]) model_create.i_create_a_model_with(self, example[4]) model_create.the_model_is_finished_in_less_than(self, example[3]) compare_pred.i_retrieve_a_list_of_remote_models(self, example[5]) compare_pred.i_create_a_local_multi_model(self) compare_pred.i_create_a_batch_prediction(self, example[6], example[7]) compare_pred.i_combine_the_votes(self, example[7]) compare_pred.the_plurality_combined_prediction(self, example[8]) compare_pred.the_confidence_weighted_prediction(self, example[8])
def test_scenario10(self): """ Scenario 10: Successfully creating a local fusion from an exported file: 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_3> secs And I export the fusion to "<exported_file>" When I create a local fusion from the file "<exported_file>" Then the fusion ID and the local fusion ID match Examples: | data | time_1 | time_2 | time_3 | exported_file | params | tag | ../data/iris.csv | 10 | 10 | 50 | ./tmp/fusion.json """ print self.test_scenario10.__doc__ examples = [ ['data/iris.csv', '10', '10', '50', './tmp/fusion.json', 'my_fusion_tag']] 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]) model_create.i_create_a_model_with(self, tag_args) model_create.the_model_is_finished_in_less_than(self, example[3]) model_create.i_create_a_model_with(self, tag_args) model_create.the_model_is_finished_in_less_than(self, example[3]) model_create.i_create_a_model_with(self, tag_args) model_create.the_model_is_finished_in_less_than(self, example[3]) prediction_compare.i_retrieve_a_list_of_remote_models(self, tag) model_create.i_create_a_fusion(self) model_create.the_fusion_is_finished_in_less_than(self, example[3]) model_create.i_export_fusion(self, example[4]) model_create.i_create_local_fusion_from_file(self, example[4]) model_create.check_fusion_id_local_id(self)
def test_scenario1(self): """ Scenario: Successfully creating an anomaly detector from a dataset and a dataset list: 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 Then I create an anomaly detector from a dataset And I wait until the anomaly detector is ready less than <time_4> secs And I check the anomaly detector stems from the original dataset And I store the dataset id in a list And I create a dataset And I wait until the dataset is ready less than <time_3> secs And I store the dataset id in a list Then I create an anomaly detector from a dataset list And I wait until the anomaly detector is ready less than <time_4> secs And I check the anomaly detector stems from the original dataset list Examples: | data | time_1 | time_2 | time_3 | time_4 | | ../data/tiny_kdd.csv | 40 | 40 | 40 | 100 """ print self.test_scenario1.__doc__ examples = [ ['data/tiny_kdd.csv', '40', '40', '40', '100']] 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_from_dataset(self) anomaly_create.the_anomaly_is_finished_in_less_than(self, example[4]) anomaly_create.i_check_anomaly_dataset_and_datasets_ids(self) mm_create.i_store_dataset_id(self) dataset_create.i_create_a_dataset(self) dataset_create.the_dataset_is_finished_in_less_than(self, example[3]) mm_create.i_store_dataset_id(self) anomaly_create.i_create_an_anomaly_from_dataset_list(self) anomaly_create.the_anomaly_is_finished_in_less_than(self, example[4]) anomaly_create.i_check_anomaly_datasets_and_datasets_ids(self)
def test_scenario2(self): """ Scenario: Successfully creating local association object: 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 association from a dataset And I wait until the association is ready less than <time_3> secs And I create a local association When I get the rules for <"item_list"> Then the first rule is "<JSON_rule>" Examples: | data | time_1 | time_2 | time_3 | item_list | JSON_rule | | ../data/tiny_mushrooms.csv | 10 | 20 | 50 | ["Edible"] | {'p_value': 2.08358e-17, 'confidence': 1, 'lift': 1.12613, 'lhs': [14], 'leverage': 0.07885, 'lhs_cover': [0.704, 176], 'rhs_cover': [0.888, 222], 'rhs': [1], 'support': [0.704, 176], 'rule_id': u'000038'} """ print self.test_scenario2.__doc__ examples = [[ 'data/tiny_mushrooms.csv', '10', '20', '50', ["Edible"], { 'p_value': 5.26971e-31, 'confidence': 1, 'rhs_cover': [0.488, 122], 'leverage': 0.24986, 'rhs': [19], 'rule_id': u'000002', 'lift': 2.04918, 'lhs': [0, 21, 16, 7], 'lhs_cover': [0.488, 122], 'support': [0.488, 122] } ]] 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]) association_create.i_create_an_association_from_dataset(self) association_create.the_association_is_finished_in_less_than( self, example[3]) association_create.i_create_a_local_association(self) association_create.i_get_rules_for_item_list(self, example[4]) association_create.the_first_rule_is(self, example[5])
def test_scenario2(self): """ Scenario: Successfully creating a prediction using a shared 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 make the model shared And I wait until the model is ready less than <time_3> secs And I get the model sharing info And I check the model status using the model's shared url And I check the model status using the model's shared key And I create a local model When I create a local prediction for "<data_input>" Then the local prediction is "<prediction>" Examples: | data | time_1 | time_2 | time_3 | data_input | prediction | | ../data/iris.csv | 10 | 10 | 10 | {"petal width": 0.5} | Iris-setosa | """ print self.test_scenario2.__doc__ examples = [[ 'data/iris.csv', '10', '10', '10', '{"petal width": 0.5}', 'Iris-setosa' ]] 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]) model_create.make_the_model_shared(self) model_create.the_model_is_finished_in_less_than(self, example[3]) model_create.get_sharing_info(self) model_create.model_from_shared_url(self) model_create.model_from_shared_key(self) compare_pred.i_create_a_local_model(self) compare_pred.i_create_a_local_prediction(self, example[4]) compare_pred.the_local_prediction_is(self, example[5])
def test_scenario2(self): """ Scenario: Successfully obtaining field importance from an Ensemble: 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 "<parms1>" And I wait until the model is ready less than <time_3> secs And I create a model with "<parms2>" And I wait until the model is ready less than <time_4> secs And I create a model with "<parms3>" And I wait until the model is ready less than <time_5> secs When I create a local Ensemble with the last <number_of_models> models Then the field importance text is <field_importance> Examples: | data | time_1 | time_2 |parms1 | time_3 |parms2 | time_4 |parms3| time_5 |number_of_models |field_importance | ../data/iris.csv | 10 | 10 |{"input_fields": ["000000", "000001","000003", "000004"]} |20 |{"input_fields": ["000000", "000001","000002", "000004"]} | 20 |{"input_fields": ["000000", "000001","000002", "000003", "000004"]} | 20 | 3 |[["000002", 0.5269933333333333], ["000003", 0.38936], ["000000", 0.04662333333333333], ["000001", 0.037026666666666666]] """ print self.test_scenario2.__doc__ examples = [[ 'data/iris.csv', '10', '10', '{"input_fields": ["000000", "000001","000003", "000004"]}', '20', '{"input_fields": ["000000", "000001","000002", "000004"]}', '20', '{"input_fields": ["000000", "000001","000002", "000003", "000004"]}', '20', '3', '[["000002", 0.5269933333333333], ["000003", 0.38936], ["000000", 0.04662333333333333], ["000001", 0.037026666666666666]]' ]] 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[3]) model_create.the_model_is_finished_in_less_than(self, example[4]) model_create.i_create_a_model_with(self, example[5]) model_create.the_model_is_finished_in_less_than(self, example[6]) model_create.i_create_a_model_with(self, example[7]) model_create.the_model_is_finished_in_less_than(self, example[8]) ensemble_create.create_local_ensemble_with_list(self, example[9]) ensemble_create.field_importance_print(self, example[10])
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_scenario1(self): """ Scenario: Successfully creating a prediction from a multi 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 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 local multi model When I create a local prediction for "<data_input>" Then the prediction for "<objective>" is "<prediction>" Examples: | data | time_1 | time_2 | time_3 | params | tag | data_input | prediction | | ../data/iris.csv | 10 | 10 | 10 | {"tags":["mytag"]} | mytag | {"petal width": 0.5} | Iris-setosa | """ print self.test_scenario1.__doc__ examples = [[ 'data/iris.csv', '10', '10', '10', '{"tags":["mytag"]}', 'mytag', '{"petal width": 0.5}', 'Iris-setosa' ]] 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[4]) model_create.the_model_is_finished_in_less_than(self, example[3]) model_create.i_create_a_model_with(self, example[4]) model_create.the_model_is_finished_in_less_than(self, example[3]) model_create.i_create_a_model_with(self, example[4]) model_create.the_model_is_finished_in_less_than(self, example[3]) compare_pred.i_retrieve_a_list_of_remote_models(self, example[5]) compare_pred.i_create_a_local_multi_model(self) compare_pred.i_create_a_local_prediction(self, example[6]) compare_pred.the_local_prediction_is(self, example[7])
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 | | ../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 | 46.69889 | 37.27594297134128 | | ../data/grades.csv | 10 | 10 | 10 | {"Midterm": 20, "Tutorial": 90, "TakeHome": 100} | 000005 | 28.06 | 24.86634 | """ print self.test_scenario3.__doc__ 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', '46.69889', '37.27594297134128'], ['data/grades.csv', '10', '10', '10', '{"Midterm": 20, "Tutorial": 90, "TakeHome": 100}', '000005', '28.06', '24.86634']] 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_compare.i_create_a_proportional_local_prediction(self, example[4]) prediction_compare.the_local_prediction_is(self, example[6])
def test_scenario10(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 | ../data/spam.csv | 20 | 20 | 000002 | 30 | {"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}} |{"Message": "A normal message"} | ham | 0.7645 """ print self.test_scenario10.__doc__ examples = [ ['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}}', '{"Message": "A normal message"}', 'ham', 0.7645, "000000"], ['data/spam.csv', '20', '20', '30', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "all", "language": "en"}}}}', '{"Message": "mobile"}', 'spam', 0.7175, "000000"], ['data/movies.csv', '20', '20', '30', '{"fields": {"000007": {"optype": "items", "item_analysis": {"separator": "$"}}}}', '{"gender": "Female", "genres": "Adventure$Action", "timestamp": 993906291, "occupation": "K-12 student", "zipcode": 59583, "rating": 3}', '25-34', '0.4135', '000002']] 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(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 creating a model and translate the tree model into a set of IF-THEN rules: 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 "<options>" waiting 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 And I translate the tree into IF_THEN rules Then I check the output is like "<expected_file>" expected file Examples: | data | time_1 | time_2 | time_3 | options | expected_file | | data/spam.csv | 20 | 20 | 30 | {"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}} | data/model/if_then_rules_spam_textanalysis_1.txt | | data/spam.csv | 20 | 20 | 30 | {"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false}}}} | data/model/if_then_rules_spam_textanalysis_2.txt | | data/spam.csv | 20 | 20 | 30 | {"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": false, "use_stopwords": false, "language": "en"}}}} | data/model/if_then_rules_spam_textanalysis_3.txt | | data/spam.csv | 20 | 20 | 30 | {"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": true, "use_stopwords": true, "language": "en"}}}} | data/model/if_then_rules_spam_textanalysis_4.txt | | data/spam.csv | 20 | 20 | 30 | {"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}} | data/model/if_then_rules_spam_textanalysis_5.txt | | data/spam.csv | 20 | 20 | 30 | {"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}} | data/model/if_then_rules_spam_textanalysis_6.txt | """ print self.test_scenario3.__doc__ examples = [ ['data/spam.csv', '10', '10', '10', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}','data/model/if_then_rules_spam_textanalysis_1.txt'], ['data/spam.csv', '10', '10', '10', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false}}}}', 'data/model/if_then_rules_spam_textanalysis_2.txt'], ['data/spam.csv', '10', '10', '10', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": false, "use_stopwords": false, "language": "en"}}}}', 'data/model/if_then_rules_spam_textanalysis_3.txt'], ['data/spam.csv', '10', '10', '10', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": false, "stem_words": true, "use_stopwords": true, "language": "en"}}}}', 'data/model/if_then_rules_spam_textanalysis_4.txt'], ['data/spam.csv', '10', '10', '10', '{"fields": {"000001": {"optype": "text", "term_analysis": {"token_mode": "full_terms_only", "language": "en"}}}}', 'data/model/if_then_rules_spam_textanalysis_5.txt'], ['data/spam.csv', '10', '10', '10', '{"fields": {"000001": {"optype": "text", "term_analysis": {"case_sensitive": true, "stem_words": true, "use_stopwords": false, "language": "en"}}}}', 'data/model/if_then_rules_spam_textanalysis_6.txt']] 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) inspect_model.i_translate_the_tree_into_IF_THEN_rules(self) inspect_model.i_check_if_the_output_is_like_expected_file(self, example[5])
def test_scenario1(self): """ Scenario: Successfully creating a model and translate the tree model into a set of IF-THEN rules: 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 And I translate the tree into IF_THEN rules Then I check the output is like "<expected_file>" expected file Examples: | data | time_1 | time_2 | time_3 | expected_file | | data/iris.csv | 10 | 10 | 10 | data/model/if_then_rules_iris.txt | | data/iris_sp_chars.csv | 10 | 10 | 10 | data/model/if_then_rules_iris_sp_chars.txt | | data/spam.csv | 20 | 20 | 30 | data/model/if_then_rules_spam.txt | | data/grades.csv | 10 | 10 | 10 | data/model/if_then_rules_grades.txt | | data/diabetes.csv | 20 | 20 | 30 | data/model/if_then_rules_diabetes.txt | | data/iris_missing2.csv | 10 | 10 | 10 | data/model/if_then_rules_iris_missing2.txt | | data/tiny_kdd.csv | 20 | 20 | 30 | data/model/if_then_rules_tiny_kdd.txt | """ print self.test_scenario1.__doc__ examples = [ ['data/iris.csv', '10', '10', '10', 'data/model/if_then_rules_iris.txt'], ['data/iris_sp_chars.csv', '10', '10', '10', 'data/model/if_then_rules_iris_sp_chars.txt'], ['data/spam.csv', '10', '10', '10', 'data/model/if_then_rules_spam.txt'], ['data/grades.csv', '10', '10', '10', 'data/model/if_then_rules_grades.txt'], ['data/diabetes.csv', '10', '10', '10', 'data/model/if_then_rules_diabetes.txt'], ['data/iris_missing2.csv', '10', '10', '10', 'data/model/if_then_rules_iris_missing2.txt'], ['data/tiny_kdd.csv', '10', '10', '10', 'data/model/if_then_rules_tiny_kdd.txt']] 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) inspect_model.i_translate_the_tree_into_IF_THEN_rules(self) inspect_model.i_check_if_the_output_is_like_expected_file(self, example[4])
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_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_scenario3(self): """ Scenario: Successfully getting the closest point in a cluster: 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 And I wait until the cluster is ready less than <time_3> secs And I create a local cluster Then the data point in the cluster closest to "<reference>" is "<closest>" Examples: | data | time_1 | time_2 | time_3 | reference | closest | """ print self.test_scenario3.__doc__ examples = [[ 'data/iris.csv', '10', '10', '40', '{"petal length": 1.4, "petal width": 0.2,' ' "sepal width": 3.0, "sepal length": 4.89,' ' "species": "Iris-setosa"}', '{"distance": 0.001894153207990619, "data":' ' {"petal length": "1.4", "petal width": "0.2",' ' "sepal width": "3.0", "sepal length": "4.9",' ' "species": "Iris-setosa"}}' ], [ 'data/spam_4w.csv', '10', '10', '40', '{"Message": "mobile"}', '{"distance": 0.0, "data":' ' {"Message": "mobile", "Type": "spam"}}' ]] 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) cluster_create.closest_in_cluster(self, example[4], example[5])
def test_scenario3(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/dates2.csv', '20', '30', '80', '{"target-2": -1}', 'data/associations/association_set2.json' ]] 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]) 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[4]) prediction_compare.the_association_set_is_like_file( self, example[5]) prediction_compare.i_create_a_local_association_set( self, example[4]) prediction_compare.the_local_association_set_is_like_file( self, example[5])
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_scenario5(self): """ Scenario: Successfully comparing centroids with summary 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 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 | | ../data/iris.csv | 20 | 20 | 30 | {"summary_fields": ["sepal width"]} |{"petal length": 1, "petal width": 1, "sepal length": 1, "species": "Iris-setosa"} | Cluster 6 | 0.713698082167 | """ print self.test_scenario5.__doc__ examples = [[ 'data/iris.csv', '20', '20', '30', '{"summary_fields": ["sepal width"]}', '{"petal length": 1, "petal width": 1, "sepal length": 1, "species": "Iris-setosa"}', 'Cluster 6', '0.713698082167' ]] 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[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_scenario1(self): """ Scenario: Successfully creating forecasts from a dataset: 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 time-series from a dataset And I wait until the time series is ready less than <time_3> secs And I update the time series name to "<time_series_name>" When I wait until the time series is ready less than <time_4> secs Then the time series name is "<time_series_name>" And I create a forecast for "<input_data>" Then the forecasts are "<forecast_points>" Examples: | data | time_1 | time_2 | time_3 | time_4 | time_series_name |input_data | forecast_points | ../data/grades.csv | 10 | 10 | 20 | 50 | my new time_series name | {"000005": {"horizon": 5}], {}} """ print self.test_scenario1.__doc__ examples = [[ 'data/grades.csv', '30', '30', '50', '50', 'my new time series name', '{"000005": {"horizon": 5}}', '{"000005": [{"point_forecast": [73.96192, 74.04106, 74.12029, 74.1996, 74.27899], "model": "M,M,N"}]}' ]] 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(self) time_series_create.the_time_series_is_finished_in_less_than( self, example[3]) time_series_create.i_update_time_series_name(self, example[5]) time_series_create.the_time_series_is_finished_in_less_than( self, example[4]) time_series_create.i_check_time_series_name(self, example[5]) forecast_create.i_create_a_forecast(self, example[6]) forecast_create.the_forecast_is(self, example[7])
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.051, "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.051, "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])