def test_error_linear_regression_parameter_n_jobs_float_type(self):
     # given: error input parameter "n_jobs" needs to be type(int)
     arg_dict = {
         "fit_intercept": True,
         "normalize": False,
         "copy_X": True,
         "n_jobs": 1.0
     }
     algo_input = alc.AlgoParam(algo_control={
         'mode': 'training',
         'control_params': arg_dict
     },
                                algo_data={
                                    'data': self.boston_data,
                                    'label': self.boston_label
                                },
                                algo_model={
                                    'model_params': None,
                                    'model_instance': None
                                })
     in_algo = AlgoUtils.algo_factory('linear-regression')
     input_params_definition = in_algo.get_input_params_definition()
     # when: checkout input type
     check_result = in_algo.check_input_params(
         input_params_definition, algo_input.algo_control.control_params)
     # then: type match
     self.assertTrue(check_result is False)
Пример #2
0
def main():
    arg_dict = {"n_neighbors": 5, "weights": "uniform"}
    data = load_iris()
    iris_data = pd.DataFrame(data.data, columns=data.feature_names)
    iris_label = data.target

    algo_input = alc.AlgoParam(algo_control={
        'mode': 'training',
        'control_params': arg_dict
    },
                               algo_data={
                                   'data': iris_data,
                                   'label': iris_label
                               },
                               algo_model={
                                   'model_params': None,
                                   'model_instance': None
                               })
    in_algo = AlgoUtils.algo_factory('knn')
    algo_output = in_algo.do_algo(algo_input)
    model = algo_output.algo_model.model_instance
    predict_result = model.predict(iris_data)

    x_axis_name = data.feature_names[0]
    y_axis_name = data.feature_names[1]
    knn_model_preview(iris_data, predict_result, x_axis_name, y_axis_name)
Пример #3
0
    def test_correct_dl_nn_classifier_do_algo_mnist_dataset(self):
        # given: collect input parameter, create algorithm object
        arg_dict = {
            "layer_1_neuron": 32,
            "layer_1_activation": "relu",
            "layer_2_neuron": 16,
            "layer_2_activation": "tanh",
            "layer_3_neuron": 10,
            "layer_3_activation": "softmax",
            "optimizer": "RMSprop",
            "loss": "categorical_crossentropy",
            "epochs": 3,
            "batch_size": 32
        }
        algo_input = alc.AlgoParam(algo_control={
            'mode': 'training',
            'control_params': arg_dict
        },
                                   algo_data={
                                       'data': self.X_train,
                                       'label': self.y_train
                                   },
                                   algo_model={
                                       'model_params': None,
                                       'model_instance': None
                                   })
        in_algo = AlgoUtils.algo_factory('DL_NN_Classifier_r07525035')
        log.debug(algo_input)
        # when: do decision tree algorithm
        algo_output = in_algo.do_algo(algo_input)

        # then:
        self.assertTrue(algo_output is not None)
        self.assertTrue(algo_output.algo_model.model_instance is not None)
 def test_correct_linear_regression_parameter_type(self):
     # given: collect input parameter, create algorithm object
     arg_dict = {
         "fit_intercept": True,
         "normalize": False,
         "copy_X": True,
         "n_jobs": 1
     }
     algo_name = 'linear-regression'
     algo_input = alc.AlgoParam(algo_control={
         'mode': 'training',
         'control_params': arg_dict
     },
                                algo_data={
                                    'data': self.boston_data,
                                    'label': self.boston_label
                                },
                                algo_model={
                                    'model_params': None,
                                    'model_instance': None
                                })
     in_algo = AlgoUtils.algo_factory(algo_name)
     input_params_definition = in_algo.get_input_params_definition()
     # when: checkout input type
     check_result = in_algo.check_input_params(
         input_params_definition, algo_input.algo_control.control_params)
     # then: type match
     self.assertTrue(check_result is True)
     self.assertEqual(Algorithm.get_project_type(algo_name), "regression")
Пример #5
0
 def test_correct_knn_parameter_type(self):
     # given: collect input parameter, create algorithm object
     arg_dict = {"n_neighbors": 5, "weights": "uniform"}
     algo_name = 'knn'
     algo_input = alc.AlgoParam(algo_control={
         'mode': 'training',
         'control_params': arg_dict
     },
                                algo_data={
                                    'data': self.iris_data,
                                    'label': self.iris_label
                                },
                                algo_model={
                                    'model_params': None,
                                    'model_instance': None
                                })
     in_algo = AlgoUtils.algo_factory(algo_name)
     input_params_definition = in_algo.get_input_params_definition()
     # when: checkout input type
     check_result = in_algo.check_input_params(
         input_params_definition, algo_input.algo_control.control_params)
     # then: type match
     self.assertTrue(check_result is True)
     self.assertEqual(Algorithm.get_project_type(algo_name),
                      "classification")
 def test_correct_one_class_svm_parameter_gamma_float_type(self):
     # given: collect input parameter, create algorithm object
     arg_dict = {"gamma": 0.1, "nu": 0.5, "kernel": "rbf", "degree": 3}
     algo_name = 'one-class_SVM'
     algo_input = alc.AlgoParam(algo_control={
         'mode': 'training',
         'control_params': arg_dict
     },
                                algo_data={
                                    'data': self.iris_data,
                                    'label': None
                                },
                                algo_model={
                                    'model_params': None,
                                    'model_instance': None
                                })
     in_algo = AlgoUtils.algo_factory(algo_name)
     input_params_definition = in_algo.get_input_params_definition()
     # when: checkout input type
     check_result = in_algo.check_input_params(
         input_params_definition, algo_input.algo_control.control_params)
     # then: type match
     self.assertTrue(check_result is True)
     self.assertEqual(Algorithm.get_project_type(algo_name),
                      "abnormal-detection")
    def test_correct_linear_regression_do_algo(self):
        # given: collect input parameter, create algorithm object
        arg_dict = {
            "fit_intercept": True,
            "normalize": False,
            "copy_X": True,
            "n_jobs": 1
        }
        algo_input = alc.AlgoParam(algo_control={
            'mode': 'training',
            'control_params': arg_dict
        },
                                   algo_data={
                                       'data': self.boston_data,
                                       'label': self.boston_label
                                   },
                                   algo_model={
                                       'model_params': None,
                                       'model_instance': None
                                   })
        in_algo = AlgoUtils.algo_factory('linear-regression')
        log.debug(algo_input)
        # when: do decision tree algorithm
        algo_output = in_algo.do_algo(algo_input)

        # then:
        self.assertTrue(algo_output is not None)
        self.assertTrue(algo_output.algo_model.model_instance is not None)
Пример #8
0
 def test_error_dl_nn_classifier_parameter_neuron_1_string_type(self):
     # given: error input parameter "layer_1_neuron" needs to be type(int)
     arg_dict = {
         "layer_1_neuron": "relu",
         "layer_1_activation": "relu",
         "layer_2_neuron": 16,
         "layer_2_activation": "tanh",
         "layer_3_neuron": 10,
         "layer_3_activation": "softmax",
         "optimizer": "Adam",
         "loss": "mean_squared_error",
         "epochs": 2,
         "batch_size": 32,
     }
     algo_input = alc.AlgoParam(algo_control={
         'mode': 'training',
         'control_params': arg_dict
     },
                                algo_data={
                                    'data': self.boston_data,
                                    'label': self.boston_label
                                },
                                algo_model={
                                    'model_params': None,
                                    'model_instance': None
                                })
     in_algo = AlgoUtils.algo_factory('DL_NN_Classifier_r07525035')
     input_params_definition = in_algo.get_input_params_definition()
     # when: checkout input type
     check_result = in_algo.check_input_params(
         input_params_definition, algo_input.algo_control.control_params)
     # then: type match
     self.assertTrue(check_result is False)
    def test_error_decision_tree_parameter_type(self):
        # given: collect input parameter, create algorithm object
        arg_dict = {"max_depth": 10.0}
        algo_input = alc.AlgoParam(algo_control={
            'mode': 'training',
            'control_params': arg_dict
        },
                                   algo_data={
                                       'data': self.iris_data,
                                       'label': self.iris_label
                                   },
                                   algo_model={
                                       'model_params': None,
                                       'model_instance': None
                                   })
        in_algo = AlgoUtils.algo_factory('decision-tree')
        input_params_definition = in_algo.get_input_params_definition()
        # when: checkout input type
        check_result = in_algo.check_input_params(
            input_params_definition, algo_input.algo_control.control_params)
        # then: type match
        self.assertTrue(check_result is False)

        # given: collect input parameter, create algorithm object
        arg_dict = {"max_depth": 'a_string'}
        algo_input = alc.AlgoParam(algo_control={
            'mode': 'training',
            'control_params': arg_dict
        },
                                   algo_data={
                                       'data': self.iris_data,
                                       'label': self.iris_label
                                   },
                                   algo_model={
                                       'model_params': None,
                                       'model_instance': None
                                   })
        in_algo = AlgoUtils.algo_factory('decision-tree')
        input_params_definition = in_algo.get_input_params_definition()

        # when: checkout input type
        check_result = in_algo.check_input_params(
            input_params_definition, algo_input.algo_control.control_params)
        # then: type match
        self.assertTrue(check_result is False)
Пример #10
0
 def test_error_kmeans_parameter_n_init_string_type(self):
     # given: collect input parameter, create algorithm object
     arg_dict = {
         "n_clusters": 8,
         "n_init": "string",
         "max_iter": 300
     }
     algo_input = alc.AlgoParam(algo_control={'mode': 'training', 'control_params': arg_dict},
                                algo_data={'data': self.iris_data, 'label': None},
                                algo_model={'model_params': None, 'model_instance': None})
     in_algo = AlgoUtils.algo_factory('k-means')
     input_params_definition = in_algo.get_input_params_definition()
     # when: checkout input type
     check_result = in_algo.check_input_params(input_params_definition, algo_input.algo_control.control_params)
     # then: type match
     self.assertTrue(check_result is False)
Пример #11
0
 def test_error_ap_damping_out_of_range(self):
     # given: collect input parameter, create algorithm object
     arg_dict = {
         "damping": 1.5,
         "preference": "-50",
         "convergence_iter": 15,
         "max_iter": 200
     }
     algo_name = 'affinity_propagation'
     algo_input = alc.AlgoParam(algo_control={'mode': 'training', 'control_params': arg_dict},
                                algo_data={'data': self.iris_data, 'label': None},
                                algo_model={'model_params': None, 'model_instance': None})
     in_algo = AlgoUtils.algo_factory(algo_name)
     input_params_definition = in_algo.get_input_params_definition()
     # when: checkout input type
     check_result = in_algo.check_input_params(input_params_definition, algo_input.algo_control.control_params)
     # then: type match
     self.assertTrue(check_result is False)
def model_predict(arg_dict, data_train, label_train, data_test, label_test,
                  class_names, fname):
    algo_input = alc.AlgoParam(algo_control={
        'mode': 'training',
        'control_params': arg_dict
    },
                               algo_data={
                                   'data': data_train,
                                   'label': label_train
                               },
                               algo_model={
                                   'model_params': None,
                                   'model_instance': None
                               })
    in_algo = AlgoUtils.algo_factory('DL_NN_Classifier_r07525035')
    algo_output = in_algo.do_algo(algo_input)
    model = algo_output.algo_model.model_instance

    predict_result = model.predict(data_test)

    clsf_report = classification_report(label_test, predict_result)
    print("Classification report for classifier %s:\n%s\n" %
          (model, clsf_report))
    classification_report_csv(clsf_report, fname)

    # Compute confusion matrix
    cnf_matrix = confusion_matrix(label_test, predict_result)
    np.set_printoptions(precision=2, suppress=True)

    # Plot non-normalized confusion matrix
    plt.figure()
    plot_confusion_matrix(cnf_matrix,
                          classes=class_names,
                          fname=fname,
                          title='Confusion matrix, without normalization')

    # Plot normalized confusion matrix
    plt.figure()
    plot_confusion_matrix(cnf_matrix,
                          classes=class_names,
                          normalize=True,
                          fname=fname,
                          title='Normalized confusion matrix')
    plt.show()
Пример #13
0
    def test_correct_kmeans_do_algo(self):
        # given: collect input parameter, create algorithm object
        arg_dict = {
            "n_clusters": 8,
            "n_init": 10,
            "max_iter": 300
        }
        algo_input = alc.AlgoParam(algo_control={'mode': 'training', 'control_params': arg_dict},
                                   algo_data={'data': self.iris_data, 'label': None},
                                   algo_model={'model_params': None, 'model_instance': None})
        in_algo = AlgoUtils.algo_factory('k-means')
        log.debug(algo_input)

        # when: do decision tree algorithm
        algo_output = in_algo.do_algo(algo_input)

        # then:
        self.assertTrue(algo_output is not None)
        self.assertTrue(algo_output.algo_model.model_instance is not None)
Пример #14
0
    def test_correct_affinitypropagation_do_algo(self):
        # given: collect input parameter, create algorithm object
        arg_dict = {
            "damping": 0.5,
            "preference": "-50",
            "convergence_iter": 15,
            "max_iter": 200
        }
        algo_name = 'affinity_propagation'
        algo_input = alc.AlgoParam(algo_control={'mode': 'training', 'control_params': arg_dict},
                                   algo_data={'data': self.iris_data, 'label': None},
                                   algo_model={'model_params': None, 'model_instance': None})
        in_algo = AlgoUtils.algo_factory(algo_name)
        log.debug(algo_input)

        # when: do decision tree algorithm
        algo_output = in_algo.do_algo(algo_input)

        # then:
        self.assertTrue(algo_output is not None)
        self.assertTrue(algo_output.algo_model.model_instance is not None)
 def test_error_one_class_svm_parameter_gamma_string_type(self):
     # given: collect input parameter, create algorithm object
     arg_dict = {"gamma": "string", "nu": 0.5, "kernel": "rbf", "degree": 3}
     algo_input = alc.AlgoParam(algo_control={
         'mode': 'training',
         'control_params': arg_dict
     },
                                algo_data={
                                    'data': self.iris_data,
                                    'label': None
                                },
                                algo_model={
                                    'model_params': None,
                                    'model_instance': None
                                })
     in_algo = AlgoUtils.algo_factory('one-class_SVM')
     input_params_definition = in_algo.get_input_params_definition()
     # when: checkout input type
     check_result = in_algo.check_input_params(
         input_params_definition, algo_input.algo_control.control_params)
     # then: type match
     self.assertTrue(check_result is False)
Пример #16
0
 def test_error_knn_parameter_weights_int_type(self):
     # given: collect input parameter, create algorithm object
     arg_dict = {"n_neighbors": 5, "weights": 1}
     algo_input = alc.AlgoParam(algo_control={
         'mode': 'training',
         'control_params': arg_dict
     },
                                algo_data={
                                    'data': self.iris_data,
                                    'label': self.iris_label
                                },
                                algo_model={
                                    'model_params': None,
                                    'model_instance': None
                                })
     in_algo = AlgoUtils.algo_factory('knn')
     input_params_definition = in_algo.get_input_params_definition()
     # when: checkout input type
     check_result = in_algo.check_input_params(
         input_params_definition, algo_input.algo_control.control_params)
     # then: type match
     self.assertTrue(check_result is False)
Пример #17
0
    def test_error_dl_nn_classifier_do_algo_wrong_dataset(self):
        # given: error database input, create algorithm object
        arg_dict = {
            "layer_1_neuron": 32,
            "layer_1_activation": "relu",
            "layer_2_neuron": 16,
            "layer_2_activation": "relu",
            "layer_3_neuron": 10,
            "layer_3_activation": "relu",
            "optimizer": "Adam",
            "loss": "mean_squared_error",
            "epochs": 3,
            "batch_size": 32
        }
        algo_input = alc.AlgoParam(algo_control={
            'mode': 'training',
            'control_params': arg_dict
        },
                                   algo_data={
                                       'data': self.boston_data,
                                       'label': self.boston_label
                                   },
                                   algo_model={
                                       'model_params': None,
                                       'model_instance': None
                                   })
        in_algo = AlgoUtils.algo_factory('DL_NN_Classifier_r07525035')
        log.debug(algo_input)
        # when: do decision tree algorithm
        try:
            algo_output = in_algo.do_algo(algo_input)
        except:
            algo_output = None

        # then:
        self.assertTrue(algo_output is None)
    def test_correct_one_class_svm_do_algo(self):
        # given: collect input parameter, create algorithm object
        arg_dict = {"gamma": 0.5, "nu": 0.5, "kernel": "rbf", "degree": 3}
        algo_input = alc.AlgoParam(algo_control={
            'mode': 'training',
            'control_params': arg_dict
        },
                                   algo_data={
                                       'data': self.iris_data,
                                       'label': None
                                   },
                                   algo_model={
                                       'model_params': None,
                                       'model_instance': None
                                   })
        in_algo = AlgoUtils.algo_factory('one-class_SVM')
        log.debug(algo_input)

        # when: do decision tree algorithm
        algo_output = in_algo.do_algo(algo_input)

        # then:
        self.assertTrue(algo_output is not None)
        self.assertTrue(algo_output.algo_model.model_instance is not None)
Пример #19
0
    def test_correct_knn_do_algo(self):
        # given: collect input parameter, create algorithm object
        arg_dict = {"n_neighbors": 5, "weights": "uniform"}
        algo_input = alc.AlgoParam(algo_control={
            'mode': 'training',
            'control_params': arg_dict
        },
                                   algo_data={
                                       'data': self.iris_data,
                                       'label': self.iris_label
                                   },
                                   algo_model={
                                       'model_params': None,
                                       'model_instance': None
                                   })
        in_algo = AlgoUtils.algo_factory('knn')
        log.debug(algo_input)

        # when: do decision tree algorithm
        algo_output = in_algo.do_algo(algo_input)

        # then:
        self.assertTrue(algo_output is not None)
        self.assertTrue(algo_output.algo_model.model_instance is not None)
Пример #20
0
 def test_correct_dl_nn_classifier_parameter_type(self):
     # given: collect input parameter, create algorithm object
     arg_dict = {
         "layer_1_neuron": 32,
         "layer_1_activation": "relu",
         "layer_2_neuron": 16,
         "layer_2_activation": "tanh",
         "layer_3_neuron": 10,
         "layer_3_activation": "softmax",
         "optimizer": "RMSprop",
         "loss": "categorical_crossentropy",
         "epochs": 3,
         "batch_size": 32
     }
     algo_name = 'DL_NN_Classifier_r07525035'
     algo_input = alc.AlgoParam(algo_control={
         'mode': 'training',
         'control_params': arg_dict
     },
                                algo_data={
                                    'data': self.X_train,
                                    'label': self.y_train
                                },
                                algo_model={
                                    'model_params': None,
                                    'model_instance': None
                                })
     in_algo = AlgoUtils.algo_factory(algo_name)
     input_params_definition = in_algo.get_input_params_definition()
     # when: checkout input type
     check_result = in_algo.check_input_params(
         input_params_definition, algo_input.algo_control.control_params)
     # then: type match
     self.assertTrue(check_result is True)
     self.assertEqual(Algorithm.get_project_type(algo_name),
                      "classification")
    def test_error_decision_tree_do_algo(self):
        # given: collect input parameter, create algorithm object
        arg_dict = {"max_depth": 10}
        # wrong data input
        algo_input = alc.AlgoParam(algo_control={
            'mode': 'training',
            'control_params': arg_dict
        },
                                   algo_data={
                                       'data': self.boston_data,
                                       'label': self.boston_label
                                   },
                                   algo_model={
                                       'model_params': None,
                                       'model_instance': None
                                   })
        in_algo = AlgoUtils.algo_factory('decision-tree')
        log.debug(algo_input)

        # when: do decision tree algorithm
        algo_output = in_algo.do_algo(algo_input)

        # then:
        self.assertTrue(algo_output is None)