Técnicas de Pré-processamento em Scikit-Learn

Introdução

Neste laboratório, exploraremos as técnicas de pré-processamento disponíveis no scikit-learn. O pré-processamento é uma etapa essencial em qualquer fluxo de trabalho de aprendizado de máquina, pois ajuda a transformar dados brutos em um formato adequado para o algoritmo de aprendizado. Coberemos várias técnicas de pré-processamento, como padronização, escalonamento, normalização, codificação de recursos categóricos, imputação de valores ausentes, geração de recursos polinomiais e criação de transformadores personalizados.

Dicas da Máquina Virtual

Após o término da inicialização da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para você.

Padronização

A padronização é uma etapa comum de pré-processamento para muitos algoritmos de aprendizado de máquina. Ela transforma os recursos para ter média zero e variância unitária. Podemos usar o StandardScaler do scikit-learn para realizar a padronização.

from sklearn.preprocessing import StandardScaler
import numpy as np

## Cria um conjunto de dados de amostra
X = np.array([[1., -1., 2.],
              [2., 0., 0.],
              [0., 1., -1.]])

## Inicializa o StandardScaler
scaler = StandardScaler()

## Ajusta o scaler nos dados de treinamento
scaler.fit(X)

## Transforma os dados de treinamento
X_scaled = scaler.transform(X)

## Imprime os dados transformados
print(X_scaled)

Escalonamento

Escalonar recursos para um intervalo específico é outra técnica comum de pré-processamento. É útil quando os recursos têm escalas diferentes e queremos trazê-los todos para um intervalo semelhante. O MinMaxScaler e o MaxAbsScaler podem ser usados para realizar o escalonamento.

from sklearn.preprocessing import MinMaxScaler, MaxAbsScaler
import numpy as np

## Cria um conjunto de dados de amostra
X = np.array([[1., -1., 2.],
              [2., 0., 0.],
              [0., 1., -1.]])

## Inicializa o MinMaxScaler
min_max_scaler = MinMaxScaler()

## Ajusta e transforma os dados de treinamento
X_minmax = min_max_scaler.fit_transform(X)

## Imprime os dados transformados
print(X_minmax)

## Inicializa o MaxAbsScaler
max_abs_scaler = MaxAbsScaler()

## Ajusta e transforma os dados de treinamento
X_maxabs = max_abs_scaler.fit_transform(X)

## Imprime os dados transformados
print(X_maxabs)

Normalização

A normalização é o processo de escalonar amostras individuais para ter norma unitária. É comumente usada quando a magnitude dos dados não é importante e estamos apenas interessados na direção (ou ângulo) dos dados. Podemos usar o Normalizer do scikit-learn para realizar a normalização.

from sklearn.preprocessing import Normalizer
import numpy as np

## Cria um conjunto de dados de amostra
X = np.array([[1., -1., 2.],
              [2., 0., 0.],
              [0., 1., -1.]])

## Inicializa o Normalizer
normalizer = Normalizer()

## Ajusta e transforma os dados de treinamento
X_normalized = normalizer.fit_transform(X)

## Imprime os dados transformados
print(X_normalized)

Codificação de Recursos Categóricos

Recursos categóricos precisam ser codificados em valores numéricos antes de poderem ser usados em algoritmos de aprendizado de máquina. Podemos usar o OrdinalEncoder e o OneHotEncoder do scikit-learn para codificar recursos categóricos.

from sklearn.preprocessing import OrdinalEncoder, OneHotEncoder
import numpy as np

## Cria um conjunto de dados de amostra
X = [['male', 'from US', 'uses Safari'],
     ['female', 'from Europe', 'uses Firefox']]

## Inicializa o OrdinalEncoder
ordinal_encoder = OrdinalEncoder()

## Ajusta e transforma os dados de treinamento
X_encoded = ordinal_encoder.fit_transform(X)

## Imprime os dados transformados
print(X_encoded)

## Inicializa o OneHotEncoder
onehot_encoder = OneHotEncoder()

## Ajusta e transforma os dados de treinamento
X_onehot = onehot_encoder.fit_transform(X)

## Imprime os dados transformados
print(X_onehot.toarray())

Imputação de Valores Ausentes

Valores ausentes em um conjunto de dados podem causar problemas com algoritmos de aprendizado de máquina. Podemos usar os métodos fornecidos no módulo impute do scikit-learn para lidar com valores ausentes. Aqui, usaremos o SimpleImputer para imputar valores ausentes.

from sklearn.impute import SimpleImputer
import numpy as np

## Cria um conjunto de dados de amostra com valores ausentes
X = np.array([[1., 2., np.nan],
              [3., np.nan, 5.],
              [np.nan, 4., 6.]])

## Inicializa o SimpleImputer
imputer = SimpleImputer()

## Ajusta e transforma os dados de treinamento
X_imputed = imputer.fit_transform(X)

## Imprime os dados transformados
print(X_imputed)

Gerando Recursos Polinomiais

Às vezes, é benéfico adicionar complexidade a um modelo considerando recursos não lineares dos dados de entrada. Podemos usar o PolynomialFeatures do scikit-learn para gerar recursos polinomiais.

from sklearn.preprocessing import PolynomialFeatures
import numpy as np

## Cria um conjunto de dados de amostra
X = np.array([[0, 1],
              [2, 3],
              [4, 5]])

## Inicializa o PolynomialFeatures
poly = PolynomialFeatures(2)

## Ajusta e transforma os dados de treinamento
X_poly = poly.fit_transform(X)

## Imprime os dados transformados
print(X_poly)

Criando Transformadores Personalizados

Em alguns casos, podemos querer converter uma função Python existente em um transformador para auxiliar na limpeza ou processamento de dados. Podemos alcançar isso usando o FunctionTransformer do scikit-learn.

from sklearn.preprocessing import FunctionTransformer
import numpy as np

## Crie uma função personalizada
def custom_function(X):
    return np.log1p(X)

## Inicialize o FunctionTransformer
transformer = FunctionTransformer(custom_function)

## Crie um conjunto de dados de amostra
X = np.array([[0, 1],
              [2, 3]])

## Transforme os dados usando a função personalizada
X_transformed = transformer.transform(X)

## Imprima os dados transformados
print(X_transformed)

Resumo

Parabéns! Você concluiu o laboratório de Pré-processamento de Dados. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.