O GBM leve é uma estrutura rápida, apropriada e de elite, que aumenta a inclinação dependendo do cálculo da árvore de escolha, utilizada para posicionamento, caracterização e inúmeras outras atribuições de IA.

Como depende dos cálculos da árvore escolhida, ela divide o conhecimento das folhas da árvore com o melhor ajuste, enquanto outros cálculos de aumento dividem a profundidade da árvore de forma astuta ou perspicaz, em oposição ao conhecimento das folhas. Assim, ao se desenvolver em uma folha semelhante em Light GBM, o cálculo em nível de folha pode diminuir mais infortúnios do que o cálculo em nível e subseqüentemente trazer uma precisão muito melhor que pode ser realizada de vez em quando por qualquer um dos cálculos de boosting atuais. Da mesma forma, é chocantemente extremamente rápido, daí a palavra ‘Light’.

Antes é um retrato esquemático dos criadores do GBM da Luz para esclarecer a distinção, obviamente.

As peças de folha de massa levam a um aumento na complexidade e podem provocar um superajuste e tendem a ser sobrecarregadas pela indicação de outro parâmetro de max-profundidade que determina a profundidade a que a separação irá acontecer.

Abaixo, veremos os meios para introduzir o Light GBM e executar um modelo que o utilize. Vamos contrastar os resultados com os resultados do XGBOOST, demonstrando que você deve tomar o Light GBM de uma ‘maneira leve’.

Dê-nos uma chance de dar uma olhada em uma parte dos benefícios do GBM Light.

Pontos de interesse do GBM Leve

Maior velocidade de preparação e maior produtividade: O GBM leve utiliza cálculo baseado em histogramas, ou seja, ele empilha incessantemente a estima dos componentes em recipientes discretos que anexam a estratégia de preparação.

Menor uso de memória: Substitui qualidades consistentes por receptáculos discretos que trazem menor uso de memória.

Precisão preferível a algum outro cálculo de impulso: Cria árvores consideravelmente mais perplexas ao seguir uma abordagem de divisão das folhas com astúcia, em oposição a uma abordagem nivelada, que é o fator fundamental para se obter maior precisão. Em qualquer caso, ele pode, às vezes, levar a sobreajustes que podem ser afastados através do ajuste do parâmetro max_depth.

Similaridade com Datasets Enormes: É equipado para realizar similarmente grande com enormes conjuntos de dados com uma diminuição crítica na preparação de um tempo quando comparado com o XGBOOST.

Aprendizagem paralela mantida.

Eu suponho que é mais provável que você não tenha sido amparado pelos benefícios do GBM Light. Dê-nos agora uma chance de continuar a introduzir a biblioteca em nosso sistema.

Instalando o GBM leve

Para Windows

Usando o Visual Studio (ou MSBuild)

-Instale o git para windows, cmake e MS Build (Não precisa do MSbuild se você já instalou o Visual Studio).

-Executar seguindo o comando:

git clone –recursivo https://github.com/Microsoft/LightGBM

cd LightGBM

mkdir build

cd construir

cmake -DCMAKE_GENERATOR_PLATFORM=x64 …

cmake — construir . –target ALL_BUILD –config Release

O exe e a dll estarão na pasta LightGBM/Release.

Usando MinGW64-Install
 git para windows cmake e MinGW64.
-Executar seguindo o comando:

git clone –recursivo https://github.com/Microsoft/LightGBM

cd LightGBM

mkdir build

cd construir

cmake -G “MinGW Makefiles” …

mingw32-make.exe -j4

O exe e a dll estarão na pasta LightGBM/.

Para Linux

O GBM leve utiliza o cmake para construir. Execute o seguinte:

git clone –recursivo https://github.com/Microsoft/LightGBM

cd LightGBM

mkdir build

cd construir

cmake …

marca -j4

Para OSX

O LightGBM depende do OpenMP para compilação, que não é suportado pela Apple Clang. Por favor, use gcc/g+++ em seu lugar.
-Executar o seguinte:

instalação de cerveja cmake

instalar gcc – sem multilíbitos

git clone –recursivo https://github.com/Microsoft/LightGBM

cd LightGBM

mkdir build

cd construir

cmake …

marca -j4

Agora, antes de mergulharmos de cabeça na construção do nosso primeiro modelo de GBM Light, vamos analisar alguns dos parâmetros do GBM Light para termos uma compreensão dos seus procedimentos subjacentes.

Parâmetros importantes do GBM leve

task : valor padrão = trem ; opções = trem , previsão ; Especifica a tarefa que desejamos executar que é ou trem ou previsão.

aplicação: padrão=regressão, digite=enum, opções= opções :

regressão : realizar tarefa de regressão

binário : Classificação binária

multiclasse: Classificação Multiclasse

lambdarank : aplicação de lambdarank

dados: type=string; dados de treinamento , LightGBM irá treinar a partir destes dados

num_iterations: número de iterações a serem realizadas; padrão=100; type=int

num_leaves : número de folhas em uma árvore ; padrão = 31 ; tipo =int

dispositivo : padrão= cpu ; opções = gpu,cpu. Dispositivo sobre o qual queremos treinar nosso modelo. Escolha a GPU para um treinamento mais rápido.

max_depth: Especifique a profundidade máxima para qual árvore irá crescer. Este parâmetro é usado para lidar com o superajuste.

min_data_in_leaf: Número mínimo de dados em uma folha.

feature_fraction: default=1 ; especifica a fração de características a ser tomada para cada iteração

bagging_fraction: default=1 ; especifica a fração de dados a ser usada para cada iteração e é geralmente usada para acelerar o treinamento e evitar o excesso de ajustes.

min_gain_to_split: default=.1 ; min gain to perform splitting

max_bin : número máximo de caixas para baldear os valores das características.

min_data_in_bin : número min de dados em um bin

num_threads: padrão=OpenMP_default, digite=int ;Número de threads para GBM leve.

label : type=string ; especifique a coluna label

categorical_feature : type=string ; especifique as características categóricas que queremos utilizar para o treinamento do nosso modelo

num_class: padrão=1 ; digite=int ; usado somente para classificação multiclasse

LightGBM versus XGBoost

Então agora que tal contrastarmos LightGBM e XGBoost aplicando ambos os cálculos a um conjunto de dados e olhando em seguida para a exposição.

Aqui estamos utilizando um conjunto de dados que contém os dados sobre pessoas de diferentes nações. Nosso objetivo é antecipar se um indivíduo faz <=50k ou >50k anualmente no local dos outros dados acessíveis. O conjunto de dados é composto por 32561 percepções e 14 destaques que retratam as pessoas.

Aqui está a conexão com o conjunto de dados: http://archive.ics.uci.edu/ml/datasets/Grown-up.

Experimente o conjunto de dados para ter um instinto apropriado sobre os fatores indicadores, de modo que você possa compreender o código abaixo de forma apropriada.

#importando bibliotecas padrão

importação numérica como np

pandas de importação como pd

da série pandas import, DataFrame

#importar lightgbm e xgboost

importação de lightgbm como lgb

importação xgboost como xgb

#carregando nosso conjunto de dados de treinamento ‘adult.csv’ com nome ‘dados’ usando pandas

data=pd.read_csv(‘adult.csv’,header=None)

#Atribuição de nomes às colunas

data.columns=[‘age’,’workclass’,’fnlwgt’,’education’,’education-num’,’marital_Status’,’occupation’,’relationship’,’race’,’sex’,’capital_gain’,’capital_loss’,’hours_per_week’,’native_country’,’Income’]

#glimpse do conjunto de dados

data.head()

# Rótulo Codificando nossa variável alvo

do sklearn.preprocessing importação LabelEncoder,OneHotEncoder

l=LabelEncoder()

l.fit(data.Income)

l.classes_

data.Income=Série(l.transform(data.Income))  #label codificando nossa variável alvo

data.Income.value_counts()

#Uma Codificação Quente das 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)

#Removendo características categóricas

data.drop([[‘classe de trabalho’,’educação’,’estado civil’,’ocupação’,’relacionamento’,’raça’,’sexo’,’país_nativo’],eixo=1,inplace=Verdade)

#Fusão de uma funcionalidade codificada a quente com o nosso conjunto de dados ‘data

data=pd.concat([data,one_hot_workclass,one_hot_education,one_hot_marital_Status,one_hot_occupation,one_hot_relationship,one_hot_race,one_hot_sex,one_hot_native_country],axis=1)

#Remover colunas dulpicate

 _, i = np.unique(data.columns, return_index=True)

data=data.iloc[:, i]

#Aqui nossa variável alvo é ‘Renda’ com valores de 1 ou 0. 

#Separando nossos dados em conjunto de dados de características x e nosso conjunto de dados alvo y

x=data.drop(‘Rendimento’,eixo=1)

y=dados.rendimento

#Imputando valores ausentes em nossa variável alvo

y.fillna(y.mode()[0],inplace=True)

#Dividindo agora nosso conjunto de dados em teste e trem

de sklearn.model_selection import train_test_split

x_train,x_test,y_train,y_test=train_test=split(x,y,test_size=.3)

#Aplicando o xgboost

#Os dados são armazenados em um objeto DMatrix

#label é usado para definir nossa variável de resultado

dtrain=xgb.DMatrix(x_train,label=y_train)

dtest=xgb.DMatrix(x_test)

#parâmetros de configuração para xgboost

parameters={‘max_depth’:7, ‘eta’:1, ‘silent’:1,’objective’:’binary:logistic’,’eval_metric’:’auc’,’learning_rate’:.05}

#treinando nosso modelo

num_round=50

a partir da data/hora de importação

início = data/hora.now()

xg=xgb.train(parâmetros,dtrain,num_round)

stop = datetime.now()

#Tempo de execução do modelo

execution_time_xgb = stop-start

execution_time_xgb

#datetime.timedelta( , , ) representação => (dias , segundos , microssegundos)

#previsão do nosso modelo em conjunto de teste

ypred=xg.predict(dtest)

ypred

#Convertendo probabilidades em 1 ou 0

para i na faixa de i(0,9769):

    if ypred[i]>=.5: # definindo limiar para .5

       ypred[i]=1

    senão:

       ypred[i]=0 

#Calculando a precisão do nosso modelo

do sklearn.metrics import accuracy_score

accuracy_xgb = accuracy_score(y_test,ypred)

precisão_xgb

# GBM Leve

train_data=lgb.Dataset(x_train,label=y_train)

#parâmetros de ajuste para lightgbm

param = {‘num_leaves’:150, ‘objective’:’binary’,’max_depth’:7,’learning_rate’:.05,’max_bin’:200}

param[‘métrica’] = [‘auc’, ‘binary_logloss’]

#Aqui fixamos max_depth em xgb e LightGBM para 7 para ter uma comparação justa entre os dois.

#treinando nosso modelo usando gbm leve

num_round=50

start=datetime.now()

lgbm=lgb.train(param,train_data,num_round)

stop=datetime.now()

#Tempo de execução do modelo

execution_time_lgbm = stop-start

execution_time_lgbm

#previsão no conjunto de teste

ypred2=lgbm.predict(x_test)

ypred2[0:5] # mostrando as 5 primeiras previsões

#convertendo probabilidades em 0 ou 1

para i na faixa de i(0,9769):

    if ypred2[i]>=.5: # definindo limiar para .5

       ypred2[i]=1

    senão: 

       ypred2[i]=0

#Calculando a precisão

accuracy_lgbm = accuracy_score(ypred2,y_test)

precisão_lgbm

y_test.value_counts()

do sklearn.metrics importação roc_auc_score

#calculating roc_auc_score para xgboost

auc_xgb = roc_auc_score(y_test,ypred)

auc_xgb

#calculating roc_auc_score for light gbm.

auc_lgbm = roc_auc_score(y_test,ypred2)

auc_lgbm comparison_dict = {‘accuracy score’:(accuracy_lgbm,accuracy_xgb),’auc score’:(auc_lgbm,auc_xgb),’execution time’:(execution_time_lgbm,execution_time_xgb)}

#Criando um dataframe ‘comparison_df’ para comparar o desempenho do Lightgbm e do xgb.

comparison_df = DataFrame(comparison_dict)

comparison_df.index= [‘LightGBM’,’xgboost’]

comparação_df

Comparação de desempenho