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