Tutorial de Pré-processamento de Dados com Scikit-learn

Introdução

Bem-vindo ao laboratório de Pré-processamento de Dados do scikit-learn. Em machine learning, a qualidade dos seus dados impacta diretamente o desempenho do seu modelo. Dados brutos são frequentemente desorganizados, inconsistentes e não estão no formato ideal para algoritmos. O pré-processamento de dados é um passo crucial que envolve a limpeza e transformação de dados para torná-los adequados para um modelo de machine learning.

Neste laboratório, você aprenderá a realizar duas tarefas fundamentais de pré-processamento usando a biblioteca scikit-learn:

Escalonamento de Features (Feature Scaling): Padronizar o intervalo das variáveis independentes ou features dos dados.
Codificação de Rótulos (Label Encoding): Converter rótulos categóricos em um formato numérico.

Usaremos o famoso conjunto de dados Iris, que está convenientemente incluído no scikit-learn, para praticar essas técnicas. Ao final deste laboratório, você terá uma compreensão sólida de como preparar seus dados para pipelines de machine learning.

Dividir dados em features e alvo com X = iris.data, y = iris.target

Nesta etapa, começaremos carregando o conjunto de dados Iris e separando-o em features e a variável target. Em machine learning, X é a notação convencional para as features (as variáveis de entrada), e y é a notação para o target (a variável de saída que você deseja prever).

A biblioteca scikit-learn fornece o conjunto de dados Iris através do seu módulo datasets. O objeto do conjunto de dados carregado se comporta como um dicionário.

Estrutura do conjunto de dados Iris:

iris.data: Matriz de features (150 amostras × 4 features)
iris.target: Rótulos do target (150 amostras)
iris.feature_names: Nomes das 4 features
iris.target_names: Nomes das 3 espécies de flores

Por que separar X e y?

X: Features de entrada (o que o modelo aprende)
y: Rótulos do target (o que o modelo prevê)
Esta é a convenção padrão em machine learning

Primeiro, abra o arquivo preprocess.py localizado no diretório ~/project usando o explorador de arquivos à esquerda. Adicionaremos nosso código a este arquivo.

Adicione as seguintes linhas sob o comentário ## --- Step 1: Split data --- para atribuir as features e o target a X e y respectivamente. Também imprimiremos suas formas para verificar.

## --- Step 1: Split data ---
X = iris.data
y = iris.target

print("Shape of features (X):", X.shape)
print("Shape of target (y):", y.shape)

Agora, salve o arquivo e execute-o a partir do terminal para ver a saída.

python3 preprocess.py

Você deverá ver a seguinte saída, que indica que temos 150 amostras e 4 features, juntamente com 150 rótulos de target correspondentes.

Shape of features (X): (150, 4)
Shape of target (y): (150,)

Escalar features usando StandardScaler de sklearn.preprocessing

Nesta etapa, nos prepararemos para escalar nossas features. O escalonamento de features é um requisito comum para muitos algoritmos de machine learning, pois eles podem ser sensíveis à escala das features de entrada. StandardScaler é uma técnica popular que padroniza as features removendo a média e escalando-as para variância unitária.

Como o StandardScaler funciona:

Fórmula: z = (x - u) / s, onde u é a média das amostras de treinamento e s é o desvio padrão
Efeito: Transforma os dados para ter uma média de 0 e um desvio padrão de 1
Benefícios: Impede que features com escalas maiores dominem o processo de aprendizado

Parâmetros chave do StandardScaler:

with_mean=True (padrão): Centraliza os dados removendo a média
with_std=True (padrão): Escala os dados dividindo pelo desvio padrão

Usaremos o StandardScaler de sklearn.preprocessing. A primeira parte do processo é criar uma instância do scaler.

No seu arquivo preprocess.py, adicione o seguinte código sob o comentário ## --- Step 2: Initialize the scaler --- para criar uma instância de StandardScaler.

## --- Step 2: Initialize the scaler ---
scaler = StandardScaler()

print("Scaler object created:", scaler)

Salve o arquivo e execute-o novamente.

python3 preprocess.py

A saída agora incluirá uma linha confirmando que o objeto StandardScaler foi criado com sucesso.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()

Ajustar o scaler com scaler.fit(X)

Nesta etapa, ajustaremos o StandardScaler aos nossos dados de features X. O método fit() é um conceito fundamental no scikit-learn.

O que fit() faz:

Calcula estatísticas necessárias (média e desvio padrão) a partir dos dados de treinamento
Armazena esses parâmetros internamente para uso posterior
Importante: Apenas aprende com os dados, não os transforma

Por que separar fit() e transform()?

Ajustar apenas nos dados de treinamento: Evita vazamento de dados aprendendo parâmetros apenas do conjunto de treinamento
Aplicar a qualquer dado: Pode transformar dados de treinamento e teste usando os mesmos parâmetros aprendidos
Consistência: Garante que a mesma transformação seja aplicada a todos os dados

Melhor prática do mundo real:

scaler.fit(X_train) - Aprender parâmetros apenas dos dados de treinamento
X_train_scaled = scaler.transform(X_train) - Transformar dados de treinamento
X_test_scaled = scaler.transform(X_test) - Transformar dados de teste com os mesmos parâmetros

Adicione o seguinte código ao seu arquivo preprocess.py sob o comentário ## --- Step 3: Fit the scaler ---. Também imprimiremos o atributo mean_ do scaler para ver o que ele aprendeu.

## --- Step 3: Fit the scaler ---
scaler.fit(X)

print("Scaler mean:", scaler.mean_)

Salve o arquivo e execute-o.

python3 preprocess.py

A saída agora mostrará a média para cada uma das quatro features, que o scaler computou a partir dos dados.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()
Scaler mean: [5.84333333 3.05733333 3.758      1.19933333]

Transformar dados com scaler.transform(X)

Nesta etapa, usaremos o scaler ajustado para transformar nossos dados. O método transform() aplica a transformação de escalonamento aos dados, usando a média e o desvio padrão calculados durante a etapa fit(). Isso centralizará nossos dados em torno de uma média de 0 com um desvio padrão de 1.

Armazenaremos os dados transformados em uma nova variável, X_scaled, para manter os dados originais intactos.

Entendendo o código:

X_scaled = scaler.transform(X): Aplica a transformação aprendida aos nossos dados
np.set_printoptions(precision=2, suppress=True): Formata a saída para melhor legibilidade
- precision=2: Mostra 2 casas decimais
- suppress=True: Usa notação científica para números muito pequenos/grandes
np.mean(X, axis=0): Calcula a média ao longo do eixo 0 (colunas)
- axis=0: Computa a média para cada feature (coluna) em todas as amostras
- Resultado: Um valor de média por feature

Adicione o seguinte código ao seu arquivo preprocess.py sob o comentário ## --- Step 4: Transform the data ---. Imprimiremos a média dos dados originais e escalados para observar o efeito da transformação.

## --- Step 4: Transform the data ---
X_scaled = scaler.transform(X)

## Use numpy para definir a precisão para uma saída mais limpa
np.set_printoptions(precision=2, suppress=True)
print("Original data mean:", np.mean(X, axis=0))
print("Scaled data mean:", np.mean(X_scaled, axis=0))
print("Scaled data sample:\n", X_scaled[:5])

Salve o arquivo e execute-o.

python3 preprocess.py

Você verá que a média dos dados escalados é efetivamente zero, e os valores de amostra dos dados foram transformados.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()
Scaler mean: [5.84333333 3.05733333 3.758      1.19933333]
Original data mean: [5.84 3.06 3.76 1.2 ]
Scaled data mean: [-0. -0. -0. -0.]
Scaled data sample:
 [[-0.9   1.02 -1.34 -1.32]
 [-1.14 -0.13 -1.34 -1.32]
 [-1.39  0.33 -1.4  -1.32]
 [-1.51  0.1  -1.28 -1.32]
 [-1.02  1.25 -1.34 -1.32]]

Codificar o alvo categórico usando LabelEncoder de sklearn.preprocessing

Nesta etapa, pré-processaremos nossa variável alvo y. O alvo do conjunto de dados Iris é categórico, representado pelos números 0, 1 e 2, que correspondem às três espécies diferentes de flores de Iris. Embora já sejam numéricos, é uma boa prática entender como codificar rótulos categóricos, especialmente se estivessem em formato de string (por exemplo, 'setosa', 'versicolor').

LabelEncoder explicado:

Propósito: Converte rótulos categóricos (strings ou tipos mistos) em inteiros
Como funciona: Atribui um inteiro único a cada categoria única
Exemplo: ['cat', 'dog', 'cat'] → [0, 1, 0]

Por que usar LabelEncoder?

Muitos algoritmos de ML exigem entradas numéricas
Armazenamento e computação eficientes
Mantém a natureza categórica dos dados

Métodos chave:

fit(y): Aprende o mapeamento de categorias para inteiros
transform(y): Aplica o mapeamento aprendido
fit_transform(y): Combina ambas as etapas em uma única chamada
inverse_transform(y_encoded): Converte inteiros de volta para as categorias originais

Notas importantes:

A ordem é arbitrária (baseada na primeira aparição ou ordenação)
Não é adequado para dados ordinais onde a ordem importa (use OrdinalEncoder em vez disso)
Para features (não alvos), considere OneHotEncoder para dados nominais

Adicione o seguinte código ao seu arquivo preprocess.py sob o comentário ## --- Step 5: Encode the target ---. Criaremos uma instância de LabelEncoder e usaremos o método fit_transform(), que combina o ajuste e a transformação em uma única etapa.

## --- Step 5: Encode the target ---
encoder = LabelEncoder()
y_encoded = encoder.fit_transform(y)

print("\nOriginal target sample:", y[:5])  ## Mostra os primeiros 5 rótulos originais
print("Encoded target sample:", y_encoded[:5])  ## Mostra os primeiros 5 rótulos codificados
print("Unique encoded values:", np.unique(y_encoded))  ## Mostra todos os valores codificados únicos

Salve o arquivo e execute-o pela última vez.

python3 preprocess.py

A saída mostrará que a variável alvo foi codificada. Como ela já estava no formato inteiro correto, o resultado é o mesmo, mas isso demonstra o processo que você usaria para rótulos baseados em strings.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()
Scaler mean: [5.84333333 3.05733333 3.758      1.19933333]
Original data mean: [5.84 3.06 3.76 1.2 ]
Scaled data mean: [-0. -0. -0. -0.]
Scaled data sample:
 [[-0.9   1.02 -1.34 -1.32]
 [-1.14 -0.13 -1.34 -1.32]
 [-1.39  0.33 -1.4  -1.32]
 [-1.51  0.1  -1.28 -1.32]
 [-1.02  1.25 -1.34 -1.32]]

Original target sample: [0 0 0 0 0]
Encoded target sample: [0 0 0 0 0]
Unique encoded values: [0 1 2]

Resumo

Parabéns por completar o laboratório! Você realizou com sucesso tarefas essenciais de pré-processamento de dados usando scikit-learn.

Neste laboratório, você aprendeu a:

Carregar um conjunto de dados padrão do scikit-learn.
Separar os dados em features (X) e um alvo (y).
Escalar features numéricas usando StandardScaler, primeiro fitando-o aos dados para aprender os parâmetros e depois transformando os dados.
Codificar rótulos de alvo categóricos em um formato inteiro legível por máquina usando LabelEncoder.

Essas etapas de pré-processamento são fundamentais para construir modelos de machine learning robustos e de alto desempenho. Agora você está mais preparado para preparar seus próprios conjuntos de dados para futuros projetos de machine learning.