El GBM ligero es una estructura rápida, apropiada y impulso de gradiente, que depende del cálculo del árbol de elección, y que se utiliza para el posicionamiento, la caracterización y otras numerosas asignaciones de la IA.
Dado que depende de los cálculos del árbol, divide la hoja del árbol con el mejor ajuste, mientras que otros cálculos de impulso dividen la profundidad del árbol de manera astuta o nivelada en oposición a la hoja. Así que cuando se desarrolla en una hoja similar en Light GBM, el cálculo por hojas puede disminuir más desgracias que el cálculo por niveles y, por lo tanto, produce una precisión mucho mayor que puede ser lograda de vez en cuando por cualquiera de los cálculos de impulso actuales. De la misma manera, es sorprendentemente extremadamente rápido, de ahí la palabra ‘Luz’.
Antes hay un retrato diagramático de los creadores del GBM de la Luz para aclarar la distinción, obviamente.
Las partes perspicaces de las hojas llevan a un aumento de la complejidad y pueden provocar un exceso de adaptación, y tiende a abrumarse al indicar otro parámetro de máxima profundidad que determina la profundidad a la que se producirá la separación.
Debajo, veremos los medios para introducir el GBM de luz y ejecutar un modelo que lo utilice. Contrastaremos los resultados con los resultados de XGBOOST demostrando que se debe tomar el GBM de Luz de una manera “LIGERA”.
Danos la oportunidad de echar un vistazo a una parte de los beneficios de la Luz GBM.
Puntos de interés de la Luz GBM
Un ritmo de preparación más rápido y una mayor productividad: El GBM ligero utiliza el cálculo basado en el histograma, es decir, coloca las incesantes estimaciones de los componentes en contenedores discretos que adjuntan la estrategia de preparación.
Menor uso de la memoria: Sustituye las cualidades consistentes a los receptáculos discretos, lo que conlleva un menor uso de la memoria.
Precisión preferible a algún otro cálculo de impulso: Crea árboles considerablemente más desconcertantes al seguir un enfoque de división de hojas en vez de un enfoque de nivelación que es el factor fundamental para lograr una mayor exactitud. En cualquier caso, a veces puede llevar a un sobreajuste del que se puede prescindir al establecer el parámetro max_depth.
Similitud con los grandes conjuntos de datos: Está equipado para funcionar de manera similar con enormes conjuntos de datos con una disminución crítica en la preparación de un tiempo cuando se contrasta con XGBOOST.
Se mantiene el aprendizaje paralelo.
Supongo que lo más probable es que te hayas entusiasmado con los beneficios del GBM ligero. Denos ahora la oportunidad de continuar introduciendo la biblioteca en nuestro sistema.
Instalación de la luz GBM
Para Windows
Usando Visual Studio (o MSBuild)
-Instalar git para windows, cmake y MS Build (No necesitas el MSbuild si ya instalas Visual Studio).
-Corre siguiendo la orden:
git clon –recursivo https://github.com/Microsoft/LightGBM
cd LightGBM
mkdir build
construcción de cd
cmake -DCMAKE_GENERATOR_PLATFORM=x64 ..
hacer –construir . –target ALL_BUILD –configurar Liberación
El exe y el dll estarán en la carpeta LightGBM/Release.
Usando MinGW64-Install
git para windows cmake y MinGW64.
-Ejecute el siguiente comando:
git clon –recursivo https://github.com/Microsoft/LightGBM
cd LightGBM
mkdir build
construcción de cd
cmake -G “MinGW Makefiles” ..
mingw32-make.exe -j4
El exe y el dll estarán en la carpeta LightGBM/.
Para Linux
El GBM ligero utiliza cmake para construir. Corre siguiendo:
git clon –recursivo https://github.com/Microsoft/LightGBM
cd LightGBM
mkdir build
construcción de cd
hacer…
hacer -j4
Para OSX
LightGBM depende de OpenMP para la compilación, lo cual no está soportado por Apple Clang. Por favor, usa gcc/g++ en su lugar.
-Ejecuta lo siguiente:
brew install cmake
brew install gcc –sin-multilib
git clon –recursivo https://github.com/Microsoft/LightGBM
cd LightGBM
mkdir build
construcción de cd
hacer…
hacer -j4
Ahora, antes de sumergirnos de lleno en la construcción de nuestro primer modelo de GBM ligero, veamos algunos de los parámetros del GBM ligero para comprender sus procedimientos subyacentes.
Parámetros importantes de la luz GBM
tarea : valor por defecto = tren ; opciones = tren , predicción ; Especifica la tarea que deseamos realizar que es o bien tren o predicción.
aplicación: default=regresión, type=enum, options=opciones :
regresión : realizar la tarea de regresión
binario : Clasificación binaria
multiclase: Clasificación de multiclase
lambdarank : aplicación del lambdarank
datos: tipo=cadena; datos de entrenamiento, LightGBM entrenará a partir de estos datos
num_iterations: número de iteraciones de refuerzo a realizar ; default=100; type=int
num_leaves : número de hojas en un árbol ; por defecto = 31 ; tipo =int
dispositivo : default= cpu ; opciones = gpu,cpu. Dispositivo en el que queremos entrenar a nuestro modelo. Elija la GPU para un entrenamiento más rápido.
profundidad máxima: Especificar la máxima profundidad a la que crecerá el árbol. Este parámetro se utiliza para tratar la sobrecarga.
min_data_en_la_hoja: Número mínimo de datos en una hoja.
fracción_de_características: default=1 ; especifica la fracción de características a tomar para cada iteración
bagging_fraction: default=1 ; especifica la fracción de datos a utilizar en cada iteración y se utiliza generalmente para acelerar el entrenamiento y evitar la sobrecarga.
min_gain_to_split: default=.1 ; min gain to perform splitting
max_bin : número máximo de cubos para poner en el cubo los valores de las características.
min_data_in_bin : min número de datos en un bin
num_threads: default=OpenMP_default, type=int ;Número de hilos para GBM ligero.
label : type=string ; especificar la columna de la etiqueta
categorical_feature : type=string ; especifique las características categóricas que queremos usar para entrenar nuestro modelo
num_class: default=1 ; type=int ; usado sólo para la clasificación multiclase
LightGBM contra XGBoost
Así que ahora qué tal si contrastamos LightGBM y XGBoost aplicando ambos cálculos a un conjunto de datos y después mirando la exposición.
Aquí estamos utilizando un conjunto de datos que contiene los datos de personas de diferentes naciones. Nuestro objetivo es anticipar si un individuo hace <=50k o >50k anuales en el lugar de los otros datos accesibles. El conjunto de datos comprende 32561 percepciones y 14 aspectos destacados que representan a las personas.
Aquí está la conexión con el conjunto de datos: http://archive.ics.uci.edu/ml/datasets/Grown-up.
Experimente el conjunto de datos para tener un instinto apropiado acerca de los factores indicadores, de manera que pueda comprender el código que está debajo de manera apropiada.
#importando bibliotecas estándar
importar numpy como np
importar pandas como pd
de la serie de importación de pandas, DataFrame
#Importa lightgbm y xgboost
importar lightgbm como lgb
importar xgboost como xgb
#cargando nuestro conjunto de datos de entrenamiento ‘adult.csv’ con nombre ‘datos’ usando pandas
data=pd.read_csv(‘adult.csv’,header=None)
#Asignando nombres a las columnas
data.columns=[‘edad’,’clase’,’fnlwgt’,’educación’,’educación-num’,’estado_marital’,’ocupación’,’relación’,’raza’,’sexo’,’ganancia_capital’,’pérdida_capital’,’horas_por_semana’,’país_nativo’,’ingresos’]
#vistazo del conjunto de datos
data.head()
# Etiqueta que codifica nuestra variable objetivo
de sklearn.preprocessing import LabelEncoder,OneHotEncoder
l=LabelEncoder()
l.fit(datos.ingresos)
l.clases_
Datos.Ingreso=Serie(l.transform(datos.Ingreso)) #label codificando nuestra variable objetivo
data.Income.value_counts()
#Una codificación en caliente de las características categóricas
one_hot_workclass=pd.get_dummies(data.workclass)
one_hot_education=pd.get_dummies(data.education)
one_hot_marital_Status=pd.get_dummies(data.marital_Status)
one_hot_occupation=pd.get_dummies(data.occupation)
one_hot_relationship=pd.get_dummies(data.relationship)
one_hot_race=pd.get_dummies(data.race)
one_hot_sex=pd.get_dummies(data.sex)
one_hot_native_country=pd.get_dummies(data.native_country)
# removiendo las características categóricas
data.drop([‘clase de trabajo’,’educación’,’estado_marital’,’ocupación’,’relación’,’raza’,’sexo’,’país_nativo’],axis=1,inplace=True)
#Fusionando una característica codificada en caliente con nuestro conjunto de datos…
data=pd.concat([datos,una_clase_de_trabajo_peligrosa,una_educación_peligrosa,un_estado_marital_peligroso,una_ocupación_peligrosa,una_relación_peligrosa,una_raza_peligrosa,un_sexo_peligroso,un_país_nativo_peligroso],axis=1)
# removiendo las columnas de dulzura
_, i = np.unique(data.columns, return_index=True)
data=data.iloc[:, i]
#Aquí nuestra variable objetivo es ‘Ingreso’ con valores como 1 o 0.
#Separando nuestros datos en características del conjunto de datos x y nuestro conjunto de datos y objetivos…
x=data.drop(‘Ingreso’,axis=1)
y=datos.Ingresos
#Imputando valores perdidos en nuestra variable objetivo
y.fillna(y.mode()[0],inplace=True)
#Ahora dividiendo nuestro conjunto de datos en pruebas y entrenamiento…
de sklearn.model_selection importar train_test_split
x_tren,x_test,y_tren,y_test=tren_test_split(x,y,test_size=.3)
# Aplicando xgboost
#Los datos se almacenan en un objeto DMatrix
#label se utiliza para definir nuestra variable de resultado
dtrain=xgb.DMatrix(x_train,label=y_train)
dtest=xgb.DMatrix(x_test)
#estableciendo los parámetros para xgboost
parameters={‘max_depth’:7, ‘eta’:1, ‘silent’:1,’objective’:’binary:logistic’,’eval_metric’:’auc’,’learning_rate’:.05}
#Entrenando a nuestro modelo
num_round=50
de la fecha de importación de la fecha de importación
start = datetime.now()
xg=xgb.train(parameters,dtrain,num_round)
stop = datetime.now()
#Tiempo de ejecución del modelo
execution_time_xgb = stop-start
execution_time_xgb
#datetime.timedelta( , , ) representación => (días , segundos , microsegundos)
#ahora predicen nuestro modelo en el set de pruebas
ypred=xg.predict(dtest)
ypred
#Convirtiendo las probabilidades en 1 o 0
para i en el rango(0,9769):
si ypred[i]>=.5: # estableciendo el umbral en .5
ypred[i]=1
…sino..:
ypred[i]=0
#Calculando la precisión de nuestro modelo
de sklearn.metrics import accuracy_score
accuracy_xgb = accuracy_score(y_test,ypred)
accuracy_xgb
# Light GBM
train_data=lgb.Dataset(x_train,label=y_train)
#Parámetros de ajuste para lightgbm
param = {‘num_leaves’:150, ‘objetivo’:’binario’,’max_depth’:7,’learning_rate’:.05,’max_bin’:200}
param[‘metric’] = [‘auc’, ‘binary_logloss’]
#Aquí hemos puesto max_depth en xgb y LightGBM a 7 para tener una comparación justa entre los dos.
#Entrenando a nuestra modelo usando gbm de luz
num_round=50
start=datetime.now()
lgbm=lgb.train(param,train_data,num_round)
stop=datetime.now()
#Tiempo de ejecución del modelo
execution_time_lgbm = stop-start
execution_time_lgbm
#Predicando en el set de pruebas
ypred2=lgbm.predict(x_test)
ypred2[0:5] # mostrando las primeras 5 predicciones
#convirtiendo las probabilidades en 0 o 1
para i en el rango(0,9769):
si ypred2[i]>=.5: # estableciendo el umbral en .5
ypred2[i]=1
…sino..:
ypred2[i]=0
#Calculando la precisión
accuracy_lgbm = accuracy_score(ypred2,y_test)
accuracy_lgbm
y_test.value_counts()
de la importación de sklearn.metrics roc_auc_score
#calculando roc_auc_score para xgboost
auc_xgb = roc_auc_score(y_test,ypred)
auc_xgb
#calculando roc_auc_score para gbm de luz.
auc_lgbm = roc_auc_score(y_test,ypred2)
auc_lgbm comparison_dict = {‘puntuación de precisión’:(accuracy_lgbm,accuracy_xgb),’puntuación de auc’:(auc_lgbm,auc_xgb),’tiempo de ejecución’:(execution_time_lgbm,execution_time_xgb)}
#Creando un marco de datos ‘comparison_df’ para comparar el rendimiento de Lightgbm y xgb.
compare_df = DataFrame(compare_dict)
comparison_df.index= [‘LightGBM’,’xgboost’]
comparación_df
Comparación de rendimiento