Python catboost.CatBoostClassifier方法代码示例

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def Train(data, modelcount, censhu, yanzhgdata, predata, cat=data.catind):
    model = cb.CatBoostClassifier(iterations=modelcount, depth=censhu, learning_rate=0.5, loss_function='Logloss',
                                  logging_level='Verbose')

    model.fit(data[:, :-1], data[:, -1], cat_features=cat, eval_set=(yanzhgdata[:, :-1], yanzhgdata[:, -1]))
    # 给出训练数据的分数
    train_mse = model.score(data[:, :-1], data[:, -1])

    # 给出验证数据的分数
    add_mse = model.score(yanzhgdata[:, :-1], yanzhgdata[:, -1])
    print(train_mse, add_mse)
    # 输出预测数据的预测值
    preout = model.predict(predata[:, :-1])
    return train_mse, add_mse, preout

# 最终确定组合的函数 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def test_cv_cat_df():
    X, y = make_classification_df(n_samples=1024, n_num_features=20, n_cat_features=1, class_sep=0.98, random_state=0)
    X, _ = autoprep_gbdt('cat', X, None)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)

    models = [CatBoostClassifier(n_estimators=300) for _ in range(5)]

    pred_oof, pred_test, scores, importance = cross_validate(models, X_train, y_train, X_test, cv=5,
                                                             eval_func=roc_auc_score,
                                                             fit_params={'cat_features': ['cat_0']})

    print(scores)
    assert len(scores) == 5 + 1
    assert scores[-1] >= 0.85  # overall roc_auc
    assert roc_auc_score(y_train, pred_oof) == scores[-1]
    assert roc_auc_score(y_test, pred_test) >= 0.85  # test roc_auc
    assert roc_auc_score(y_test, models[0].predict_proba(X_test)[:, 1]) >= 0.85  # make sure models are trained
    assert len(importance) == 5
    assert list(importance[0].columns) == ['feature', 'importance']
    assert len(importance[0]) == 20 + 1
    assert models[0].tree_count_ < 300  # making sure early stopping worked 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def __init__(self):
        self._models = dict()
        try:
            import sklearn.ensemble
            self._models['RandomForestClassifier'] = sklearn.ensemble.RandomForestClassifier
        except ImportError:
            pass

        try:
            import xgboost
            self._models['XGBClassifier'] = xgboost.XGBClassifier
        except ImportError:
            pass

        try:
            import lightgbm
            self._models['LGBMClassifier'] = lightgbm.LGBMClassifier
        except ImportError:
            pass

        try:
            import catboost
            self._models['CatBoostClassifier'] = catboost.CatBoostClassifier
        except ImportError:
            pass 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def fit(self, X, y, sample_weight=None, eval_set=None, sample_weight_eval_set=None, **kwargs):
        lb = LabelEncoder()
        lb.fit(self.labels)
        y = lb.transform(y)
        orig_cols = list(X.names)
        XX = X.to_pandas()
        params = {
            'train_dir': user_dir(),
            'allow_writing_files': False,
            'thread_count': 10,
            # 'loss_function': 'Logloss'
        }
        from catboost import CatBoostClassifier
        model = CatBoostClassifier(**params)
        model.fit(XX, y=y, sample_weight=sample_weight, verbose=False,
                  cat_features=list(X[:, [str, int]].names))  # Amazon specific, also no early stopping

        # must always set best_iterations
        self.set_model_properties(model=model,
                                  features=orig_cols,
                                  importances=model.feature_importances_,
                                  iterations=0) 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def test_catboost_bin_classifier(self):
        import onnxruntime
        from distutils.version import StrictVersion

        if StrictVersion(onnxruntime.__version__) >= StrictVersion('1.3.0'):
            X, y = make_classification(n_samples=100, n_features=4, random_state=0)
            catboost_model = catboost.CatBoostClassifier(task_type='CPU', loss_function='CrossEntropy',
                                                         n_estimators=10, verbose=0)
            catboost_model.fit(X.astype(numpy.float32), y)

            catboost_onnx = convert_catboost(catboost_model, name='CatBoostBinClassification',
                                             doc_string='test binary classification')
            self.assertTrue(catboost_onnx is not None)
            dump_data_and_model(X.astype(numpy.float32), catboost_model, catboost_onnx, basename="CatBoostBinClass")

        else:
            warnings.warn('Converted CatBoost models for binary classification work with onnxruntime version 1.3.0 or '
                          'a newer one') 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def __init__(self, **kwargs):
        super().__init__()
        self.estimator = ctb.CatBoostClassifier(**kwargs) 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def CatBoost_First(self, data, catsign, depth=5, iterations=200):

        model = cb.CatBoostClassifier(iterations=iterations, depth=depth, learning_rate=0.5,
                                      loss_function='Logloss', logging_level='Verbose')

        model.fit(data['train'][:, :-1], data['train'][:, -1], cat_features=catsign)
        # 注意存储验证数据集结果和预测数据集结果的不同
        # 训练数据集的预测结果
        xul = model.predict(data['train'][:, :-1])
        # 验证的预测结果
        yanre = model.predict(data['test'][:, :-1])
        # 预测的预测结果
        prer = model.predict(data['predict'][:, :-1])

        # 每计算一折后，要计算训练、验证、预测数据的误差
        xx = self.F1(xul, data['train'][:, -1])

        yy = self.F1(yanre, data['test'][:, -1])

        pp = self.F1(prer, data['predict'][:, -1])

        # 开始结合
        self.yanzhneg_pr.append(yanre)
        self.yanzhneg_real = data['test'][:, -1]
        self.predi.append(prer)
        self.preal = data['predict'][:, -1]

        # 存储误差
        self.error_dict['CatBoost'] = [xx, yy, pp]

        return print('1层中的CatBoost运行完毕') 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def __init__(self, target_labels, *args, **kwargs):
        self.target_labels = target_labels
        self.n_classes = len(target_labels)
        self.models = [CatBoostClassifier(*args, **kwargs) for _ in range(self.n_classes)] 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def dump(self, model) -> ArtifactCollection:
        """
        Dumps `catboost.CatBoostClassifier` or `catboost.CatBoostRegressor` instance to :class:`.LocalFileBlob` and
        creates :class:`.ArtifactCollection` from it

        :return: context manager with :class:`~ebonite.core.objects.ArtifactCollection`
        """
        model_file = tempfile.mktemp()
        try:
            model.save_model(model_file)
            yield Blobs({self._get_model_file_name(model): LocalFileBlob(model_file)})
        finally:
            os.remove(model_file) 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def _get_model_file_name(self, model):
        if isinstance(model, CatBoostClassifier):
            return self.classifier_file_name
        return self.regressor_file_name 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def load(self, path):
        """
        Loads `catboost.CatBoostClassifier` or `catboost.CatBoostRegressor` instance from path

        :param path: path to load from
        """
        if os.path.exists(os.path.join(path, self.classifier_file_name)):
            model_type = CatBoostClassifier
        else:
            model_type = CatBoostRegressor

        model = model_type()
        model.load_model(os.path.join(path, self._get_model_file_name(model)))
        return model 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def _exposed_methods_mapping(self):
        ret = {
            'predict': 'predict'
        }
        if isinstance(self.model, CatBoostClassifier):
            ret['predict_proba'] = 'predict_proba'
        return ret 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def catboost_classifier(pandas_data, catboost_params):
    return CatBoostClassifier(**catboost_params).fit(pandas_data, [1, 0]) 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def test_serialization_final_fallback(ray_start_regular):
    pytest.importorskip("catboost")
    # This test will only run when "catboost" is installed.
    from catboost import CatBoostClassifier

    model = CatBoostClassifier(
        iterations=2,
        depth=2,
        learning_rate=1,
        loss_function="Logloss",
        logging_level="Verbose")

    reconstructed_model = ray.get(ray.put(model))
    assert set(model.get_params().items()) == set(
        reconstructed_model.get_params().items()) 

# 需要导入模块: import catboost [as 别名]
# 或者: from catboost import CatBoostClassifier [as 别名]
def __init__(self, **kwargs):
        self.estimator = ctb.CatBoostClassifier(**kwargs)