Usando a biblioteca Lazy Predict, podemos comparar os algoritmos de classificação e regressão de melhor desempenho sem esforço. Esta biblioteca foi criada por “Shankar Rao Pandala” e aqui está o link para a documentação.

Usaremos o conjunto de dados de câncer de mama para comparar algoritmos de classificação e o conjunto de dados de habitação de Boston para comparar os algoritmos de regressão com apenas algumas linhas de código para cada tarefa usando esta biblioteca.

Tarefa de classificação:

Instalando a biblioteca:

! pip install lazypredict

Use o comando acima para instalar a biblioteca lazypredict

Importando bibliotecas e dados de câncer de mama necessários:

# Import library
import lazypredict
from lazypredict.Supervised import LazyClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

# Load dataset
data = load_breast_cancer ()
X = data.data
y = data.target

Agora vamos dividir os dados na proporção 80/20:

# Divisão de dados
X_train, X_test, y_train, y_test = train_test_split (X, y, test_size = .2, random_state = 100)

Atribuindo lazyclassifier:

# Define e cria o lazyclassifier
clf = LazyClassifier (verbose = 0, ignore_warnings = True, custom_metric = None)
models_train, predictions_train = clf.fit (X_train, X_train, y_train, y_train)
models_test, predictions_test = clf.fit y_train, y_test)

Treine o desempenho dos dados:

# Imprime o desempenho do modelo no conjunto de treinamento
models_train

Desempenho dos dados de teste:

# Imprime o desempenho do modelo no conjunto de dados de teste
models_test

A partir das imagens acima, podemos entender como vários algoritmos classificadores (cerca de 28 modelos) são construídos e podemos comparar suas precisões, pontuações ROC AUC e F1 junto com o tempo gasto para construir.

Vamos criar um gráfico de barras para comparar esses modelos usando bibliotecas de mapas de mar e matos.

import matplotlib.pyplot as plt
import seaborn as sns

plt.figure (figsize = (5, 10))
sns.set_theme (style = ”whitegrid”)
ax = sns.barplot (y = models_train.index, x = ”Accuracy”, data = models_train)

A partir do gráfico de barras acima, podemos decidir qual algoritmo se adapta melhor à nossa declaração de problema e ajustá-lo ainda mais para melhor desempenho.

Tarefa de regressão:

# Carregando conjunto de dados de habitação de
Boston boston = datasets.load_boston ()
X, y = shuffle (boston.data, boston.target, random_state = 42)

Agora vamos dividir os dados na proporção 80/20:

# Divisão de dados
X_train, X_test, y_train, y_test = train_test_split (X, y, test_size = .2, random_state = 42)

Atribuindo lazyregressor:

# Define e cria o lazyclassifier
reg = LazyRegressor (verbose = 0, ignore_warnings = False, custom_metric = None)
models_train, predictions_train = reg.fit (X_train, X_train, y_train, y_train)
models_test, predictions_test = reg.fit (X_train, X_test) y_train, y_test)

Treine o desempenho dos dados:

# Imprime o desempenho do modelo no conjunto de dados de treinamento
models_train

Desempenho dos dados de teste:

# Imprime o desempenho do modelo no conjunto de dados de teste
models_test

A partir das imagens acima, podemos entender como vários algoritmos de regressor (cerca de 36 modelos) são construídos e podemos comparar seus valores R-quadrado e RMSE com o tempo gasto para construir.

Vamos criar um gráfico de barras para comparar esses modelos usando bibliotecas de mapas de mar e matos.

import matplotlib.pyplot as plt
import seaborn as sns

models_train [“R-Squared”] = [0 if i <0 else i for i in models_train.iloc [:, 0]]

plt.figure (figsize = (5, 10))
sns.set_theme (style = ”whitegrid”)
ax = sns.barplot (y = models_train.index, x = ”R-Squared”, data = models_train)
ax.set ( xlim = (0, 1))

Esta é uma maneira fácil de construir vários modelos de aprendizado de máquina usando apenas algumas linhas de código. Se tentarmos construir manualmente esses modelos de ML individualmente, levará muito tempo para importar as respectivas bibliotecas, construí-las individualmente e agregar seus resultados de previsão. A partir do gráfico de barras acima, podemos chegar a uma conclusão sobre qual algoritmo está tendo um bom desempenho e decidir ajustá-lo ainda mais para um melhor desempenho.

Nota :

A biblioteca LazyPredict nos permite construir os modelos com seus parâmetros padrão. Não podemos otimizar os parâmetros, mas ele construirá esses modelos com seus parâmetros padrão, o que ainda é bom, já que fomos capazes de construí-los rapidamente e, uma vez que identificamos qual modelo é o melhor, podemos concentrar nosso esforço em realizar a otimização de hiperparâmetro para esse ML algoritmo.

Então, o que vocês acham? Terei interesse em saber sua opinião sobre isso. Espero ter dado uma breve ideia sobre como construir rapidamente modelos de ML usando apenas algumas linhas de código. Dê a ele um 💚, se você gostou deste post para motivação extra. Estou sempre aberto a suas sugestões e dúvidas.