Aprendizado de máquina em Python: Tutorial do Scikit-Learn

O aprendizado de máquina é um subcampo da inteligência artificial dedicado à compreensão e à criação de métodos para imitar a maneira como os seres humanos aprendem. Esses métodos incluem o uso de algoritmos e dados para melhorar o desempenho em algum conjunto de tarefas e geralmente se enquadram em um dos três tipos mais comuns de aprendizado: 

• Aprendizado supervisionado: um tipo de aprendizado de máquina que aprende a relação entre entrada e saída. 
• Aprendizado não supervisionado: um tipo de aprendizado de máquina que aprende a estrutura subjacente de um conjunto de dados não rotulado.   
• Aprendizado por reforço: um método de aprendizado de máquina em que o agente de software aprende a executar determinadas ações em um ambiente que o leva à recompensa máxima.

O Scikit-learn, também conhecido como sklearn, é uma biblioteca de aprendizado de máquina Python robusta e de código aberto. Ele foi criado para ajudar a simplificar o processo de implementação de aprendizado de máquina e modelos estatísticos em Python. 

A biblioteca permite que os profissionais implementem rapidamente uma grande variedade de algoritmos de aprendizado de máquina supervisionados e não supervisionados por meio de uma interface consistente. O Sklearn foi desenvolvido com base no SciPy e funciona com todos os tipos de dados numéricos armazenados como matrizes NumPy, matrizes esparsas SciPy e todos os outros tipos de dados que podem ser convertidos em matrizes numéricas, como Pandas DataFrames.  

Neste tutorial prático do sklearn, abordaremos vários aspectos do ciclo de vida do aprendizado de máquina, como processamento de dados, treinamento de modelos e avaliação de modelos.  

Confira este espaço de trabalho do DataCamp para acompanhar o código. 

Dados

O primeiro aspecto do sklearn que exploraremos são os dados; o Scikit-learn vem com alguns conjuntos de dados padrão de aprendizado de máquina, o que significa que você não precisa baixá-los de um site ou banco de dados externo. 

Exemplos dos conjuntos de dados de brinquedo disponíveis no sklearn incluem o conjunto de dados de íris para classificação e o conjunto de dados de diabetes para regressão. Para o nosso exemplo, usaremos o conjunto de dados o conjunto de dados de vinho.

Vamos carregá-lo na memória:

from sklearn.datasets import load_wine

wine_data = load_wine() 

A execução do código acima retorna um objeto semelhante a um dicionário que contém os dados juntamente com metadados sobre os dados que ele contém. 

Os dados de que precisamos estão no arquivo .data do objeto do tipo dicionário, mas como não é um dicionário real, podemos acessá-lo como um atributo da instância wine_data da seguinte forma:

wine_data.data

Isso retorna uma matriz N x M, em que N é o número de amostras e M é o número de recursos.  

Vamos usar esse conhecimento para carregar nossos dados em um pandas DataFramedo pandas, que é muito mais fácil de manipular e analisar.

import pandas as pd
from sklearn.datasets import load_wine

wine_data = load_wine()

# Convert data to pandas dataframe
wine_df = pd.DataFrame(wine_data.data, columns=wine_data.feature_names)

# Add the target label
wine_df["target"] = wine_data.target

# Take a preview
wine_df.head()

Agora você está pronto para explorar os dados. 

Exploração de dados

Os DataFrames do Pandas são definidos como estruturas de dados rotuladas bidimensionais que consistem em colunas, que podem conter diferentes etapas de dados. A maneira mais fácil de conceituar um DataFrame é pensar nele como três componentes mesclados; esses componentes são: 1) dados, 2) um índice e 3) colunas. 

A exploração de dados não é o foco principal deste artigo, mas é uma etapa extremamente importante em qualquer projeto de dados - você pode aprender mais sobre isso em nosso Tutorial de análise exploratória de dados em Python. Faremos uma breve exploração para ter uma ideia melhor do que o nosso conjunto de dados contém; isso nos dará uma ideia melhor de como processar os dados. 

A primeira coisa que faremos é chamar o método info() em nosso pandas DataFrame; isso imprimirá um resumo conciso dos dados sobre o vinho contidos no DataFrame.

wine_df.info()

"""

RangeIndex: 178 entries, 0 to 177
Data columns (total 14 columns):
 #   Column                        Non-Null Count  Dtype  
---  ------                        --------------  -----  
 0   alcohol                       178 non-null    float64
 1   malic_acid                    178 non-null    float64
 2   ash                           178 non-null    float64
 3   alcalinity_of_ash             178 non-null    float64
 4   magnesium                     178 non-null    float64
 5   total_phenols                 178 non-null    float64
 6   flavanoids                    178 non-null    float64
 7   nonflavanoid_phenols          178 non-null    float64
 8   proanthocyanins               178 non-null    float64
 9   color_intensity               178 non-null    float64
 10  hue                           178 non-null    float64
 11  od280/od315_of_diluted_wines  178 non-null    float64
 12  proline                       178 non-null    float64
 13  target                        178 non-null    int64  
dtypes: float64(13), int64(1)
memory usage: 19.6 KB
"""

Depois de executar essa célula, você aprenderá: 

• Os dados contêm 178 amostras de dados
• Há um total de 14 colunas, incluindo a coluna de destino (o que queremos prever)
• Há 0 colunas com valores ausentes; você pode inferir isso na coluna "Non-Null Count". 
• Todos os recursos são do tipo de dados float64enquanto o rótulo de destino é um int64.
• Os dados usam 19,6 KB de memória. 

Também podemos chamar o método describe() em nosso DataFrame para obter estatísticas descritivas sobre cada recurso do conjunto de dados. 

Por exemplo: 

wine_df.describe() 

Você também quer ter uma ideia do tipo de valores que estão sendo mantidos em cada recurso. A maneira mais rápida de aprender isso é usar o método head() para exibir as primeiras cinco linhas de dados ou o método tail() para exibir as últimas cinco linhas de dados. 

wine_df.tail()

A execução desse código nos mostra que nossos recursos estão em escalas diferentes, o que pode causar problemas ao lidar com algoritmos baseados em Gradient Descent, como regressão logística, e ao lidar com algoritmos baseados em distância, como máquinas de vetores de suporte. Isso ocorre porque eles são sensíveis ao intervalo de pontos de dados. 

Em um fluxo de trabalho normal de aprendizado de máquina, esse processo será muito mais demorado, mas vamos pular o processamento de dados para voltar ao foco principal deste tutorial, o Scikit-learn. 

Você pode saber mais sobre o Pandas em Tutorial do Python Pandas: O guia definitivo para iniciantes. 

Exemplo do Scikit-learn: Pré-processamento de dados

Temos um bom entendimento da aparência de nossos dados. Quando você chega a esse ponto, geralmente significa que está pronto para começar a preparar os dados para serem inseridos em um modelo de aprendizado de máquina. 

O processamento de dados é uma etapa vital no fluxo de trabalho de aprendizado de máquina porque os dados do mundo real são confusos. Pode conter: 

• Valores ausentes,
• Valores redundantes
• Anômalos
• Erros
• Ruído

Você deve lidar com tudo isso antes de fornecer os dados a um modelo de aprendizado de máquina; caso contrário, o modelo incorporará esses erros em sua função de aproximação - ele aprenderá a cometer erros em novas instâncias. Foi isso que deu origem ao famoso ditado do aprendizado de máquina: "Garbage in, garbage out". 

Outro motivo é que os modelos de aprendizado de máquina geralmente exigem dados numéricos.  

Além de nossos dados estarem em escalas diferentes, não há muito mais de errado com nossos dados à primeira vista. Para combater esse problema, vamos padronizar os recursos usandoa classe StandardScaler do sklearn; isso garantirá que a média de cada recurso seja aproximadamente igual a zero .

Aqui está o código: 

from sklearn.preprocessing import StandardScaler

# Split data into features and label 
X = wine_df[wine_data.feature_names].copy()
y = wine_df["target"].copy() 

# Instantiate scaler and fit on features
scaler = StandardScaler()
scaler.fit(X)

# Transform features
X_scaled = scaler.transform(X.values)

# View first instance
print(X_scaled[0])

"""
[ 1.51861254 -0.5622498   0.23205254 -1.16959318  1.91390522  0.80899739
  1.03481896 -0.65956311  1.22488398  0.25171685  0.36217728  1.84791957
  1.01300893]
"""

Vamos prosseguir com o treinamento do modelo. 

Exemplo do Scikit-learn: Treinamento de modelos

Antes que um modelo de aprendizado de máquina possa fazer previsões, ele deve ser treinado em um conjunto de dados para aprender uma função de aproximação. 

Mas como saberemos se o modelo tem um bom desempenho em dados que ele nunca viu antes? Não o faremos a menos que o testemos. 

Uma maneira de testar um modelo de aprendizado de máquina antes de colocá-lo em um ambiente em que cause impacto em outras pessoas é dividir os dados de treinamento em um conjunto de treinamento e de teste e usar o conjunto de teste para avaliar o que o modelo aprendeu; isso é conhecido como avaliação off-line. 

Há várias maneiras de dividir os dados em conjuntos de treinamento e teste, mas o scikit-learn tem uma função integrada para fazer isso em nosso nome chamada train_test_split().

Usaremos essa função para dividir nossos dados de modo que 70% sejam usados para treinar o modelo e 30% sejam usados para avaliar a capacidade do modelo de generalizar para instâncias não vistas. 

from sklearn.model_selection import train_test_split

# Split data into train and test
X_train_scaled, X_test_scaled, y_train, y_test = train_test_split(X_scaled,
                                                                  y,
                                                             train_size=.7,
                                                           random_state=25)

# Check the splits are correct
print(f"Train size: {round(len(X_train_scaled) / len(X) * 100)}% \n\
Test size: {round(len(X_test_scaled) / len(X) * 100)}%")

"""
Train size: 70% 
Test size: 30%

Agora vamos criar alguns modelos. 

Criação do modelo

Graças ao sklearn, a criação de um modelo de aprendizado de máquina é extremamente simples. 

Vamos criar três modelos para prever a classe do vinho: 

1. Regressão logística
2. Máquina de vetor de suporte 
3. Classificador de árvore de decisão

from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

# Instnatiating the models 
logistic_regression = LogisticRegression()
svm = SVC()
tree = DecisionTreeClassifier()

# Training the models 
logistic_regression.fit(X_train_scaled, y_train)
svm.fit(X_train_scaled, y_train)
tree.fit(X_train_scaled, y_train)

# Making predictions with each model
log_reg_preds = logistic_regression.predict(X_test_scaled)
svm_preds = svm.predict(X_test_scaled)
tree_preds = tree.predict(X_test_scaled)

A próxima etapa é avaliar como os modelos são generalizados para instâncias não vistas. 

Exemplo do Scikit-learn: Avaliação do modelo

A avaliação do modelo é feita para testar a capacidade de generalização do modelo para instâncias não vistas. O Scikit-learn fornece uma série de métricas de classificação e regressão para avaliar o desempenho de um modelo treinado. 

Para nosso caso de uso, usaremos classification_report() da seção metrics para criar um relatório de texto mostrando as principais métricas de classificação, como precisão, recall, f1_score, exatidão etc.

Veja como isso fica no código:

from sklearn.metrics import classification_report

# Store model predictions in a dictionary
# this makes it's easier to iterate through each model
# and print the results. 
model_preds = {
    "Logistic Regression": log_reg_preds,
    "Support Vector Machine": svm_preds,
    "Decision Tree": tree_preds
}

for model, preds in model_preds.items():
    print(f"{model} Results:\n{classification_report(y_test, preds)}", sep="\n\n")

"""
Logistic Regression Results:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        17
           1       1.00      0.92      0.96        25
           2       0.86      1.00      0.92        12

    accuracy                           0.96        54
   macro avg       0.95      0.97      0.96        54
weighted avg       0.97      0.96      0.96        54

Support Vector Machine Results:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        17
           1       1.00      1.00      1.00        25
           2       1.00      1.00      1.00        12

    accuracy                           1.00        54
   macro avg       1.00      1.00      1.00        54
weighted avg       1.00      1.00      1.00        54

Decision Tree Results:
              precision    recall  f1-score   support

           0       0.94      0.94      0.94        17
           1       0.96      0.88      0.92        25
           2       0.86      1.00      0.92        12

    accuracy                           0.93        54
   macro avg       0.92      0.94      0.93        54
weighted avg       0.93      0.93      0.93        54
"""

À primeira vista, parece que a máquina de vetores de suporte é o melhor modelo. Em um fluxo de trabalho típico, isso despertaria a curiosidade sobre o modelo: ele é realmente tão bom quanto parece, ou cometemos algum erro? Você deve ficar intrigado em saber mais sobre seus modelos e o que eles estão aprendendo, pois isso lhe dará uma visão melhor dos pontos fortes e fracos deles. 

O conhecimento dessas informações é extremamente perspicaz para as partes interessadas, pois permite que elas encontrem soluções para compensar os pontos em que o modelo deixa a desejar. 

Conclusão

A biblioteca scikit-learn consiste em vários módulos que facilitam a implementação de modelos de aprendizado de máquina. Esses módulos variam de ferramentas de pré-processamento para ajudá-lo a preparar seu modelo para ser alimentado em um modelo de aprendizado de máquina a modelos que você pode usar para encontrar padrões em seus dados e métricas de avaliação que você pode usar para avaliar o desempenho do seu modelo. 

Neste tutorial, apenas arranhamos a superfície dos recursos do sklearn. Para se aprofundar no que você pode fazer com a biblioteca, temos vários recursos para ajudá-lo. Aqui estão alguns para você começar: 

• Aprendizagem supervisionada com o scikit-learn
• Aprendizado não supervisionado em Python
• Classificação K-Nearest neighbors (KNN) com o scikit-learn