compute_predict

Author: pplonski

mljar/client/dataset.py

@@ -4,6 +4,7 @@
 import os
 import sys
 import time
+import copy
 from zipfile import ZipFile, ZIP_DEFLATED
 from os.path import basename
 from base import MljarHttpClient
@@ -45,6 +46,12 @@ def get_dataset(self, dataset_hid):
             logger.error('Dataset not found')
             return None
 
+    def delete_dataset(self, dataset_hid):
+        '''
+        Deletes dataset
+        '''
+        response = self.request("DELETE", '/'.join([self.url, dataset_hid]))
+        return response.status_code == 204 or response.status_code == 200
 
     def _prepare_data(self, X, y):
         '''
@@ -55,22 +62,23 @@ def _prepare_data(self, X, y):
         if isinstance(X, np.ndarray):
             cols = {}
             col_names = []
-            for i in xrange(X.shape[1]):
+            X_cpy = copy.deepcopy(X)
+            for i in xrange(X_cpy.shape[1]):
                 c = 'attribute_'+str(i+1)
-                cols[c] = X[:,i]
+                cols[c] = X_cpy[:,i]
                 col_names += [c]
             if y is not None:
-                cols['target'] = y
+                cols['target'] = copy.deepcopy(y)
                 col_names.append('target')
             data = pd.DataFrame(cols, columns=col_names)
         if isinstance(X, pd.DataFrame):
             if y is not None:
-                data = X
-                data['target'] = y
+                data = copy.deepcopy(X)
+                data['target'] = copy.deepcopy(y)
                 # todo: add search for target like attributes and rename
                 # "target", "class", "loss"
             else:
-                data = X
+                data = copy.deepcopy(X)
 
         dataset_hash = str(make_hash(data))
         return data, dataset_hash

mljar/mljar.py

@@ -286,6 +286,8 @@ def predict(self, X):
 
         if self.selected_algorithm is not None:
 
+            return Mljar.compute_prediction(X, self.selected_algorithm.hid, self.project.hid)
+            '''
             # chack if dataset exists in mljar if not upload dataset for prediction
             dataset = DatasetClient(self.project.hid).add_dataset_if_not_exists(X, y = None)
 
@@ -317,10 +319,11 @@ def predict(self, X):
             logger.error('Sorry, there was some problem with computing prediction for your dataset. \
                             Please login to mljar.com to your account and check details.')
             return None
+            '''
 
 
     @staticmethod
-    def compute_prediction(X, model_id, project_id):
+    def compute_prediction(X, model_id, project_id, keep_dataset = False):
 
 
         # chack if dataset exists in mljar if not upload dataset for prediction
@@ -344,6 +347,8 @@ def compute_prediction(X, model_id, project_id):
             if prediction is not None:
                 pred = PredictionDownloadClient().download(prediction.hid)
                 #sys.stdout.write('\r\n')
+                if not keep_dataset:
+                    DatasetClient(project_id).delete_dataset(dataset.hid)
                 return pred
 
             #sys.stdout.write('\rFetch predictions: {0}%'.format(round(i/(total_checks*0.01))))

tests/dataset_client_test.py

@@ -23,13 +23,14 @@ def setUp(self):
         df = pd.read_csv('tests/data/test_1.csv')
         cols = ['sepal length', 'sepal width', 'petal length', 'petal width']
         target = 'class'
-        self.X = df[cols]
+        self.X = df.loc[:,cols]
         self.y = df[target]
 
     def tearDown(self):
         # clean
         self.project_client.delete_project(self.project.hid)
 
+
     def test_get_datasests(self):
         """
         Get empty list of datasets in project.
@@ -117,3 +118,39 @@ def test_add_existing_dataset(self):
         # number of all datasets in project should be 1
         datasets = dc.get_datasets()
         self.assertEqual(len(datasets), init_datasets_cnt+1)
+
+
+    def test_prepare_data_two_sources(self):
+        dc = DatasetClient(self.project.hid)
+        data_1, data_hash_1 = dc._prepare_data(self.X, self.y)
+        data_2, data_hash_2 = dc._prepare_data(self.X, None)
+        self.assertNotEqual(data_hash_1, data_hash_2)
+
+
+    def test_prepare_data_two_sources_numpy(self):
+        dc = DatasetClient(self.project.hid)
+        data_1, data_hash_1 = dc._prepare_data(np.array(self.X), np.array(self.y))
+        data_2, data_hash_2 = dc._prepare_data(np.array(self.X), None)
+        self.assertNotEqual(data_hash_1, data_hash_2)
+
+    def test_create_and_delete(self):
+        # setup dataset client
+        dc = DatasetClient(self.project.hid)
+        self.assertNotEqual(dc, None)
+        # get initial number of datasets
+        init_datasets_cnt = len(dc.get_datasets())
+        # add dataset
+        my_dataset_1 = dc.add_dataset_if_not_exists(self.X, self.y)
+        my_dataset_2 = dc.add_dataset_if_not_exists(self.X, y = None)
+        # get datasets
+        datasets = dc.get_datasets()
+        self.assertEqual(len(datasets), init_datasets_cnt+2)
+        # delete added dataset
+        dc.delete_dataset(my_dataset_1.hid)
+        # check number of datasets
+        datasets = dc.get_datasets()
+        self.assertEqual(len(datasets), init_datasets_cnt+1)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/mljar_test.py

@@ -8,6 +8,7 @@
 import time
 
 from mljar.client.project import ProjectClient
+from mljar.client.dataset import DatasetClient
 from project_based_test import ProjectBasedTest
 from mljar.exceptions import BadValueException, IncorrectInputDataException
 from mljar.utils import MLJAR_DEFAULT_TUNING_MODE
@@ -26,9 +27,10 @@ def setUp(self):
         self.X = df[cols]
         self.y = df[target]
 
-    #def tearDown(self):
-    #    # clean
-    #    ProjectBasedTest.clean_projects()
+    def tearDown(self):
+        # clean
+        ProjectBasedTest.clean_projects()
+
 
     def mse(self, predictions, targets):
         predictions = np.array(predictions)
@@ -38,12 +40,10 @@ def mse(self, predictions, targets):
 
 
     def test_compute_prediction(self):
-        '''
-        Test the most common usage.
-        '''
         model = Mljar(project = self.proj_title, experiment = self.expt_title,
-                        algorithms = ['rfc'], metric='logloss',
-                        validation_kfolds=3, tuning_mode='Normal')
+                        algorithms = ['rfc'], metric = 'logloss',
+                        validation_kfolds = 3, tuning_mode = 'Normal',
+                        single_algorithm_time_limit = 1)
         self.assertTrue(model is not None)
         # fit models and wait till all models are trained
         model.fit(X = self.X, y = self.y)
@@ -52,19 +52,29 @@ def test_compute_prediction(self):
         project_id = model.project.hid
         # get model id
         model_id = model.selected_algorithm.hid
+
+        dc = DatasetClient(project_id)
+        init_datasets_cnt = len(dc.get_datasets())
         # compute predictions
         pred = Mljar.compute_prediction(self.X, model_id, project_id)
         # compute score
         score = self.mse(pred, self.y)
         self.assertTrue(score < 0.1)
+        # check if dataset was removed
+        self.assertEqual(init_datasets_cnt, len(dc.get_datasets()))
+        # run predictions again, but keep dataset
+        pred = Mljar.compute_prediction(self.X, model_id, project_id, keep_dataset = True)
+        self.assertEqual(init_datasets_cnt+1, len(dc.get_datasets())) # should be one more
+
 
     def test_basic_usage(self):
         '''
         Test the most common usage.
         '''
         model = Mljar(project = self.proj_title, experiment = self.expt_title,
-                        algorithms = ['xgb'], metric='logloss',
-                        validation_kfolds=3, tuning_mode='Normal')
+                        algorithms = ['xgb'], metric = 'logloss',
+                        validation_kfolds = 3, tuning_mode = 'Normal',
+                        single_algorithm_time_limit = 1)
         self.assertTrue(model is not None)
         # fit models and wait till all models are trained
         model.fit(X = self.X, y = self.y)
@@ -97,7 +107,8 @@ def test_usage_with_train_split(self):
         Test usage with train split.
         '''
         model = Mljar(project = self.proj_title, experiment = self.expt_title,
-                    validation_train_split = 0.8, algorithms = ['xgb'], tuning_mode='Normal')
+                    validation_train_split = 0.8, algorithms = ['xgb'], tuning_mode='Normal',
+                    single_algorithm_time_limit=1)
         self.assertTrue(model is not None)
         # fit models and wait till all models are trained
         model.fit(X = self.X, y = self.y, wait_till_all_done = False)
@@ -117,7 +128,8 @@ def test_usage_with_validation_dataset(self):
         Test usage with validation dataset.
         '''
         model = Mljar(project = self.proj_title, experiment = self.expt_title,
-                            algorithms = ['xgb'], tuning_mode='Normal')
+                            algorithms = ['xgb'], tuning_mode='Normal',
+                            single_algorithm_time_limit = 1)
         self.assertTrue(model is not None)
         # load validation data
         df = pd.read_csv('tests/data/test_1_vald.csv')
@@ -174,7 +186,8 @@ def test_non_wait_fit(self):
         '''
         model = Mljar(project = self.proj_title, experiment = self.expt_title,
                         algorithms = ['xgb'], metric='logloss',
-                        validation_kfolds=3, tuning_mode='Normal')
+                        validation_kfolds=3, tuning_mode='Normal',
+                        single_algorithm_time_limit = 1)
         self.assertTrue(model is not None)
         # fit models, just start computation and do not wait
         start_time = time.time()
@@ -211,8 +224,9 @@ def test_retrive_models(self):
         all models will be simply retrived from existing project.
         '''
         model = Mljar(project = self.proj_title, experiment = self.expt_title,
-                        algorithms = ['xgb'], metric='logloss',
-                        validation_kfolds=3, tuning_mode='Normal')
+                        algorithms = ['xgb'], metric = 'logloss',
+                        validation_kfolds = 3, tuning_mode = 'Normal',
+                        single_algorithm_time_limit = 1)
         self.assertTrue(model is not None)
         # fit models and wait till all models are trained
         model.fit(X = self.X, y = self.y)
@@ -240,8 +254,9 @@ def test_retrive_models(self):
         # re-use project
         start_time = time.time()
         model_2 = Mljar(project = self.proj_title, experiment = self.expt_title,
-                        algorithms = ['xgb'], metric='logloss',
-                        validation_kfolds=3, tuning_mode='Normal')
+                        algorithms = ['xgb'], metric = 'logloss',
+                        validation_kfolds = 3, tuning_mode = 'Normal',
+                        single_algorithm_time_limit = 1)
         self.assertTrue(model_2 is not None)
         # re-use trained models
         model_2.fit(X = self.X, y = self.y)