Help on class AbuML in module abupy.MLBu.ABuML:
class AbuML(builtins.object)
| AbuML(x, y, df, fiter_type=<EMLFitType.E_FIT_AUTO: 'auto'>)
|
| 封装有简单学习及无监督学习方法以及相关操作类
|
| Methods defined here:
|
| __init__(self, x, y, df, fiter_type=<EMLFitType.E_FIT_AUTO: 'auto'>)
| AbuML属于中间层需要所有原料都配齐,x, y, df,构造方式参考
| create_test_fiter方法中的实行流程
|
| :param x: 训练集x矩阵,numpy矩阵
| :param y: 训练集y序列,numpy序列
| :param df: 拆分x,y使用的pd.DataFrame对象
| :param fiter_type: 使用的学习器类型,默认使用E_FIT_AUTO即根据y的label数量选择分类或者回归
|
| adaboost_classifier_best(self, **kwargs)
| eg:
| adaboost_classifier_best有param_grid参数调用:
|
| param_grid = {'learning_rate': np.arange(0.2, 1.2, 0.2), 'n_estimators': np.arange(10, 100, 10)}
| ttn_abu.adaboost_classifier_best(param_grid=param_grid, n_jobs=-1)
|
| out: AdaBoostClassifier(learning_rate=0.6, n_estimators=70)
|
| adaboost_classifier_best无param_grid参数调用:
|
| from abupy import AbuML, ml
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.adaboost_classifier_best()
| |
| :param kwargs: 关键字可选参数param_grid: 最优字典关键字参数
| eg:param_grid = {'learning_rate': np.arange(0.2, 1.2, 0.2),
| 'n_estimators': np.arange(10, 100, 10)}
| 关键字可选参数assign: 是否保存实例化后最优参数的学习器对象,默认True
| 关键字可选参数n_jobs: 并行执行的进程任务数量,默认-1, 开启与cpu相同数量的进程数
| 关键字可选参数show: 是否可视化最优参数搜索结果
| :return: 通过最优参数构造的AdaBoostClassifier对象
|
| adaboost_regressor_best(self, **kwargs)
| eg:
| adaboost_regressor_best有param_grid参数调用:
|
| param_grid = {'learning_rate': np.arange(0.2, 1.2, 0.2), 'n_estimators': np.arange(10, 100, 10)}
| ttn_abu.adaboost_regressor_best(param_grid=param_grid, n_jobs=-1)
|
| out: AdaBoostRegressor(learning_rate=0.8, n_estimators=40)
|
| adaboost_regressor_best无param_grid参数调用:
|
| from abupy import AbuML, ml
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.adaboost_regressor_best()
|
| :param kwargs: 关键字可选参数param_grid: 最优字典关键字参数
| eg:param_grid = {'learning_rate': np.arange(0.2, 1.2, 0.2),
| 'n_estimators': np.arange(10, 100, 10)}
| 关键字可选参数assign: 是否保存实例化后最优参数的学习器对象,默认True
| 关键字可选参数n_jobs: 并行执行的进程任务数量,默认-1, 开启与cpu相同数量的进程数
| 关键字可选参数show: 是否可视化最优参数搜索结果
| :return: 通过最优参数构造的AdaBoostRegressor对象
|
| bagging_classifier_best(self, **kwargs)
| eg:
| bagging_classifier_best有param_grid参数调用:
|
| param_grid = {'max_samples': np.arange(1, 5), 'n_estimators': np.arange(100, 300, 50)}
| ttn_abu.bagging_classifier_best(param_grid=param_grid, n_jobs=-1)
|
| out: BaggingClassifier(max_samples=4, n_estimators=100)
|
| bagging_classifier_best无param_grid参数调用:
|
| from abupy import AbuML, ml
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.bagging_classifier_best()
|
| :param kwargs: 关键字可选参数param_grid: 最优字典关键字参数
| eg:param_grid = {'max_samples': np.arange(1, 5), 'n_estimators': np.arange(100, 300, 50)}
| 关键字可选参数assign: 是否保存实例化后最优参数的学习器对象,默认True
| 关键字可选参数n_jobs: 并行执行的进程任务数量,默认-1, 开启与cpu相同数量的进程数
| 关键字可选参数show: 是否可视化最优参数搜索结果
| :return: 通过最优参数构造的BaggingClassifier对象
|
| bagging_regressor_best(self, **kwargs)
| eg:
| bagging_regressor_best有param_grid参数调用:
|
| param_grid = {'max_samples': np.arange(1, 5), 'n_estimators': np.arange(100, 300, 50)}
| ttn_abu.bagging_regressor_best(param_grid=param_grid, n_jobs=-1)
|
| out: BaggingRegressor(max_samples=4, n_estimators=250)
|
| bagging_regressor_best无param_grid参数调用:
|
| from abupy import AbuML, ml
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.bagging_regressor_best()
|
| :param kwargs: 关键字可选参数param_grid: 最优字典关键字参数
| eg:param_grid = {'max_samples': np.arange(1, 5), 'n_estimators': np.arange(100, 300, 50)}
| 关键字可选参数assign: 是否保存实例化后最优参数的学习器对象,默认True
| 关键字可选参数n_jobs: 并行执行的进程任务数量,默认-1, 开启与cpu相同数量的进程数
| 关键字可选参数show: 是否可视化最优参数搜索结果
| :return: 通过最优参数构造的BaggingRegressor对象
|
| cross_val_accuracy_score(self, cv=10, **kwargs)
| 被装饰器entry_wrapper(support=(EMLFitType.E_FIT_CLF,))装饰,
| 即只支持有监督学习分类,使用cross_val_score对数据进行accuracy度量
| :param cv: 透传cross_val_score的参数,默认10
| :param kwargs: 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 确定传递self._do_cross_val_score中参数x,y,
| 装饰器使用的fiter_type,eg:ttn_abu.cross_val_accuracy_score(fiter_type=ml.EMLFitType.E_FIT_CLF)
| :return: cross_val_score返回的score序列,
| eg: array([ 1. , 0.9 , 1. , 0.9 , 1. , 0.9 , 1. , 0.9 , 0.95, 1. ])
|
| cross_val_mean_squared_score(self, cv=10, **kwargs)
| 被装饰器entry_wrapper(support=(EMLFitType.E_FIT_CLF, EMLFitType.E_FIT_REG))装饰,
| 即支持有监督学习回归和分类,使用cross_val_score对数据进行rmse度量
| :param cv: 透传cross_val_score的参数,默认10
| :param kwargs: 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 确定传递self._do_cross_val_score中参数x,y,
| 以及装饰器使用的fiter_type,eg:ttn_abu.cross_val_roc_auc_score(fiter_type=ml.EMLFitType.E_FIT_CLF)
| :return: cross_val_score返回的score序列,
| eg: array([-0.1889, -0.1667, -0.2135, -0.1348, -0.1573, -0.2022, -0.1798,
| -0.2022, -0.1348, -0.1705])
|
| cross_val_prob_accuracy_score(self, pb_threshold, cv=10, show=True, **kwargs)
| 被装饰器entry_wrapper(support=(EMLFitType.E_FIT_CLF,))装饰,
| 即只支持有监督学习分类,拆分训练集,测试集,对所有数据进行一次predict_proba
| 获取分类的概率(具体阅读ABuMLExecute.run_prob_cv_estimator),之后根据
| pb_threshold的值对结果概率进行二值转换,pb_threshold的均衡对影响数据的度量
| 准确度等
| eg:
| in: ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.estimator.svc(probability=True)
| ttn_abu.cross_val_prob_accuracy_score(pb_threshold=0.60)
| out:
| threshold=0.6 prob accuracy=0.83, effect cnt=870, effect rate=0.98, score=0.81
| 阀值0.6,准确率0.83,生效比例0.98,分数0.81
|
| in:
| ttn_abu.cross_val_prob_accuracy_score(pb_threshold=0.80)
| out:
| threshold=0.8 prob accuracy=0.87, effect cnt=718, effect rate=0.81, score=0.70
| 阀值0.8,准确率0.87 提高,生效比例0.81 降低,分数0.70 降低
|
| in:
| ttn_abu.cross_val_prob_accuracy_score(pb_threshold=0.85)
| out:
| threshold=0.85 prob accuracy=0.89, effect cnt=337, effect rate=0.38, score=0.34
| 阀值0.85,准确率0.89 再次提高,生效比例0.38 很低,分数0.34 降低
|
| 即通过训练集数据寻找合适的prob值对数据的predict_prob进行非均衡处理,必然对交易的拦截进行非均衡
| 处理,只对有很大概率的的交易进行拦截
|
| :param pb_threshold: binarize(y_prob, threshold=pb_threshold)中使用的二分阀值,float(0-1)
| :param cv: 透传ABuMLExecute.run_prob_cv_estimator中的cv参数,默认10,int
| :param show: 是否显示输出结果信息,默认显示
| :param kwargs: 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 确定传递self._do_cross_val_score中参数x,y
| 装饰器使用的fiter_type
| :return: accuracy, effect_cnt, effect_rate, score
|
| cross_val_roc_auc_score(self, cv=10, **kwargs)
| 被装饰器entry_wrapper(support=(EMLFitType.E_FIT_CLF,))装饰,
| 即支持有监督学习分类,使用cross_val_score对数据进行roc_auc度量,如果数据的y的
| label标签 > 2,通过label_binarize将label标签进行二值化处理,
| 依次计算二值化的列的roc_auc,结果返回score最好的数据度量
| :param cv: 透传cross_val_score的参数,默认10
| :param kwargs: 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 确定传递self._do_cross_val_score中参数x,y,
| 以及装饰器使用的fiter_type,eg:ttn_abu.cross_val_roc_auc_score(fiter_type=ml.EMLFitType.E_FIT_REG)
| :return: cross_val_score返回的score序列,
| eg: array([ 1. , 0.9 , 1. , 0.9 , 1. , 0.9 , 1. , 0.9 , 0.95, 1. ])
|
| cross_val_silhouette_score(self, cv=10, **kwargs)
| 被装饰器entry_wrapper(support=(EMLFitType.E_FIT_KMEAN, ))装饰,即
| 只支持无监督学习kmean的cv验证,使用silhouette_score对聚类后的结果labels_
| 进行度量使用silhouette_score
| :param cv: 透传run_silhouette_cv_estimator的参数,默认10
| :param kwargs: 外部可以传递x 通过
| x = kwargs.pop('x', self.x)
| 确定传递ABuMLExecute.run_silhouette_cv_estimator中参数x
| 装饰器使用的fiter_type,
| eg:ttn_abu.cross_val_silhouette_score(fiter_type=ml.EMLFitType.E_FIT_KMEAN)
| :return: run_silhouette_cv_estimator返回的score序列,
| eg: array([ 0.6322, 0.6935, 0.7187, 0.6887, 0.6699, 0.703 , 0.6922,
| 0.7049, 0.6462, 0.6755])
|
| decision_tree_classifier_best(self, **kwargs)
| eg:
| decision_tree_classifier_best无param_grid参数调用:
|
| from abupy import AbuML, ml
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.decision_tree_classifier_best()
|
| decision_tree_classifier_best有param_grid参数调用:
|
| param_grid = {'max_features': ['sqrt', 'log2', ], 'max_depth': np.arange(1, 10, 1)}
| ttn_abu.decision_tree_classifier_best(param_grid=param_grid, n_jobs=-1)
|
| out: DecisionTreeClassifier(max_features='sqrt', max_depth=7)
|
| :param kwargs: 关键字可选参数param_grid: 最优字典关键字参数
| eg:param_grid = {'max_features': ['sqrt', 'log2', ],
| 'max_depth': np.arange(1, 10, 1)}
| 关键字可选参数assign: 是否保存实例化后最优参数的学习器对象,默认True
| 关键字可选参数n_jobs: 并行执行的进程任务数量,默认-1, 开启与cpu相同数量的进程数
| 关键字可选参数show: 是否可视化最优参数搜索结果
| :return: 通过最优参数构造的DecisionTreeClassifier对象
|
| decision_tree_regressor_best(self, **kwargs)
| eg:
| decision_tree_regressor_best无param_grid参数调用:
|
| from abupy import AbuML, ml
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.decision_tree_regressor_best()
|
| decision_tree_regressor_best有param_grid参数调用:
|
| param_grid = {'max_features': ['sqrt', 'log2', ], 'max_depth': np.arange(1, 10, 1)}
| ttn_abu.decision_tree_regressor_best(param_grid=param_grid, n_jobs=-1)
|
| out: DecisionTreeRegressor(max_features='sqrt', max_depth=3)
|
| :param kwargs: 关键字可选参数param_grid: 最优字典关键字参数
| eg:param_grid = {'max_features': ['sqrt', 'log2', ],
| 'max_depth': np.arange(1, 10, 1)}
| 关键字可选参数assign: 是否保存实例化后最优参数的学习器对象,默认True
| 关键字可选参数n_jobs: 并行执行的进程任务数量,默认-1, 开启与cpu相同数量的进程数
| 关键字可选参数show: 是否可视化最优参数搜索结果
| :return: 通过最优参数构造的DecisionTreeRegressor对象
|
| echo_info(self, fiter=None)
| 显示fiter class信息,self.df信息包括,head,tail,describe
| eg:
| fiter class is: DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,
| max_features=None, max_leaf_nodes=None,
| min_impurity_split=1e-07, min_samples_leaf=1,
| min_samples_split=2, min_weight_fraction_leaf=0.0,
| presort=False, random_state=None, splitter='best')
| describe:
| y x0 x1 x2 x3
| count 150.0000 150.0000 150.0000 150.0000 150.0000
| mean 1.0000 5.8433 3.0540 3.7587 1.1987
| std 0.8192 0.8281 0.4336 1.7644 0.7632
| min 0.0000 4.3000 2.0000 1.0000 0.1000
| 25% 0.0000 5.1000 2.8000 1.6000 0.3000
| 50% 1.0000 5.8000 3.0000 4.3500 1.3000
| 75% 2.0000 6.4000 3.3000 5.1000 1.8000
| max 2.0000 7.9000 4.4000 6.9000 2.5000
| :param fiter:
| :return:
|
| feature_selection(self, show=True, **kwargs)
| 被装饰器entry_wrapper()装饰,默认参数即支持有监督和无监督学习
| 监督学习通过sklern中的RFE包装拟合器进行fit(x, y),对数据的特征进行ranking和support评定
|
| eg:
| RFE selection
| ranking support
| SibSp 1 True
| Parch 1 True
| Cabin_No 1 True
| Cabin_Yes 7 False
| Embarked_C 2 False
| Embarked_Q 3 False
| Embarked_S 5 False
| Sex_female 8 False
| Sex_male 1 True
| Pclass_1 4 False
| Pclass_2 6 False
| Pclass_3 1 True
| Age_scaled 1 True
| Fare_scaled 1 True
|
| 无监督学习通过sklern中的VarianceThreshold进行fit(x),根据x的方差进行特征评定
| eg:
| unsupervised VarianceThreshold
| support
| SibSp True
| Parch True
| Cabin_No True
| Cabin_Yes True
| Embarked_C True
| Embarked_Q True
| Embarked_S True
| Sex_female True
| Sex_male True
| Pclass_1 True
| Pclass_2 True
| Pclass_3 True
| Age_scaled True
| Fare_scaled True
|
| :param show: 是否在内部输出打印结果
| :param kwargs: 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 确定传递self._do_cross_val_score中参数x,y,
| 以及装饰器使用的fiter_type,eg:ttn_abu.feature_selection(fiter_type=ml.EMLFitType.E_FIT_REG)
|
| fit(self, **kwargs)
| 包装fit操作,根据是否是有监督学习来区别
| 使用fit(x, y)还是fit(x)
|
| eg:
| in: iris_abu.estimator.random_forest_classifier()
| iris_abu.fit()
| out:
| RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
| max_depth=None, max_features='auto', max_leaf_nodes=None,
| min_impurity_split=1e-07, min_samples_leaf=1,
| min_samples_split=2, min_weight_fraction_leaf=0.0,
| n_estimators=100, n_jobs=1, oob_score=False, random_state=None,
| verbose=0, warm_start=False)
| :param kwargs:
| :return: fit(x, y)或者fit(x)操作后返回
|
| fit_transform(self, **kwargs)
| 被装饰器@entry_wrapper()装饰,默认参数即支持有监督和无监督学习,
| 内部通过检测isinstance(fiter, TransformerMixin) or hasattr(fiter, 'fit_transform')
| 来判定是否可以fit_transform
|
| eg:
| input: ttn_abu.x.shape
| output: (891, 14)
|
| input: ttn_abu.fit_transform(fiter_type=ml.EMLFitType.E_FIT_PCA).shape
| output: (891, 4)
|
| input: ttn_abu.fit_transform(fiter_type=ml.EMLFitType.E_FIT_KMEAN).shape
| output: (891, 2)
|
| :param kwargs: 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 以及装饰器使用的fiter_type,eg:ttn_abu.fit_transform(fiter_type=ml.EMLFitType.E_FIT_CLF)
| :return: fit_transform后的转换结果矩阵
|
| get_fiter(self)
| 根据self.fiter_type的类型选择从self.estimator返回学习器对象
|
| self.fiter_type == EMLFitType.E_FIT_AUTO:
| 自动选择有简单学习,当y的label数量 < 10个使用分类self.estimator.clf,否则回归self.estimator.reg
| self.fiter_type == EMLFitType.E_FIT_REG:
| 使用有监督学习回归self.estimator.reg
| self.fiter_type == EMLFitType.E_FIT_CLF:
| 使用有监督学习分类self.estimator.clf
| self.fiter_type == EMLFitType.E_FIT_HMM:
| 使用无监督学习hmm,self.estimator.hmm
| self.fiter_type == EMLFitType.E_FIT_PCA:
| 使用无监督学习pca,self.estimator.pca
| self.fiter_type == EMLFitType.E_FIT_KMEAN:
| 使用无监督学习kmean,self.estimator.kmean
| :return: 返回学习器对象
|
| importances_coef_pd(self, **kwargs)
| 被装饰器entry_wrapper(support=(EMLFitType.E_FIT_CLF, EMLFitType.E_FIT_REG))装饰,
| 即支持有监督学习回归和分类,根据fit后的feature_importances_或者coef_和原始self.df.columns
| 组成pd.DataFrame对象返回
| eg:
| feature importance
| 7 Sex_female 0.0000
| 10 Pclass_2 0.0018
| 3 Cabin_Yes 0.0033
| 5 Embarked_Q 0.0045
| 9 Pclass_1 0.0048
| 4 Embarked_C 0.0098
| 6 Embarked_S 0.0105
| 1 Parch 0.0154
| 2 Cabin_No 0.0396
| 0 SibSp 0.0506
| 11 Pclass_3 0.0790
| 13 Fare_scaled 0.1877
| 12 Age_scaled 0.2870
| 8 Sex_male 0.3060
|
| coef columns
| 0 [-0.344229036121] SibSp
| 1 [-0.1049314305] Parch
| 2 [0.0] Cabin_No
| 3 [0.902140498996] Cabin_Yes
| 4 [0.0] Embarked_C
| 5 [0.0] Embarked_Q
| 6 [-0.417254399259] Embarked_S
| 7 [1.95656682017] Sex_female
| 8 [-0.677432099492] Sex_male
| 9 [0.3411515052] Pclass_1
| 10 [0.0] Pclass_2
| 11 [-1.19413332987] Pclass_3
| 12 [-0.523782082975] Age_scaled
| 13 [0.0844326510536] Fare_scaled
| :param kwargs: 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 以及装饰器使用的fiter_type,eg:ttn_abu.importances_coef_pd(fiter_type=ml.EMLFitType.E_FIT_REG)
| :return: pd.DataFrame对象
|
| is_supervised_learning(self)
| 返回self.fiter_type所使用的是有监督学习还是无监督学习
| :return: bool,True: 有监督,False: 无监督
|
| knn_classifier_best(self, **kwargs)
| eg:
| knn_classifier_best有param_grid参数调用:
|
| param_grid = {'algorithm': ['ball_tree', 'kd_tree', 'brute'], 'n_neighbors': np.arange(1, 26, 1)}
| ttn_abu.knn_classifier_best(param_grid=param_grid, n_jobs=-1)
|
| out: KNeighborsClassifier(algorithm='ball_tree', n_neighbors=14)
|
| knn_classifier_best无param_grid参数调用:
|
| from abupy import AbuML, ml
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.knn_classifier_best()
|
| :param kwargs: 关键字可选参数param_grid: 最优字典关键字参数
| eg:param_grid = {'algorithm': ['ball_tree', 'kd_tree', 'brute'],
| 'n_neighbors': np.arange(1, 26, 1)}
| 关键字可选参数assign: 是否保存实例化后最优参数的学习器对象,默认True
| 关键字可选参数n_jobs: 并行执行的进程任务数量,默认-1, 开启与cpu相同数量的进程数
| 关键字可选参数show: 是否可视化最优参数搜索结果
| :return: 通过最优参数构造的KNeighborsClassifier对象
|
| plot_confusion_matrices(self, **kwargs)
| 被entry_wrapper(support=(EMLFitType.E_FIT_CLF, ))装饰,即只支持分类
| 套接plot_confusion_matrices进行训练集测试集拆封分混淆矩阵计算且可视化
| 混淆矩阵
|
| :param 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 装饰器使用的fiter_type,
| eg:
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.plot_confusion_matrices(fiter_type=ml.EMLFitType.E_FIT_CLF)
|
| plot_decision_function(self, use_pca=True, **kwargs)
| 被装饰器entry_wrapper(support=(EMLFitType.E_FIT_CLF, EMLFitType.E_FIT_REG))装饰,
| 即支持有监督学习回归和分类
| :param use_pca: 是否使用pca进行降维,bool,默认True
| :param kwargs: 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 装饰器使用的fiter_type,
| eg:
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.plot_decision_function(fiter_type=ml.EMLFitType.E_FIT_CLF)
|
| plot_graphviz_tree(self, **kwargs)
| 被装饰器entry_wrapper(support=(EMLFitType.E_FIT_CLF, EMLFitType.E_FIT_REG))装饰,
| 即支持有监督学习回归和分类,绘制决策树或者core基于树的分类回归算法的决策示意图绘制,查看
| 学习器本身hasattr(fiter, 'tree_')是否有tree_属性,如果没有使用决策树替换
|
| :param kwargs: 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 装饰器使用的fiter_type,
| eg:
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.plot_graphviz_tree(fiter_type=ml.EMLFitType.E_FIT_CLF)
|
| plot_learning_curve(self, **kwargs)
| 被装饰器entry_wrapper(support=(EMLFitType.E_FIT_CLF, EMLFitType.E_FIT_REG))装饰,
| 即支持有监督学习回归和分类,绘制训练集数据的学习曲线,当训练集的y标签label非2分问题,
| 使用OneVsOneClassifier进行包装
| :param kwargs:
| 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 装饰器使用的fiter_type,
| eg:
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.plot_learning_curve(fiter_type=ml.EMLFitType.E_FIT_CLF)
|
| plot_roc_estimator(self, pos_label=None, **kwargs)
| 被entry_wrapper(support=(EMLFitType.E_FIT_CLF, ))装饰,即只支持分类
| 计算fpr, tpr, thresholds,最后绘制roc_auc曲线进行可视化操作
|
| :param pos_label:
| :param kwargs: 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 装饰器使用的fiter_type,
| eg:
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.plot_roc_estimator(fiter_type=ml.EMLFitType.E_FIT_CLF)
|
| plot_visualize_tree(self, use_pca=True, **kwargs)
| 被装饰器entry_wrapper(support=(EMLFitType.E_FIT_CLF, EMLFitType.E_FIT_REG))装饰,
| 即支持有监督学习回归和分类, 绘制特征平面,由于特征平面需要x的维度只能是2维,所以对
| x的特征列多于两个的进行降维操作,默认使用pca,还可以选择根据特征的重要, 程度选择两个importances
| 最重要的特征进行特征平面绘制
|
| :param use_pca: 是否使用pca进行降维,bool,默认True
| :param kwargs: 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 装饰器使用的fiter_type,
| eg:
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.plot_visualize_tree(fiter_type=ml.EMLFitType.E_FIT_CLF)
|
| predict(self, x, pre_fit=True, **kwargs)
| call有监督和无监督学习的predict,套接self._predict_callback方法,其
| 被装饰器params_to_numpy装饰,将predict参数中所有可迭代序列变成numpy,
| 即统一将x转换numpy序列,
| eg:
| test_input = pd.DataFrame.from_dict({'x0': 6.8, 'x1': 3.5, 'x2': 5.4, 'x3': 2.2}, orient='index')
| test_input:
| 0
| x0 6.8
| x1 3.5
| x2 5.4
| x3 2.2
|
| iris_abu.predict(test_input)
|
| params_to_numpy装饰后参数中的x转换为:array([[ 6.8, 3.5, 5.4, 2.2]]) numpy array
|
| 被装饰器entry_wrapper()装饰,默认参数即支持有监督和无监督学习
| :param x: 可迭代序列,通过params_to_numpy装饰统一转换numpy
| :param pre_fit: bool,默认pre_fit True, 代表每次predict前先fit,
| 如在乎效率的情况下,需要在外部先fit后,参数pre_fit置False
| :param kwargs: 装饰器使用的fiter_type,eg:ttn_abu.predict(test_input, fiter_type=ml.EMLFitType.E_FIT_KMEAN)
| :return: eg: array([2])
|
| predict_proba(self, x, pre_fit=True, **kwargs)
| call有监督和无监督学习的predict_proba,套接self._predict_callback方法,其
| 被装饰器params_to_numpy装饰,将predict参数中所有可迭代序列变成numpy,
| 即统一将x转换numpy序列,
| eg:
| test_input = pd.DataFrame.from_dict({'x0': 6.8, 'x1': 3.5, 'x2': 5.4, 'x3': 2.2}, orient='index')
| test_input:
| 0
| x0 6.8
| x1 3.5
| x2 5.4
| x3 2.2
|
| iris_abu.predict_proba(test_input, fiter_type=ml.EMLFitType.E_FIT_CLF)
|
| params_to_numpy装饰后参数中的x转换为:array([[ 6.8, 3.5, 5.4, 2.2]]) numpy array
|
| 被装饰器entry_wrapper()装饰,默认参数即支持有监督和无监督学习
| :param x: 通过params_to_numpy装饰统一转换numpy
| :param pre_fit: bool,默认pre_fit True, 代表每次predict前先fit,
| 如在乎效率的情况下,需要在外部先fit后,参数pre_fit置False
| :param kwargs: 装饰器使用的fiter_type,eg:iris_abu.predict_proba(test_input, fiter_type=ml.EMLFitType.E_FIT_CLF)
| :return: eg: array([[ 0.2, 0.3, 0.5]])
|
| predict_proba_threshold(self, x, threshold, default_ret, pre_fit=True, **kwargs)
| eg:
| in: ttn_abu = AbuML.create_test_more_fiter()
| in: ttn_abu.estimator.svc(probability=True)
| in: ttn_abu.search_match_pos_threshold(0.85, 0.80, fiter_type=ml.EMLFitType.E_FIT_CLF)
| out: 0.770 satisfy require, accuracy:0.850, effect_rate:0.854
|
| 即通过search_match_pos_threshold获取了predict_proba的二分阀值为0.77时,分类的正确率达到0.85, 且覆盖80%样本
|
| in: test = np.array([ 1. , 0. , 0. , 1. , 1. , 0. , 0. ,1. , 0. , 1.
| , 0. , 0. , 0.8132, 0.5868])
| in: ttn_abu.predict_proba(test)
| out: array([[ 0.106, 0.894]])
| 使用predict_proba得到的是分类的概率
|
| in: ttn_abu.predict_proba_threshold(test, threshold=0.77 ,default_ret=0)
| out: 1
| 使用predict_proba_threshold将阀值threshold设定0.77后,可以得到输出为1,即概率 0.894 > 0.77, 标签1分类成立
|
| in: test2 = np.array([ 0. , 1. , 1. , 0. , 1. , 1. , 0. ,1. , 0. , 0.
| , 0. , 1. , 0.7832, 0.2868])
| in: ttn_abu.predict_proba(test2)
| out: array([[ 0.2372, 0.7628]])
|
| in: ttn_abu.predict_proba_threshold(test2, threshold=0.77 ,default_ret=0)
| out: 0
| 对test2做predict_proba_threshold返回0,因为0.7628 < 0.77, 标签1的分类不成立,返回default_ret
|
| 应用场景:比如对交易进行拦截,实行高放行率,低拦截率,0代表放行,1代表拦截,
| 上述predict_proba_threshold(test2, threshold=0.77 ,default_ret=0)
| 即可实行对较大概率的交易进行拦截,即把握大的进行拦截,把握不大的默认选择放行
| :param x: 在predict_proba中通过params_to_numpy装饰统一转换numpy
| :param threshold: 对predict_proba结果进行二值化的阀值 eg: threshold=0.77
| :param default_ret: 使用predict_proba返回的矢量和不等于1时,即没有进行有效投票时返回的值:
| eg:
| proba = np.where(proba >= threshold, 1, 0)
| if proba.sum() != 1:
| # eg: proba = array([[ 0.2328, 0.7672]])->array([[0, 0]])
| return default_ret
| :param pre_fit: bool,默认pre_fit True, 代表每次predict前先fit,
| 如在乎效率的情况下,需要在外部先fit后,参数pre_fit置False
| :param kwargs: 装饰器使用的fiter_type,
| eg:iris_abu.predict_proba_threshold(test_input, , threshold=0.77 ,default_ret=0
| fiter_type=ml.EMLFitType.E_FIT_CLF)
| :return: int,default_ret or proba.argmax()
|
| random_forest_classifier_best(self, **kwargs)
| eg:
| random_forest_classifier_best有param_grid参数调用:
|
| param_grid = {'max_features': ['sqrt', 'log2', ], 'n_estimators': np.arange(50, 200, 20)}
| ttn_abu.random_forest_classifier_best(param_grid=param_grid, n_jobs=-1)
|
| out: RandomForestClassifier(max_features='sqrt', n_estimators=190)
|
| random_forest_classifier_best无param_grid参数调用:
|
| from abupy import AbuML, ml
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.random_forest_classifier_best()
|
| :param kwargs: 关键字可选参数param_grid: 最优字典关键字参数
| eg:param_grid = {'max_features': ['sqrt', 'log2', ],
| 'n_estimators': np.arange(10, 150, 15)}
|
| 关键字可选参数assign: 是否保存实例化后最优参数的学习器对象,默认True
| 关键字可选参数n_jobs: 并行执行的进程任务数量,默认-1, 开启与cpu相同数量的进程数
| 关键字可选参数show: 是否可视化最优参数搜索结果
| :return: 通过最优参数构造的RandomForestClassifier对象
|
| random_forest_regressor_best(self, **kwargs)
| eg:
| random_forest_regressor_best无param_grid参数调用:
|
| from abupy import AbuML, ml
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.random_forest_regressor_best()
|
| random_forest_regressor_best有param_grid参数调用:
|
| param_grid = {'max_features': ['sqrt', 'log2', ], 'n_estimators': np.arange(10, 150, 15)}
| ttn_abu.random_forest_regressor_best(param_grid=param_grid, n_jobs=-1)
|
| out: RandomForestRegressor(max_features='log2', n_estimators=115)
|
|
| :param kwargs: 关键字可选参数param_grid: 最优字典关键字参数
| eg:param_grid = {'max_features': ['sqrt', 'log2', ],
| 'n_estimators': np.arange(10, 150, 15)}
|
| 关键字可选参数assign: 是否保存实例化后最优参数的学习器对象,默认True
| 关键字可选参数n_jobs: 并行执行的进程任务数量,默认-1, 开启与cpu相同数量的进程数
| 关键字可选参数show: 是否可视化最优参数搜索结果
| :return: 通过最优参数构造的RandomForestRegressor对象
|
| search_match_neg_threshold(self, accuracy_match=0, effect_rate_match=0, neg_num=50, **kwargs)
| 套接self.cross_val_prob_accuracy_score,通过np.linspace(0.01, 0.50, num=neg_num)[::-1]生成
| pb_threshold参数序列,这里linspace的start从0.01至0.50后[::-1]倒序,依次迭代生成的阀值参数
| ,当cross_val_prob_accuracy_score返回的正确率大于 参数中accuracy_match且返回的生效率大于参数中的effect_rate_match,
| 匹配寻找成功,中断迭代操作,返回寻找到的满足条件的阀值,返回的阀值应用场景阅读predict_proba_threshold函数
|
| eg:
| in: ttn_abu.search_match_neg_threshold(0.85, 0.80, fiter_type=ml.EMLFitType.E_FIT_CLF)
| out: 0.220 satisfy require, accuracy:0.852, effect_rate:0.844
|
| :param accuracy_match: 寻找阀值条件,需要当cross_val_prob_accuracy_score返回的正确率大于accuracy_match,
| float, 范围(0-1),默认值0
| :param effect_rate_match: 寻找阀值条件,需要当cross_val_prob_accuracy_score返回的生效率大于effect_rate_match,
| float, 范围(0-1),默认值0
| :param neg_num: 透传neg_thresholds = np.linspace(0.01, 0.50, num=neg_num)[::-1]的参数,默认50
| :param kwargs: 装饰器使用的fiter_type,
| eg: iris_abu.search_match_neg_threshold(0.85, 0.80, fiter_type=ml.EMLFitType.E_FIT_CLF)
| :return: 返回寻找到的满足条件的阀值,float
|
| search_match_pos_threshold(self, accuracy_match=0, effect_rate_match=0, pos_num=50, **kwargs)
| 套接self.cross_val_prob_accuracy_score,通过np.linspace(0.50, 0.99, num=neg_num)生成
| pb_threshold参数序列,这里linspace的start从0.50至0.99正序,依次迭代生成的阀值参数
| ,当cross_val_prob_accuracy_score返回的正确率大于 参数中accuracy_match且返回的生效率大于参数中的effect_rate_match,
| 匹配寻找成功,中断迭代操作,返回寻找到的满足条件的阀值,返回的阀值应用场景阅读predict_proba_threshold函数
|
| eg:
| in: ttn_abu.search_match_pos_threshold(0.85, 0.80, fiter_type=ml.EMLFitType.E_FIT_CLF)
| out: 0.770 satisfy require, accuracy:0.850, effect_rate:0.854
|
| :param accuracy_match: 寻找阀值条件,需要当cross_val_prob_accuracy_score返回的正确率大于accuracy_match,
| float, 范围(0-1),默认值0
| :param effect_rate_match: 寻找阀值条件,需要当cross_val_prob_accuracy_score返回的生效率大于effect_rate_match,
| float, 范围(0-1),默认值0
| :param pos_num: 透传neg_thresholds = np.linspace(0.50, 0.99, num=neg_num)的参数,默认50
| :param kwargs: 装饰器使用的fiter_type,
| eg: iris_abu.search_match_pos_threshold(0.85, 0.80, fiter_type=ml.EMLFitType.E_FIT_CLF)
| :return: 返回寻找到的满足条件的阀值,float
|
| train_test_split_df(self, test_size=0.1, random_state=0, **kwargs)
| 套接封装train_test_split_xy,外部传递pd.DataFrame参数时使用
| :param test_size: 透传参数train_test_split_xy
| :param random_state: 透传参数train_test_split_xy
| :param kwargs: 通过 df = kwargs.pop('df', self.df)弹出传递的pd.DataFrame对象进行x,y分解
| y = matrix[:, 0],即硬编码分类y在第一列,外部传递的df对象需要遵循
| 以及装饰器使用的fiter_type,eg:ttn_abu.train_test_split_df(fiter_type=ml.EMLFitType.E_FIT_CLF)
|
| train_test_split_xy(self, test_size=0.1, random_state=0, **kwargs)
| 被entry_wrapper(support=(EMLFitType.E_FIT_CLF, ))装饰,即只支持分类
| 首先使用train_test_split将x,y根据参数test_size切割训练集和测试集,
| 显示数据集,训练集,测试集的数量,针对训练集数据进行训练,使用训练好的
| 分类器对测试集x进行predict,对结果分别使用metrics.accuracy_score,
| metrics.precision_score, metrics.recall_score度量准确率,查准率,
| 和召回率,多label的的情况下使用average = 'macro'对precision_score和
| recall_score进行度量,最后显示分类结果混淆矩阵以及metrics.classification_report
| 情况
|
| eg:
| x-y:(891, 14)-(891,)
| train_x-train_y:(801, 14)-(801,)
| test_x-test_y:(90, 14)-(90,)
| accuracy = 0.77
| precision_score = 0.74
| recall_score = 0.72
| Predicted
| | 0 | 1 |
| |-----|-----|
| 0 | 41 | 10 |
| Actual |-----|-----|
| 1 | 11 | 28 |
| |-----|-----|
| precision recall f1-score support
|
| 0.0 0.79 0.80 0.80 51
| 1.0 0.74 0.72 0.73 39
|
| avg / total 0.77 0.77 0.77 90
|
| :param test_size: 测试集占比例,float,默认0.1,即将数据分10份,一份做为测试集
| :param random_state: 透传给train_test_split的随机参数
| :param kwargs: 外部可以传递x, y, 通过
| x = kwargs.pop('x', self.x)
| y = kwargs.pop('y', self.y)
| 以及装饰器使用的fiter_type,eg:ttn_abu.train_test_split_xy(fiter_type=ml.EMLFitType.E_FIT_CLF)
|
| xgb_classifier_best(self, **kwargs)
| eg:
| xgb_classifier_best有param_grid参数调用:
|
| param_grid = {'learning_rate': np.arange(0.1, 0.5, 0.05), 'n_estimators': np.arange(50, 200, 10)}
| ttn_abu.xgb_classifier_best(param_grid=param_grid, n_jobs=-1)
|
| out: GradientBoostingClassifier(learning_rate=0.1, n_estimators=160)
| xgb_classifier_best无param_grid参数调用:
|
| from abupy import AbuML, ml
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.xgb_classifier_best()
|
| :param kwargs: 关键字可选参数param_grid: 最优字典关键字参数
| eg:param_grid = {'learning_rate': np.arange(0.1, 0.5, 0.05),
| 'n_estimators': np.arange(50, 200, 10)}
|
| 关键字可选参数assign: 是否保存实例化后最优参数的学习器对象,默认True
| 关键字可选参数n_jobs: 并行执行的进程任务数量,默认-1, 开启与cpu相同数量的进程数
| 关键字可选参数show: 是否可视化最优参数搜索结果
| :return: 通过最优参数构造的GradientBoostingClassifier对象
|
| xgb_regressor_best(self, **kwargs)
| eg:
| xgb_regressor_best有param_grid参数调用:
|
| param_grid = {'learning_rate': np.arange(0.1, 0.5, 0.05), 'n_estimators': np.arange(10, 100, 10)}
| ttn_abu.xgb_regressor_best(param_grid=param_grid, n_jobs=-1)
|
| out: GradientBoostingRegressor(learning_rate=0.2, n_estimators=70)
|
|
| xgb_regressor_best无param_grid参数调用:
|
| from abupy import AbuML, ml
| ttn_abu = AbuML.create_test_more_fiter()
| ttn_abu.xgb_regressor_best()
|
|
| :param kwargs: 关键字可选参数param_grid: 最优字典关键字参数
| eg:param_grid = {'learning_rate': np.arange(0.1, 0.5, 0.05),
| 'n_estimators': np.arange(10, 100, 10)}
| 关键字可选参数assign: 是否保存实例化后最优参数的学习器对象,默认True
| 关键字可选参数n_jobs: 并行执行的进程任务数量,默认-1, 开启与cpu相同数量的进程数
| 关键字可选参数show: 是否可视化最优参数搜索结果
| :return: 通过最优参数构造的GradientBoostingRegressor对象
|
| ----------------------------------------------------------------------
| Class methods defined here:类函数
|
| create_test_fiter() from builtins.type
| 类方法:使用iris数据构造AbuML对象,测试接口,通过简单iris数据对方法以及策略进行验证
| iris数据量小,如需要更多数据进行接口测试可使用create_test_more_fiter接口
|
| eg: iris_abu = AbuML.create_test_fiter()
|
| :return: AbuML(x, y, df),
| eg: df
| y x0 x1 x2 x3
| 0 0 5.1 3.5 1.4 0.2
| 1 0 4.9 3.0 1.4 0.2
| 2 0 4.7 3.2 1.3 0.2
| 3 0 4.6 3.1 1.5 0.2
| 4 0 5.0 3.6 1.4 0.2
| .. .. ... ... ... ...
| 145 2 6.7 3.0 5.2 2.3
| 146 2 6.3 2.5 5.0 1.9
| 147 2 6.5 3.0 5.2 2.0
| 148 2 6.2 3.4 5.4 2.3
| 149 2 5.9 3.0 5.1 1.8
|
| create_test_more_fiter() from builtins.type
| 类方法:使用泰坦尼克数据构造AbuML对象,测试接口,对方法以及策略进行验证 比iris数据多
| eg: ttn_abu = AbuML.create_test_more_fiter()
|
| :return: AbuML(x, y, df),构造AbuML最终的泰坦尼克数据形式如:
|
| eg: df
| Survived SibSp Parch Cabin_No Cabin_Yes Embarked_C Embarked_Q 0 0 1 0 1 0 0 0
| 1 1 1 0 0 1 1 0
| 2 1 0 0 1 0 0 0
| 3 1 1 0 0 1 0 0
| 4 0 0 0 1 0 0 0
| 5 0 0 0 1 0 0 1
| 6 0 0 0 0 1 0 0
| 7 0 3 1 1 0 0 0
| 8 1 0 2 1 0 0 0
| 9 1 1 0 1 0 1 0
| .. ... ... ... ... ... ... ...
|
| Embarked_S Sex_female Sex_male Pclass_1 Pclass_2 Pclass_3 0 1 0 1 0 0 1
| 1 0 1 0 1 0 0
| 2 1 1 0 0 0 1
| 3 1 1 0 1 0 0
| 4 1 0 1 0 0 1
| 5 0 0 1 0 0 1
| 6 1 0 1 1 0 0
| 7 1 0 1 0 0 1
| 8 1 1 0 0 0 1
| 9 0 1 0 0 1 0
| .. ... ... ... ... ... ...
| Age_scaled Fare_scaled
| 0 -0.5614 -0.5024
| 1 0.6132 0.7868
| 2 -0.2677 -0.4889
| 3 0.3930 0.4207
| 4 0.3930 -0.4863
| 5 -0.4271 -0.4781
| 6 1.7877 0.3958
| 7 -2.0295 -0.2241
| 8 -0.1943 -0.4243
| .. ... ...
|
| load_ttn_raw_df() from builtins.type
| 读取泰坦尼克测试数据
| :return: pd.DataFrame对象,from接口pd.read_csv(train_csv_path)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)