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