Melhorando o desempenho dos modelos de ML

Melhoria de desempenho com conjuntos

Os conjuntos podem nos dar um impulso no resultado do aprendizado de máquina, combinando vários modelos. Basicamente, os modelos de conjunto consistem em vários modelos de aprendizado supervisionado treinados individualmente e seus resultados são combinados de várias maneiras para obter melhor desempenho preditivo em comparação com um único modelo. Os métodos de conjunto podem ser divididos nos seguintes dois grupos -

Métodos de conjunto sequencial

Como o nome indica, nesse tipo de método de conjunto, os alunos básicos são gerados sequencialmente. A motivação de tais métodos é explorar a dependência entre os alunos básicos.

Métodos de conjunto paralelo

Como o nome indica, nesse tipo de método de conjunto, os alunos básicos são gerados em paralelo. A motivação de tais métodos é explorar a independência entre os alunos básicos.

Métodos de aprendizagem do conjunto

A seguir estão os métodos de aprendizagem de conjunto mais populares, ou seja, os métodos para combinar as previsões de diferentes modelos -

Ensacamento

O termo bagging também é conhecido como agregação de bootstrap. Em métodos de ensacamento, o modelo de conjunto tenta melhorar a precisão da predição e diminuir a variância do modelo combinando predições de modelos individuais treinados em amostras de treinamento geradas aleatoriamente. A predição final do modelo ensemble será dada pelo cálculo da média de todas as predições dos estimadores individuais. Um dos melhores exemplos de métodos de ensacamento são as florestas aleatórias.

Boosting

No método de boosting, o princípio principal da construção do modelo de conjunto é construí-lo incrementalmente, treinando cada estimador de modelo base sequencialmente. Como o nome sugere, ele basicamente combina vários alunos semanais, treinados sequencialmente em várias iterações de dados de treinamento, para construir um conjunto poderoso. Durante o treinamento de alunos da base semanal, pesos mais altos são atribuídos aos alunos que foram classificados incorretamente anteriormente. O exemplo de método de boosting é AdaBoost.

Votação

Neste modelo de aprendizagem por conjunto, vários modelos de diferentes tipos são construídos e algumas estatísticas simples, como calcular a média ou mediana, etc., são usadas para combinar as previsões. Essa previsão servirá como entrada adicional para o treinamento para fazer a previsão final.

Algoritmos de ensemble de ensacamento

A seguir estão três algoritmos de conjunto de ensacamento -

Árvore de decisão ensacada

Como sabemos que os métodos de ensemble de bagging funcionam bem com os algoritmos de alta variância e, neste caso, o melhor é o algoritmo de árvore de decisão. Na seguinte receita Python, vamos construir um modelo ensemble de árvore de decisão usando a função BaggingClassifier do sklearn com DecisionTreeClasifier (um algoritmo de árvores de classificação e regressão) no conjunto de dados de diabetes dos índios Pima.

Primeiro, importe os pacotes necessários da seguinte forma -

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier

Agora, precisamos carregar o conjunto de dados de diabetes Pima como fizemos nos exemplos anteriores -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Em seguida, forneça a entrada para validação cruzada de 10 vezes da seguinte forma -

seed = 7
kfold = KFold(n_splits=10, random_state=seed)
cart = DecisionTreeClassifier()

Precisamos fornecer o número de árvores que vamos construir. Aqui estamos construindo 150 árvores -

num_trees = 150

Em seguida, construa o modelo com a ajuda do seguinte script -

model = BaggingClassifier(base_estimator=cart, n_estimators=num_trees, random_state=seed)

Calcule e imprima o resultado da seguinte forma -

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Resultado

0.7733766233766234

A saída acima mostra que obtivemos cerca de 77% de precisão em nosso modelo de classificador de árvore de decisão ensacado.

Floresta Aleatória

É uma extensão de árvores de decisão ensacadas. Para classificadores individuais, as amostras do conjunto de dados de treinamento são obtidas com substituição, mas as árvores são construídas de forma a reduzir a correlação entre elas. Além disso, um subconjunto aleatório de recursos é considerado para escolher cada ponto de divisão em vez de escolher avidamente o melhor ponto de divisão na construção de cada árvore.

Na seguinte receita do Python, vamos construir um modelo de conjunto de floresta aleatório ensacado usando a classe RandomForestClassifier do sklearn no conjunto de dados de diabetes dos índios Pima.

Primeiro, importe os pacotes necessários da seguinte forma -

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier

Agora, precisamos carregar o conjunto de dados de diabetes Pima, como fizemos nos exemplos anteriores -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Em seguida, forneça a entrada para validação cruzada de 10 vezes da seguinte forma -

seed = 7
kfold = KFold(n_splits=10, random_state=seed)

Precisamos fornecer o número de árvores que vamos construir. Aqui, estamos construindo 150 árvores com pontos de divisão escolhidos a partir de 5 recursos -

num_trees = 150
max_features = 5

Em seguida, construa o modelo com a ajuda do seguinte script -

model = RandomForestClassifier(n_estimators=num_trees, max_features=max_features)

Calcule e imprima o resultado da seguinte forma -

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Resultado

0.7629357484620642

A saída acima mostra que obtivemos cerca de 76% de precisão de nosso modelo de classificador de floresta aleatório ensacado.

Árvores Extra

É outra extensão do método de conjunto de árvore de decisão ensacada. Neste método, as árvores aleatórias são construídas a partir das amostras do conjunto de dados de treinamento.

Na seguinte receita Python, vamos construir um modelo de conjunto de árvore extra usando a classe ExtraTreesClassifier do sklearn no conjunto de dados de diabetes dos índios Pima.

Primeiro, importe os pacotes necessários da seguinte forma -

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import ExtraTreesClassifier

Agora, precisamos carregar o conjunto de dados de diabetes Pima, como fizemos nos exemplos anteriores -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Em seguida, forneça a entrada para validação cruzada de 10 vezes da seguinte forma -

seed = 7
kfold = KFold(n_splits=10, random_state=seed)

Precisamos fornecer o número de árvores que vamos construir. Aqui, estamos construindo 150 árvores com pontos de divisão escolhidos a partir de 5 recursos -

num_trees = 150
max_features = 5

Em seguida, construa o modelo com a ajuda do seguinte script -

model = ExtraTreesClassifier(n_estimators=num_trees, max_features=max_features)

Calcule e imprima o resultado da seguinte forma -

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Resultado

0.7551435406698566

A saída acima mostra que obtivemos cerca de 75,5% de precisão do nosso modelo de classificador de árvores extras embaladas.

Impulsionando algoritmos de conjunto

A seguir estão os dois algoritmos de conjunto de reforço mais comuns -

AdaBoost

É um dos algoritmos de conjunto de reforço de maior sucesso. A principal chave desse algoritmo está na maneira como eles atribuem pesos às instâncias no conjunto de dados. Devido a isso, o algoritmo precisa prestar menos atenção às instâncias enquanto constrói modelos subsequentes.

Na seguinte receita do Python, vamos construir o modelo de conjunto Ada Boost para classificação usando a classe AdaBoostClassifier do sklearn no conjunto de dados de diabetes dos índios Pima.

Primeiro, importe os pacotes necessários da seguinte forma -

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import AdaBoostClassifier

Agora, precisamos carregar o conjunto de dados de diabetes Pima, como fizemos nos exemplos anteriores -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Em seguida, forneça a entrada para validação cruzada de 10 vezes da seguinte forma -

seed = 5
kfold = KFold(n_splits=10, random_state=seed)

Precisamos fornecer o número de árvores que vamos construir. Aqui, estamos construindo 150 árvores com pontos de divisão escolhidos a partir de 5 recursos -

num_trees = 50

Em seguida, construa o modelo com a ajuda do seguinte script -

model = AdaBoostClassifier(n_estimators=num_trees, random_state=seed)

Calcule e imprima o resultado da seguinte forma -

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Resultado

0.7539473684210527

A saída acima mostra que obtivemos cerca de 75% de precisão em nosso modelo de conjunto do classificador AdaBoost.

Estocástico Gradient Boosting

Também é chamado de Máquinas de Gradient Boosting. Na seguinte receita do Python, vamos construir o modelo Stochastic Gradient Boostingensemble para classificação usando a classe GradientBoostingClassifier do sklearn no conjunto de dados de diabetes dos índios Pima.

Primeiro, importe os pacotes necessários da seguinte forma -

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import GradientBoostingClassifier

Agora, precisamos carregar o conjunto de dados de diabetes Pima, como fizemos nos exemplos anteriores -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Em seguida, forneça a entrada para validação cruzada de 10 vezes da seguinte forma -

seed = 5
kfold = KFold(n_splits=10, random_state=seed)

Precisamos fornecer o número de árvores que vamos construir. Aqui, estamos construindo 150 árvores com pontos de divisão escolhidos a partir de 5 recursos -

num_trees = 50

Em seguida, construa o modelo com a ajuda do seguinte script -

model = GradientBoostingClassifier(n_estimators=num_trees, random_state=seed)

Calcule e imprima o resultado da seguinte forma -

results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

Resultado

0.7746582365003418

A saída acima mostra que obtivemos cerca de 77,5% de precisão de nosso modelo de conjunto do classificador Gradient Boosting.

Algoritmos de conjunto de votação

Conforme discutido, a votação primeiro cria dois ou mais modelos autônomos a partir do conjunto de dados de treinamento e, em seguida, um classificador de votação irá envolver o modelo junto com a média das previsões do submodelo sempre que novos dados necessários.

Na seguinte receita do Python, vamos construir o modelo Voting ensemble para classificação usando a classe VotingClassifier do sklearn no conjunto de dados de diabetes dos índios Pima. Estamos combinando as previsões de regressão logística, classificador de árvore de decisão e SVM juntos para um problema de classificação como segue -

Primeiro, importe os pacotes necessários da seguinte forma -

from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.ensemble import VotingClassifier

Agora, precisamos carregar o conjunto de dados de diabetes Pima, como fizemos nos exemplos anteriores -

path = r"C:\pima-indians-diabetes.csv"
headernames = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = read_csv(path, names=headernames)
array = data.values
X = array[:,0:8]
Y = array[:,8]

Em seguida, forneça a entrada para validação cruzada de 10 vezes da seguinte forma -

kfold = KFold(n_splits=10, random_state=7)

Em seguida, precisamos criar submodelos da seguinte forma -

estimators = []
model1 = LogisticRegression()
estimators.append(('logistic', model1))
model2 = DecisionTreeClassifier()
estimators.append(('cart', model2))
model3 = SVC()
estimators.append(('svm', model3))

Agora, crie o modelo de conjunto de votação combinando as previsões dos submodelos criados acima.

ensemble = VotingClassifier(estimators)
results = cross_val_score(ensemble, X, Y, cv=kfold)
print(results.mean())

Resultado

0.7382262474367738

A saída acima mostra que obtivemos cerca de 74% de precisão em nosso modelo de conjunto de classificadores de votação.