def test_k_nearest_neighbor(self):
     self.assertTrue(expr=isinstance(Classification().k_nearest_neighbor(),
                                     KNeighborsClassifier))
 def test_gradient_boosting_tree(self):
     self.assertTrue(
         expr=isinstance(Classification().gradient_boosting_tree(),
                         GradientBoostingClassifier))
 def test_gradient_boosting_tree_param(self):
     _gbo_param: dict = Classification().gradient_boosting_tree_param()
     self.assertTrue(
         expr=_gbo_param.get(list(_gbo_param.keys())[0]) != Classification(
         ).gradient_boosting_tree_param().get(list(_gbo_param.keys())[0]))
 def test_cat_boost_param(self):
     _cat_boost_param: dict = Classification().cat_boost_param()
     self.assertTrue(expr=_cat_boost_param.get(
         list(_cat_boost_param.keys())[0]) != Classification(
         ).cat_boost_param().get(list(_cat_boost_param.keys())[0]))
 def test_extreme_gradient_boosting_tree(self):
     self.assertTrue(expr=isinstance(
         Classification().extreme_gradient_boosting_tree(), XGBClassifier))
 def test_linear_discriminant_analysis_param(self):
     _lda_param: dict = Classification().linear_discriminant_analysis_param(
     )
     self.assertTrue(expr=_lda_param.get(list(_lda_param.keys(
     ))[0]) != Classification().linear_discriminant_analysis_param().get(
         list(_lda_param.keys())[0]))
 def test_quadratic_discriminant_analysis(self):
     self.assertTrue(
         expr=isinstance(Classification().quadratic_discriminant_analysis(),
                         QuadraticDiscriminantAnalysis))
 def test_nu_support_vector_machine_param(self):
     _nusvm_param: dict = Classification().nu_support_vector_machine_param()
     self.assertTrue(expr=_nusvm_param.get(list(_nusvm_param.keys())[0]) !=
                     Classification().nu_support_vector_machine_param().get(
                         list(_nusvm_param.keys())[0]))
 def test_ada_boosting(self):
     self.assertTrue(expr=isinstance(Classification().ada_boosting(),
                                     AdaBoostClassifier))
 def test_linear_support_vector_machine(self):
     self.assertTrue(expr=isinstance(
         Classification().linear_support_vector_machine(), LinearSVC))
 def test_nu_support_vector_machine(self):
     self.assertTrue(expr=isinstance(
         Classification().nu_support_vector_machine(), NuSVC))
 def test_random_forest_param(self):
     _rf_param: dict = Classification().random_forest_param()
     self.assertTrue(
         expr=_rf_param.get(list(_rf_param.keys())[0]) != Classification(
         ).random_forest_param().get(list(_rf_param.keys())[0]))
 def test_random_forest(self):
     self.assertTrue(expr=isinstance(Classification().random_forest(),
                                     RandomForestClassifier))
 def test_quadratic_discriminant_analysis_param(self):
     _qda_param: dict = Classification(
     ).quadratic_discriminant_analysis_param()
     self.assertTrue(expr=_qda_param.get(list(_qda_param.keys(
     ))[0]) != Classification().quadratic_discriminant_analysis_param().get(
         list(_qda_param.keys())[0]))
 def test_k_nearest_neighbor_param(self):
     _knn_param: dict = Classification().k_nearest_neighbor_param()
     self.assertTrue(
         expr=_knn_param.get(list(_knn_param.keys())[0]) != Classification(
         ).k_nearest_neighbor_param().get(list(_knn_param.keys())[0]))
 def test_ada_boosting_param(self):
     _ada_boost_param: dict = Classification().ada_boosting_param()
     self.assertTrue(expr=_ada_boost_param.get(
         list(_ada_boost_param.keys())[0]) != Classification(
         ).ada_boosting_param().get(list(_ada_boost_param.keys())[0]))
 def test_linear_discriminant_analysis(self):
     self.assertTrue(
         expr=isinstance(Classification().linear_discriminant_analysis(),
                         LinearDiscriminantAnalysis))
 def test_cat_boost(self):
     self.assertTrue(
         expr=isinstance(Classification().cat_boost(), CatBoostClassifier))
 def test_logistic_regression(self):
     self.assertTrue(expr=isinstance(Classification().logistic_regression(),
                                     LogisticRegression))
 def test_logistic_regression_param(self):
     _logistic_param: dict = Classification().logistic_regression_param()
     self.assertTrue(expr=_logistic_param.get(
         list(_logistic_param.keys())[0]) != Classification(
         ).logistic_regression_param().get(list(_logistic_param.keys())[0]))