auc函数python auc函数可以用于无监督么

auc 论文里的 怎么计算 python svm

利用Python画ROC曲线，以及AUC值的计算\

成都创新互联主营龙华网站建设的网络公司,主营网站建设方案,成都app开发,龙华h5微信小程序搭建,龙华网站营销推广欢迎龙华等地区企业咨询

前言

ROC（Receiver Operating Characteristic）曲线和AUC常被用来评价一个二值分类器（binary classifier）的优劣。这篇文章将先简单的介绍ROC和AUC，而后用实例演示如何python作出ROC曲线图以及计算AUC。

AUC介绍

AUC(Area Under Curve)是机器学习二分类模型中非常常用的评估指标，相比于F1-Score对项目的不平衡有更大的容忍性，目前常见的机器学习库中(比如scikit-learn)一般也都是集成该指标的计算，但是有时候模型是单独的或者自己编写的，此时想要评估训练模型的好坏就得自己搞一个AUC计算模块，本文在查询资料时发现libsvm-tools有一个非常通俗易懂的auc计算，因此抠出来用作日后之用。

AUC计算

AUC的计算分为下面三个步骤：

1、计算数据的准备，如果模型训练时只有训练集的话一般使用交叉验证的方式来计算，如果有评估集(evaluate)一般就可以直接计算了，数据的格式一般就是需要预测得分以及其目标类别（注意是目标类别，不是预测得到的类别）

2、根据阈值划分得到横（X:False Positive Rate）以及纵（Y:True Positive Rate）点

3、将坐标点连成曲线之后计算其曲线下面积,就是AUC的值

直接上python代码

#! -*- coding=utf-8 -*-

import pylab as pl

from math import log,exp,sqrt

evaluate_result="you file path"

db = [] #[score,nonclk,clk]

pos, neg = 0, 0

with open(evaluate_result,'r') as fs:

for line in fs:

nonclk,clk,score = line.strip().split('\t')

nonclk = int(nonclk)

clk = int(clk)

score = float(score)

db.append([score,nonclk,clk])

pos += clk

neg += nonclk

db = sorted(db, key=lambda x:x[0], reverse=True)

#计算ROC坐标点

xy_arr = []

tp, fp = 0., 0.

for i in range(len(db)):

tp += db[i][2]

fp += db[i][1]

xy_arr.append([fp/neg,tp/pos])

#计算曲线下面积

auc = 0.

prev_x = 0

for x,y in xy_arr:

if x != prev_x:

auc += (x - prev_x) * y

prev_x = x

print "the auc is %s."%auc

x = [_v[0] for _v in xy_arr]

y = [_v[1] for _v in xy_arr]

pl.title("ROC curve of %s (AUC = %.4f)" % ('svm',auc))

pl.xlabel("False Positive Rate")

pl.ylabel("True Positive Rate")

pl.plot(x, y)# use pylab to plot x and y

pl.show()# show the plot on the screen

输入的数据集可以参考svm预测结果

其格式为:

nonclk \t clk \t score

其中：

1、nonclick:未点击的数据，可以看做负样本的数量

2、clk:点击的数量，可以看做正样本的数量

3、score:预测的分数，以该分数为group进行正负样本的预统计可以减少AUC的计算量

运行的结果为:

如果本机没安装pylab可以直接注释依赖以及画图部分

注意

上面贴的代码:

1、只能计算二分类的结果（至于二分类的标签随便处理）

2、上面代码中每个score都做了一次阈值，其实这样效率是相当低的，可以对样本进行采样或者在计算横轴坐标时进行等分计算

python 怎么画与其他方法进行比较的ROC曲线？

使用sklearn的一系列方法后可以很方便的绘制处ROC曲线，这里简单实现以下。

主要是利用混淆矩阵中的知识作为绘制的数据（如果不是很懂可以先看看这里的基础）：

tpr(Ture Positive Rate)：真阳率 图像的纵坐标

fpr(False Positive Rate)：阳率（伪阳率） 图像的横坐标

mean_tpr：累计真阳率求平均值

mean_fpr：累计阳率求平均值

import numpy as np

import matplotlib.pyplot as plt

from sklearn import svm, datasets

from sklearn.metrics import roc_curve, auc

from sklearn.model_selection import StratifiedKFold

iris = datasets.load_iris()

X = iris.data

y = iris.target

X, y = X[y != 2], y[y != 2] # 去掉了label为2，label只能二分，才可以。

n_samples, n_features = X.shape

# 增加噪声特征

random_state = np.random.RandomState(0)

X = np.c_[X, random_state.randn(n_samples, 200 * n_features)]

cv = StratifiedKFold(n_splits=6) #导入该模型，后面将数据划分6份

classifier = svm.SVC(kernel='linear', probability=True,random_state=random_state) # SVC模型 可以换作AdaBoost模型试试

# 画平均ROC曲线的两个参数

mean_tpr = 0.0 # 用来记录画平均ROC曲线的信息

mean_fpr = np.linspace(0, 1, 100)

cnt = 0

for i, (train, test) in enumerate(cv.split(X,y)): #利用模型划分数据集和目标变量 为一一对应的下标

cnt +=1

probas_ = classifier.fit(X[train], y[train]).predict_proba(X[test]) # 训练模型后预测每条样本得到两种结果的概率

fpr, tpr, thresholds = roc_curve(y[test], probas_[:, 1]) # 该函数得到伪正例、真正例、阈值，这里只使用前两个

mean_tpr += np.interp(mean_fpr, fpr, tpr) # 插值函数 interp(x坐标,每次x增加距离,y坐标) 累计每次循环的总值后面求平均值

mean_tpr[0] = 0.0 # 将第一个真正例=0 以0为起点

roc_auc = auc(fpr, tpr) # 求auc面积

plt.plot(fpr, tpr, lw=1, label='ROC fold {0:.2f} (area = {1:.2f})'.format(i, roc_auc)) # 画出当前分割数据的ROC曲线

plt.plot([0, 1], [0, 1], '--', color=(0.6, 0.6, 0.6), label='Luck') # 画对角线

mean_tpr /= cnt # 求数组的平均值

mean_tpr[-1] = 1.0 # 坐标最后一个点为（1,1） 以1为终点

mean_auc = auc(mean_fpr, mean_tpr)

plt.plot(mean_fpr, mean_tpr, 'k--',label='Mean ROC (area = {0:.2f})'.format(mean_auc), lw=2)

plt.xlim([-0.05, 1.05]) # 设置x、y轴的上下限，设置宽一点，以免和边缘重合，可以更好的观察图像的整体

plt.ylim([-0.05, 1.05])

plt.xlabel('False Positive Rate')

plt.ylabel('True Positive Rate') # 可以使用中文，但需要导入一些库即字体

plt.title('Receiver operating characteristic example')

plt.legend(loc="lower right")

plt.show()

如何用Python在10分钟内建立一个预测模型

预测模型的分解过程

我总是集中于投入有质量的时间在建模的初始阶段，比如，假设生成、头脑风暴、讨论或理解可能的结果范围。所有这些活动都有助于我解决问题，并最终让我设计出更强大的商业解决方案。为什么你要在前面花费这段时间，这有充分的理由：

你有足够的时间投入并且你是无经验的（这是有影响的）

你不带有其它数据观点或想法的偏见（我总是建议，在深入研究数据之前做假设生成）

在后面的阶段，你会急于完成该项目而没有能力投入有质量的时间了。

这个阶段需要投入高质量时间，因此我没有提及时间表，不过我建议你把它作为标准的做法。这有助于你建立建立更好地预测模型，在后面的阶段的只需较少的迭代工作。让我们来看看建立第一个模型的剩余阶段的时间表：

数据描述性分析——50%的时间

数据预处理（缺失值和异常值修复）——40%的时间

数据建模——4%的时间

性能预测——6%的时间

让我们一步一步完成每个过程（每一步投入预测的时间）：

阶段1：描述性分析/数据探索

在我刚开始成为数据科学家的时候，数据探索占据了我大量的时间。不过，随着时间的推移，我已经把大量的数据操作自动化了。由于数据准备占据建立第一个模型工作量的50%，自动化的好处是显而易见的。

这是我们的第一个基准模型，我们去掉任何特征设计。因此，描述分析所需的时间仅限于了解缺失值和直接可见的大的特征。在我的方法体系中，你将需要2分钟来完成这一步（假设，100000个观测数据集）。

我的第一个模型执行的操作：

确定ID，输入特征和目标特征

确定分类和数值特征

识别缺失值所在列

阶段2：数据预处理（缺失值处理）

有许多方法可以解决这个问题。对于我们的第一个模型，我们将专注于智能和快速技术来建立第一个有效模型。

为缺失值创建假标志：有用，有时缺失值本身就携带了大量的信息。

用均值、中位数或其它简单方法填补缺失值：均值和中位数填补都表现良好，大多数人喜欢用均值填补但是在有偏分布的情况下我建议使用中位数。其它智能的方法与均值和中位数填补类似，使用其它相关特征填补或建立模型。比如，在Titanic生存挑战中，你可以使用乘客名字的称呼，比如：“Mr.”, “Miss.”,”Mrs.”,”Master”，来填补年龄的缺失值，这对模型性能有很好的影响。

填补缺失的分类变量：创建一个新的等级来填补分类变量，让所有的缺失值编码为一个单一值比如，“New_Cat”，或者，你可以看看频率组合，使用高频率的分类变量来填补缺失值。

由于数据处理方法如此简单，你可以只需要3到4分钟来处理数据。

阶段3：数据建模

根据不同的业务问题，我推荐使用GBM或RandomForest技术的任意一种。这两个技术可以极其有效地创建基准解决方案。我已经看到数据科学家通常把这两个方法作为他们的第一个模型同时也作为最后一个模型。这最多用去4到5分钟。

阶段4：性能预测

有各种各样的方法可以验证你的模型性能，我建议你将训练数据集划分为训练集和验证集（理想的比例是70：30）并且在70%的训练数据集上建模。现在，使用30%的验证数据集进行交叉验证并使用评价指标进行性能评估。最后需要1到2分钟执行和记录结果。

本文的目的不是赢得比赛，而是建立我们自己的基准。让我们用python代码来执行上面的步骤，建立你的第一个有较高影响的模型。

让我们开始付诸行动

首先我假设你已经做了所有的假设生成并且你擅长使用python的基本数据科学操作。我用一个数据科学挑战的例子来说明。让我们看一下结构：

步骤1：导入所需的库，读取测试和训练数据集。

#导入pandas、numpy包，导入LabelEncoder、random、RandomForestClassifier、GradientBoostingClassifier函数

import pandas as pd

import numpy as np

fromsklearn.preprocessing import LabelEncoder

import random

fromsklearn.ensemble import RandomForestClassifier

from sklearn.ensembleimport GradientBoostingClassifier

#读取训练、测试数据集

train=pd.read_csv('C:/Users/AnalyticsVidhya/Desktop/challenge/Train.csv')

test=pd.read_csv('C:/Users/AnalyticsVidhya/Desktop/challenge/Test.csv')

#创建训练、测试数据集标志

train='Train'

test='Test'

fullData =pd.concat(,axis=0) #联合训练、测试数据集

步骤2：该框架的第二步并不需要用到python，继续下一步。

步骤3：查看数据集的列名或概要

fullData.columns # 显示所有的列名称

fullData.head(10) #显示数据框的前10条记录

fullData.describe() #你可以使用describe()函数查看数值域的概要

步骤4：确定a)ID变量 b)目标变量 c)分类变量 d)数值变量 e)其他变量。

ID_col =

target_col =

cat_cols =

num_cols= list(set(list(fullData.columns))-set(cat_cols)-set(ID_col)-set(target_col)-set(data_col))

other_col= #为训练、测试数据集设置标识符

步骤5：识别缺失值变量并创建标志

fullData.isnull().any()#返回True或False，True意味着有缺失值而False相反

num_cat_cols = num_cols+cat_cols # 组合数值变量和分类变量

#为有缺失值的变量创建一个新的变量

# 对缺失值标志为1，否则为0

for var in num_cat_cols:

if fullData.isnull().any()=True:

fullData=fullData.isnull()*1

步骤6：填补缺失值

#用均值填补数值缺失值

fullData = fullData.fillna(fullData.mean(),inplace=True)

#用-9999填补分类变量缺失值

fullData = fullData.fillna(value = -9999)

步骤7：创建分类变量的标签编码器，将数据集分割成训练和测试集，进一步，将训练数据集分割成训练集和测试集。

#创建分类特征的标签编码器

for var in cat_cols:

number = LabelEncoder()

fullData = number.fit_transform(fullData.astype('str'))

#目标变量也是分类变量，所以也用标签编码器转换

fullData = number.fit_transform(fullData.astype('str'))

train=fullData='Train']

test=fullData='Test']

train = np.random.uniform(0, 1, len(train)) = .75

Train, Validate = train=True], train=False]

步骤8：将填补和虚假（缺失值标志）变量传递到模型中，我使用随机森林来预测类。

features=list(set(list(fullData.columns))-set(ID_col)-set(target_col)-set(other_col))

x_train = Train.values

y_train = Train.values

x_validate = Validate.values

y_validate = Validate.values

x_test=test.values

random.seed(100)

rf = RandomForestClassifier(n_estimators=1000)

rf.fit(x_train, y_train)

步骤9：检查性能做出预测

status = rf.predict_proba(x_validate)

fpr, tpr, _ = roc_curve(y_validate, status)

roc_auc = auc(fpr, tpr)

print roc_auc

final_status = rf.predict_proba(x_test)

test=final_status

test.to_csv('C:/Users/Analytics Vidhya/Desktop/model_output.csv',columns=)

现在可以提交了！

python tensorflow 怎么添加auc

tensorflow添加自定义的auc计算operator

tensorflow可以很方便的添加用户自定义的operator(如果不添加也可以采用sklearn的auc计算函数或者自己写一个 但是会在python执行，这里希望在graph中也就是c++端执行这个计算)

这里根据工作需要添加一个计算auc的operator，只给出最简单实现，后续高级功能还是参考官方wiki

注意tensorflow现在和最初的官方wiki有变化，原wiki貌似是需要重新bazel编译整个tensorflow，然后使用比如tf.user_op.auc这样。

目前wiki给出的方式=0.6.0版本，采用plug-in的方式，更加灵活可以直接用g++编译一个so载入，解耦合，省去了编译tensorflow过程，即插即用。

首先auc的operator计算的文件

tensorflow/core/user_ops/auc.cc

/* Copyright 2015 Google Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

==============================================================================*/

// An auc Op.

#include "tensorflow/core/framework/op.h"

#include "tensorflow/core/framework/op_kernel.h"

using namespace tensorflow;

using std::vector;

//@TODO add weight as optional input

REGISTER_OP("Auc")

.Input("predicts: T1")

.Input("labels: T2")

.Output("z: float")

.Attr("T1: {float, double}")

.Attr("T2: {float, double}")

//.Attr("T1: {float, double}")

//.Attr("T2: {int32, int64}")

.SetIsCommutative()

.Doc(R"doc(

Given preidicts and labels output it's auc

)doc");

class AucOp : public OpKernel {

public:

explicit AucOp(OpKernelConstruction* context) : OpKernel(context) {}

templatetypename ValueVec

void index_sort(const ValueVec valueVec, vectorint indexVec)

{

indexVec.resize(valueVec.size());

for (size_t i = 0; i indexVec.size(); i++)

{

indexVec[i] = i;

}

std::sort(indexVec.begin(), indexVec.end(),

[valueVec](const int l, const int r) { return valueVec(l) valueVec(r); });

}

void Compute(OpKernelContext* context) override {

// Grab the input tensor

const Tensor predicts_tensor = context-input(0);

const Tensor labels_tensor = context-input(1);

auto predicts = predicts_tensor.flatfloat(); //输入能接受float double那么这里如何都处理?

auto labels = labels_tensor.flatfloat();

vectorint indexes;

index_sort(predicts, indexes);

typedef float Float;

Float oldFalsePos = 0;

Float oldTruePos = 0;

Float falsePos = 0;

Float truePos = 0;

Float oldOut = std::numeric_limitsFloat::infinity();

Float result = 0;

for (size_t i = 0; i indexes.size(); i++)

{

int index = indexes[i];

Float label = labels(index);

Float prediction = predicts(index);

Float weight = 1.0;

//Pval3(label, output, weight);

if (prediction != oldOut) //存在相同值得情况是特殊处理的

{

result += 0.5 * (oldTruePos + truePos) * (falsePos - oldFalsePos);

oldOut = prediction;

oldFalsePos = falsePos;

oldTruePos = truePos;

}

if (label 0)

truePos += weight;

else

falsePos += weight;

}

result += 0.5 * (oldTruePos + truePos) * (falsePos - oldFalsePos);

Float AUC = result / (truePos * falsePos);

// Create an output tensor

Tensor* output_tensor = NULL;

TensorShape output_shape;

OP_REQUIRES_OK(context, context-allocate_output(0, output_shape, output_tensor));

output_tensor-scalarfloat()() = AUC;

}

};

REGISTER_KERNEL_BUILDER(Name("Auc").Device(DEVICE_CPU), AucOp);

编译：

$cat gen-so.sh

TF_INC=$(python -c 'import tensorflow as tf; print(tf.sysconfig.get_include())')

TF_LIB=$(python -c 'import tensorflow as tf; print(tf.sysconfig.get_lib())')

i=$1

o=${i/.cc/.so}

g++ -std=c++11 -shared $i -o $o -I $TF_INC -l tensorflow_framework -L $TF_LIB -fPIC -Wl,-rpath $TF_LIB

$sh gen-so.sh auc.cc

会生成auc.so

使用的时候

auc_module = tf.load_op_library('auc.so')

#auc = tf.user_ops.auc #0.6.0之前的tensorflow 自定义op方式

auc = auc_module.auc

evaluate_op = auc(py_x, Y) #py_x is predicts, Y is labels

xgboost auc值怎么判断

h2XGBoost参数调优完全指南（附Python代码）/h2

译注：文内提供的代码和运行结果有一定差异，可以从这里完整代码对照参考。另外，我自己跟着教程做的时候，发现我的库无法解析字符串类型的特征，所以只用其中一部分特征做的，具体数值跟文章中不一样，反而可以帮助理解文章。所以大家其实也可以小小修改一下代码，不一定要完全跟着教程做~ ^0^

需要提前安装好的库：简介如果你的预测模型表现得有些不尽如人意，那就用XGBoost吧。XGBoost算法现在已经成为很多数据工程师的重要武器。它是一种十分精致的算法，可以处理各种不规则的数据。

构造一个使用XGBoost的模型十分简单。但是，提高这个模型的表现就有些困难(至少我觉得十分纠结)。这个算法使用了好几个参数。所以为了提高模型的表现，参数的调整十分必要。在解决实际问题的时候，有些问题是很难回答的——你需要调整哪些参数？这些参数要调到什么值，才能达到理想的输出？

这篇文章最适合刚刚接触XGBoost的人阅读。在这篇文章中，我们会学到参数调优的技巧，以及XGboost相关的一些有用的知识。以及，我们会用Python在一个数据集上实践一下这个算法。你需要知道的XGBoost(eXtreme Gradient Boosting)是Gradient Boosting算法的一个优化的版本。特别鸣谢：我个人十分感谢Mr Sudalai Rajkumar (aka SRK)大神的支持，目前他在AV Rank中位列第二。如果没有他的帮助，就没有这篇文章。在他的帮助下，我们才能给无数的数据科学家指点迷津。给他一个大大的赞！内容列表1、XGBoost的优势

2、理解XGBoost的参数

3、调整参数(含示例)1、XGBoost的优势XGBoost算法可以给预测模型带来能力的提升。当我对它的表现有更多了解的时候，当我对它的高准确率背后的原理有更多了解的时候，我发现它具有很多优势：1、正则化标准GBM的实现没有像XGBoost这样的正则化步骤。正则化对减少过拟合也是有帮助的。 实际上，XGBoost以“正则化提升(regularized boosting)”技术而闻名。2、并行处理XGBoost可以实现并行处理，相比GBM有了速度的飞跃。 不过，众所周知，Boosting算法是顺序处理的，它怎么可能并行呢？每一课树的构造都依赖于前一棵树，那具体是什么让我们能用多核处理器去构造一个树呢？我希望你理解了这句话的意思。 XGBoost 也支持Hadoop实现。3、高度的灵活性XGBoost 允许用户定义自定义优化目标和评价标准 它对模型增加了一个全新的维度，所以我们的处理不会受到任何限制。4、缺失值处理XGBoost内置处理缺失值的规则。 用户需要提供一个和其它样本不同的值，然后把它作为一个参数传进去，以此来作为缺失值的取值。XGBoost在不同节点遇到缺失值时采用不同的处理方法，并且会学习未来遇到缺失值时的处理方法。5、剪枝当分裂时遇到一个负损失时，GBM会停止分裂。因此GBM实际上是一个贪心算法。 XGBoost会一直分裂到指定的最大深度(max_depth)，然后回过头来剪枝。如果某个节点之后不再有正值，它会去除这个分裂。 这种做法的优点，当一个负损失（如-2）后面有个正损失（如+10）的时候，就显现出来了。GBM会在-2处停下来，因为它遇到了一个负值。但是XGBoost会继续分裂，然后发现这两个分裂综合起来会得到+8，因此会保留这两个分裂。6、内置交叉验证XGBoost允许在每一轮boosting迭代中使用交叉验证。因此，可以方便地获得最优boosting迭代次数。 而GBM使用网格搜索，只能检测有限个值。7、在已有的模型基础上继续XGBoost可以在上一轮的结果上继续训练。这个特性在某些特定的应用上是一个巨大的优势。 sklearn中的GBM的实现也有这个功能，两种算法在这一点上是一致的。相信你已经对XGBoost强大的功能有了点概念。注意这是我自己总结出来的几点，你如果有更多的想法，尽管在下面评论指出，我会更新这个列表的！2、XGBoost的参数XGBoost的作者把所有的参数分成了三类：

1、通用参数：宏观函数控制。

2、Booster参数：控制每一步的booster(tree/regression)。

3、学习目标参数：控制训练目标的表现。

在这里我会类比GBM来讲解，所以作为一种基础知识。通用参数这些参数用来控制XGBoost的宏观功能。1、booster[默认gbtree]选择每次迭代的模型，有两种选择：

gbtree：基于树的模型

gbliner：线性模型2、silent[默认0]当这个参数值为1时，静默模式开启，不会输出任何信息。 一般这个参数就保持默认的0，因为这样能帮我们更好地理解模型。3、nthread[默认值为最大可能的线程数]这个参数用来进行多线程控制，应当输入系统的核数。 如果你希望使用CPU全部的核，那就不要输入这个参数，算法会自动检测它。

还有两个参数，XGBoost会自动设置，目前你不用管它。接下来咱们一起看booster参数。booster参数尽管有两种booster可供选择，我这里只介绍tree booster，因为它的表现远远胜过linear booster，所以linear booster很少用到。1、eta[默认0.3]和GBM中的 learning rate 参数类似。 通过减少每一步的权重，可以提高模型的鲁棒性。 典型值为0.01-0.2。2、min_child_weight[默认1]决定最小叶子节点样本权重和。 和GBM的 min_child_leaf 参数类似，但不完全一样。XGBoost的这个参数是最小样本权重的和，而GBM参数是最小样本总数。 这个参数用于避免过拟合。当它的值较大时，可以避免模型学习到局部的特殊样本。 但是如果这个值过高，会导致欠拟合。这个参数需要使用CV来调整。3、max_depth[默认6]和GBM中的参数相同，这个值为树的最大深度。 这个值也是用来避免过拟合的。max_depth越大，模型会学到更具体更局部的样本。 需要使用CV函数来进行调优。 典型值：3-104、max_leaf_nodes树上最大的节点或叶子的数量。 可以替代max_depth的作用。因为如果生成的是二叉树，一个深度为n的树最多生成n2个叶子。 如果定义了这个参数，GBM会忽略max_depth参数。5、gamma[默认0]在节点分裂时，只有分裂后损失函数的值下降了，才会分裂这个节点。Gamma指定了节点分裂所需的最小损失函数下降值。 这个参数的值越大，算法越保守。这个参数的值和损失函数息息相关，所以是需要调整的。6、max_delta_step[默认0]这参数限制每棵树权重改变的最大步长。如果这个参数的值为0，那就意味着没有约束。如果它被赋予了某个正值，那么它会让这个算法更加保守。 通常，这个参数不需要设置。但是当各类别的样本十分不平衡时，它对逻辑回归是很有帮助的。 这个参数一般用不到，但是你可以挖掘出来它更多的用处。7、subsample[默认1]和GBM中的subsample参数一模一样。这个参数控制对于每棵树，随机采样的比例。 减小这个参数的值，算法会更加保守，避免过拟合。但是，如果这个值设置得过小，它可能会导致欠拟合。 典型值：0.5-18、colsample_bytree[默认1]和GBM里面的max_features参数类似。用来控制每棵随机采样的列数的占比(每一列是一个特征)。 典型值：0.5-19、colsample_bylevel[默认1]用来控制树的每一级的每一次分裂，对列数的采样的占比。 我个人一般不太用这个参数，因为subsample参数和colsample_bytree参数可以起到相同的作用。但是如果感兴趣，可以挖掘这个参数更多的用处。10、lambda[默认1]权重的L2正则化项。(和Ridge regression类似)。 这个参数是用来控制XGBoost的正则化部分的。虽然大部分数据科学家很少用到这个参数，但是这个参数在减少过拟合上还是可以挖掘出更多用处的。11、alpha[默认1]权重的L1正则化项。(和Lasso regression类似)。 可以应用在很高维度的情况下，使得算法的速度更快。12、scale_pos_weight[默认1]在各类别样本十分不平衡时，把这个参数设定为一个正值，可以使算法更快收敛。学习目标参数这个参数用来控制理想的优化目标和每一步结果的度量方法。1、objective[默认reg:linear]这个参数定义需要被最小化的损失函数。最常用的值有：

binary:logistic 二分类的逻辑回归，返回预测的概率(不是类别)。 multi:softmax 使用softmax的多分类器，返回预测的类别(不是概率)。

在这种情况下，你还需要多设一个参数：num_class(类别数目)。 multi:softprob 和multi:softmax参数一样，但是返回的是每个数据属于各个类别的概率。2、eval_metric[默认值取决于objective参数的取值]对于有效数据的度量方法。 对于回归问题，默认值是rmse，对于分类问题，默认值是error。 典型值有：

rmse 均方根误差(∑Ni=1?2N??????√) mae 平均绝对误差(∑Ni=1|?|N) logloss 负对数似然函数值 error 二分类错误率(阈值为0.5) merror 多分类错误率 mlogloss 多分类logloss损失函数 auc 曲线下面积3、seed(默认0)随机数的种子 设置它可以复现随机数据的结果，也可以用于调整参数如果你之前用的是Scikit-learn,你可能不太熟悉这些参数。但是有个好消息，python的XGBoost模块有一个sklearn包，XGBClassifier。这个包中的参数是按sklearn风格命名的。会改变的函数名是：

1、eta -learning_rate

2、lambda-reg_lambda

3、alpha-reg_alpha

你肯定在疑惑为啥咱们没有介绍和GBM中的’n_estimators’类似的参数。XGBClassifier中确实有一个类似的参数，但是，是在标准XGBoost实现中调用拟合函数时，把它作为’num_boosting_rounds’参数传入。调整参数(含示例)我已经对这些数据进行了一些处理：City变量，因为类别太多，所以删掉了一些类别。 DOB变量换算成年龄，并删除了一些数据。 增加了 EMI_Loan_Submitted_Missing 变量。如果EMI_Loan_Submitted变量的数据缺失，则这个参数的值为1。否则为0。删除了原先的EMI_Loan_Submitted变量。 EmployerName变量，因为类别太多，所以删掉了一些类别。 因为Existing_EMI变量只有111个值缺失，所以缺失值补充为中位数0。 增加了 Interest_Rate_Missing 变量。如果Interest_Rate变量的数据缺失，则这个参数的值为1。否则为0。删除了原先的Interest_Rate变量。 删除了Lead_Creation_Date，从直觉上这个特征就对最终结果没什么帮助。 Loan_Amount_Applied, Loan_Tenure_Applied 两个变量的缺项用中位数补足。 增加了 Loan_Amount_Submitted_Missing 变量。如果Loan_Amount_Submitted变量的数据缺失，则这个参数的值为1。否则为0。删除了原先的Loan_Amount_Submitted变量。 增加了 Loan_Tenure_Submitted_Missing 变量。如果 Loan_Tenure_Submitted 变量的数据缺失，则这个参数的值为1。否则为0。删除了原先的 Loan_Tenure_Submitted 变量。 删除了LoggedIn, Salary_Account 两个变量 增加了 Processing_Fee_Missing 变量。如果 Processing_Fee 变量的数据缺失，则这个参数的值为1。否则为0。删除了原先的 Processing_Fee 变量。 Source前两位不变，其它分成不同的类别。 进行了量化和独热编码(一位有效编码)。如果你有原始数据，可以从资源库里面data_preparation的Ipython notebook 文件，然后自己过一遍这些步骤。首先，import必要的库，然后加载数据。#Import libraries:

import pandas as pd

import numpy as np

import xgboost as xgb

from xgboost.sklearn import XGBClassifier

from sklearn import cross_validation, metrics   #Additional     scklearn functions

from sklearn.grid_search import GridSearchCV   #Perforing grid search

import matplotlib.pylab as plt

%matplotlib inline

from matplotlib.pylab import rcParams

rcParams['figure.figsize'] = 12, 4

train = pd.read_csv('train_modified.csv')

target = 'Disbursed'

IDcol = 'ID'

注意我import了两种XGBoost：xgb - 直接引用xgboost。接下来会用到其中的“cv”函数。 XGBClassifier - 是xgboost的sklearn包。这个包允许我们像GBM一样使用Grid Search 和并行处理。在向下进行之前，我们先定义一个函数，它可以帮助我们建立XGBoost models 并进行交叉验证。好消息是你可以直接用下面的函数，以后再自己的models中也可以使用它。def modelfit(alg, dtrain, predictors,useTrainCV=True, cv_folds=5, early_stopping_rounds=50):

if useTrainCV:

xgb_param = alg.get_xgb_params()

xgtrain = xgb.DMatrix(dtrain[predictors].values, label=dtrain[target].values)

cvresult = xgb.cv(xgb_param, xgtrain, num_boost_round=alg.get_params()['n_estimators'], nfold=cv_folds,

metrics='auc', early_stopping_rounds=early_stopping_rounds, show_progress=False)

alg.set_params(n_estimators=cvresult.shape[0])

#Fit the algorithm on the data

alg.fit(dtrain[predictors], dtrain['Disbursed'],eval_metric='auc')

#Predict training set:

dtrain_predictions = alg.predict(dtrain[predictors])

dtrain_predprob = alg.predict_proba(dtrain[predictors])[:,1]

#Print model report:

print "\nModel Report"

print "Accuracy : %.4g" % metrics.accuracy_score(dtrain['Disbursed'].values, dtrain_predictions)

print "AUC Score (Train): %f" % metrics.roc_auc_score(dtrain['Disbursed'], dtrain_predprob)

feat_imp = pd.Series(alg.booster().get_fscore()).sort_values(ascending=False)

feat_imp.plot(kind='bar', title='Feature Importances')

plt.ylabel('Feature Importance Score')

这个函数和GBM中使用的有些许不同。不过本文章的重点是讲解重要的概念，而不是写代码。如果哪里有不理解的地方，请在下面评论，不要有压力。注意xgboost的sklearn包没有“feature_importance”这个量度，但是get_fscore()函数有相同的功能。参数调优的一般方法。我们会使用和GBM中相似的方法。需要进行如下步骤：

选择较高的学习速率(learning rate)。一般情况下，学习速率的值为0.1。但是，对于不同的问题，理想的学习速率有时候会在0.05到0.3之间波动。选择对应于此学习速率的理想决策树数量。XGBoost有一个很有用的函数“cv”，这个函数可以在每一次迭代中使用交叉验证，并返回理想的决策树数量。

2. 对于给定的学习速率和决策树数量，进行决策树特定参数调优(max_depth, min_child_weight, gamma, subsample, colsample_bytree)。在确定一棵树的过程中，我们可以选择不同的参数，待会儿我会举例说明。

3. xgboost的正则化参数的调优。(lambda, alpha)。这些参数可以降低模型的复杂度，从而提高模型的表现。

4. 降低学习速率，确定理想参数。咱们一起详细地一步步进行这些操作。第一步：确定学习速率和tree_based 参数调优的估计器数目。为了确定boosting 参数，我们要先给其它参数一个初始值。咱们先按如下方法取值：

1、max_depth = 5 :这个参数的取值最好在3-10之间。我选的起始值为5，但是你也可以选择其它的值。起始值在4-6之间都是不错的选择。

2、min_child_weight = 1:在这里选了一个比较小的值，因为这是一个极不平衡的分类问题。因此，某些叶子节点下的值会比较小。

3、gamma = 0: 起始值也可以选其它比较小的值，在0.1到0.2之间就可以。这个参数后继也是要调整的。

4、subsample,colsample_bytree = 0.8: 这个是最常见的初始值了。典型值的范围在0.5-0.9之间。

5、scale_pos_weight = 1: 这个值是因为类别十分不平衡。

注意哦，上面这些参数的值只是一个初始的估计值，后继需要调优。这里把学习速率就设成默认的0.1。然后用xgboost中的cv函数来确定最佳的决策树数量。前文中的函数可以完成这个工作。#Choose all predictors except target  IDcols

predictors = [x for x in train.columns if x not in [target,IDcol]]

xgb1 = XGBClassifier(

learning_rate =0.1,

n_estimators=1000,

max_depth=5,

min_child_weight=1,

gamma=0,

subsample=0.8,

colsample_bytree=0.8,

objective= 'binary:logistic',

nthread=4,

scale_pos_weight=1,

seed=27)

modelfit(xgb1, train, predictors)

从输出结果可以看出，在学习速率为0.1时，理想的决策树数目是140。这个数字对你而言可能比较高，当然这也取决于你的系统的性能。注意：在AUC(test)这里你可以看到测试集的AUC值。但是如果你在自己的系统上运行这些命令，并不会出现这个值。因为数据并不公开。这里提供的值仅供参考。生成这个值的代码部分已经被删掉了。喎?"/kf/ware/vc/" target="_blank" class="keylink"vcD4NCjwvYmxvY2txdW90ZT4NCjxoMSBpZD0="第二步-maxdepth-和-minweight-参数调优"第二步： max_depth 和 min_weight 参数调优我们先对这两个参数调优，是因为它们对最终结果有很大的影响。首先，我们先大范围地粗调参数，然后再小范围地微调。

注意：在这一节我会进行高负荷的栅格搜索(grid search)，这个过程大约需要15-30分钟甚至更久，具体取决于你系统的性能。你也可以根据自己系统的性能选择不同的值。param_test1 = {

'max_depth':range(3,10,2),

'min_child_weight':range(1,6,2)

}

gsearch1 = GridSearchCV(estimator = XGBClassifier(         learning_rate =0.1, n_estimators=140, max_depth=5,

min_child_weight=1, gamma=0, subsample=0.8,             colsample_bytree=0.8,

objective= 'binary:logistic', nthread=4,     scale_pos_weight=1, seed=27),

param_grid = param_test1,     scoring='roc_auc',n_jobs=4,iid=False, cv=5)

gsearch1.fit(train[predictors],train[target])

gsearch1.grid_scores_, gsearch1.best_params_,     gsearch1.best_score_

文章题目：auc函数python auc函数可以用于无监督么
分享地址：http://6mz.cn/article/hghegc.html