AbuML函数

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)