Arquivo de Python - Página 68 de 94

O Min-Max Scaling é uma técnica de pré-processamento de dados que transforma features (características) escalando cada feature para um range específico, geralmente [0, 1]. É uma das técnicas de normalização mais comuns em aprendizado de máquina.

O que é Min-Max Scaling?

Min-Max Scaling é um método de normalização que transforma os dados redimensionando-os para um intervalo fixo, normalmente [0, 1]. A transformação é dada pela fórmula:

$X_{\text{scaled}} = \frac{X – X_{\text{min}}}{X_{\text{max}} – X_{\text{min}}}$

Onde:

$X$ é o valor original
$X_{\text{min}}$ é o valor mínimo da feature
$X_{\text{max}}$ é o valor máximo da feature
$X_{\text{scaled}}$ é o valor normalizado

Implementação manual em Python:

import numpy as np

def min_max_scaling_manual(data):
    """Implementação manual do Min-Max Scaling"""
    data = np.array(data)
    min_val = np.min(data)
    max_val = np.max(data)
    scaled_data = (data - min_val) / (max_val - min_val)
    return scaled_data, min_val, max_val

# Dados de exemplo
dados_originais = [10, 20, 30, 40, 50]
dados_normalizados, min_val, max_val = min_max_scaling_manual(dados_originais)

print("Dados originais:", dados_originais)
print("Valor mínimo:", min_val)
print("Valor máximo:", max_val)
print("Dados normalizados:", dados_normalizados)

import numpy as np

def min_max_scaling_manual(data):

"""Implementação manual do Min-Max Scaling"""

data = np.array(data)

min_val = np.min(data)

max_val = np.max(data)

scaled_data = (data - min_val) / (max_val - min_val)

return scaled_data, min_val, max_val

# Dados de exemplo

dados_originais = [10, 20, 30, 40, 50]

dados_normalizados, min_val, max_val = min_max_scaling_manual(dados_originais)

print("Dados originais:", dados_originais)

print("Valor mínimo:", min_val)

print("Valor máximo:", max_val)

print("Dados normalizados:", dados_normalizados)

Em R, podemos implementar Min-Max Scaling similarmente:

# Implementação manual do Min-Max Scaling em R
min_max_scaling_manual <- function(data) {
  min_val <- min(data)
  max_val <- max(data)
  scaled_data <- (data - min_val) / (max_val - min_val)
  return(list(scaled_data = scaled_data, min_val = min_val, max_val = max_val))
}

# Dados de exemplo
dados_originais <- c(10, 20, 30, 40, 50)
resultado <- min_max_scaling_manual(dados_originais)

print(paste("Dados originais:", paste(dados_originais, collapse = ", ")))
print(paste("Valor mínimo:", resultado$min_val))
print(paste("Valor máximo:", resultado$max_val))
print(paste("Dados normalizados:", paste(round(resultado$scaled_data, 3), collapse = ", ")))

# Implementação manual do Min-Max Scaling em R

min_max_scaling_manual <- function(data) {

min_val <- min(data)

max_val <- max(data)

scaled_data <- (data - min_val) / (max_val - min_val)

return(list(scaled_data = scaled_data, min_val = min_val, max_val = max_val))

}

# Dados de exemplo

dados_originais <- c(10, 20, 30, 40, 50)

resultado <- min_max_scaling_manual(dados_originais)

print(paste("Dados originais:", paste(dados_originais, collapse = ", ")))

print(paste("Valor mínimo:", resultado$min_val))

print(paste("Valor máximo:", resultado$max_val))

print(paste("Dados normalizados:", paste(round(resultado$scaled_data, 3), collapse = ", ")))

Implementação com Scikit-Learn

Usando MinMaxScaler

A biblioteca Scikit-Learn fornece a classe MinMaxScaler que implementa eficientemente a normalização Min-Max:

from sklearn.preprocessing import MinMaxScaler
import numpy as np

# Dados de exemplo
dados = np.array([[10], [20], [30], [40], [50]])

# Criando e ajustando o scaler
scaler = MinMaxScaler()
scaler.fit(dados)

# Transformando os dados
dados_normalizados = scaler.transform(dados)

print("Dados originais:")
print(dados)
print("\nDados normalizados:")
print(dados_normalizados)
print("\nValor mínimo aprendido:", scaler.data_min_)
print("Valor máximo aprendido:", scaler.data_max_)

# Transformando novos dados
novos_dados = np.array([[15], [25], [35]])
novos_dados_normalizados = scaler.transform(novos_dados)
print("\nNovos dados normalizados:")
print(novos_dados_normalizados)

from sklearn.preprocessing import MinMaxScaler

import numpy as np

# Dados de exemplo

dados = np.array([[10], [20], [30], [40], [50]])

# Criando e ajustando o scaler

scaler = MinMaxScaler()

scaler.fit(dados)

# Transformando os dados

dados_normalizados = scaler.transform(dados)

print("Dados originais:")

print(dados)

print("\nDados normalizados:")

print(dados_normalizados)

print("\nValor mínimo aprendido:", scaler.data_min_)

print("Valor máximo aprendido:", scaler.data_max_)

# Transformando novos dados

novos_dados = np.array([[15], [25], [35]])

novos_dados_normalizados = scaler.transform(novos_dados)

print("\nNovos dados normalizados:")

print(novos_dados_normalizados)

O MinMaxScaler também permite definir um range personalizado:

# MinMaxScaler com range personalizado (-1, 1)
scaler_custom = MinMaxScaler(feature_range=(-1, 1))
dados_custom = scaler_custom.fit_transform(dados)
print("Dados com range personalizado (-1, 1):")
print(dados_custom)

# MinMaxScaler com range personalizado (-1, 1)

scaler_custom = MinMaxScaler(feature_range=(-1, 1))

dados_custom = scaler_custom.fit_transform(dados)

print("Dados com range personalizado (-1, 1):")

print(dados_custom)

Aplicação em DataFrame Pandas

O MinMaxScaler pode ser aplicado diretamente em DataFrames do Pandas:

import pandas as pd
from sklearn.preprocessing import MinMaxScaler

# Criando DataFrame de exemplo
df = pd.DataFrame({
    'idade': [25, 30, 35, 40, 45, 50],
    'salario': [5000, 6000, 7000, 8000, 9000, 10000],
    'horas_trabalho': [40, 42, 38, 45, 40, 35]
})

print("DataFrame original:")
print(df)

# Aplicando MinMaxScaler
scaler = MinMaxScaler()
df_normalizado = pd.DataFrame(
    scaler.fit_transform(df),
    columns=df.columns,
    index=df.index
)

print("\nDataFrame normalizado:")
print(df_normalizado)

# Estatísticas do scaler
print("\nEstatísticas do scaler:")
for i, col in enumerate(df.columns):
    print(f"{col}: min={scaler.data_min_[i]:.2f}, max={scaler.data_max_[i]:.2f}")

import pandas as pd

from sklearn.preprocessing import MinMaxScaler

# Criando DataFrame de exemplo

df = pd.DataFrame({

'idade': [25, 30, 35, 40, 45, 50],

'salario': [5000, 6000, 7000, 8000, 9000, 10000],

'horas_trabalho': [40, 42, 38, 45, 40, 35]

})

print("DataFrame original:")

print(df)

# Aplicando MinMaxScaler

scaler = MinMaxScaler()

df_normalizado = pd.DataFrame(

scaler.fit_transform(df),

columns=df.columns,

index=df.index

)

print("\nDataFrame normalizado:")

print(df_normalizado)

# Estatísticas do scaler

print("\nEstatísticas do scaler:")

for i, col in enumerate(df.columns):

print(f"{col}: min={scaler.data_min_[i]:.2f}, max={scaler.data_max_[i]:.2f}")

Em R, podemos usar a função scale() com parâmetros apropriados ou o pacote caret:

# Min-Max Scaling em R usando scale()
min_max_scale <- function(x) {
  (x - min(x)) / (max(x) - min(x))
}

# Criando data frame de exemplo
df <- data.frame(
  idade = c(25, 30, 35, 40, 45, 50),
  salario = c(5000, 6000, 7000, 8000, 9000, 10000),
  horas_trabalho = c(40, 42, 38, 45, 40, 35)
)

print("Data frame original:")
print(df)

# Aplicando Min-Max Scaling
df_normalizado <- as.data.frame(lapply(df, min_max_scale))
print("Data frame normalizado:")
print(df_normalizado)

# Min-Max Scaling em R usando scale()

min_max_scale <- function(x) {

(x - min(x)) / (max(x) - min(x))

}

# Criando data frame de exemplo

df <- data.frame(

idade = c(25, 30, 35, 40, 45, 50),

salario = c(5000, 6000, 7000, 8000, 9000, 10000),

horas_trabalho = c(40, 42, 38, 45, 40, 35)

)

print("Data frame original:")

print(df)

# Aplicando Min-Max Scaling

df_normalizado <- as.data.frame(lapply(df, min_max_scale))

print("Data frame normalizado:")

print(df_normalizado)

Vantagens e Desvantagens do Min-Max Scaling

Vantagens:

Preserva a forma da distribuição original
Mantém as relações entre os valores originais
Fácil de implementar e interpretar
Não distorce as distâncias entre os valores
Ideal para dados com distribuição não-normal

Desvantagens:

Sensível a outliers (valores extremos)
Não centraliza os dados na média zero
Não reduz a variabilidade dos dados
Não é adequado quando a presença de outliers é significativa

⚠️ Cuidado com Outliers

O Min-Max Scaling é sensível a outliers pois os valores mínimo e máximo são determinados pelos valores extremos do conjunto de dados:

# Exemplo com outlier
dados_com_outlier = np.array([[10], [20], [30], [40], [50], [1000]])  # 1000 é um outlier

scaler = MinMaxScaler()
dados_com_outlier_normalizados = scaler.fit_transform(dados_com_outlier)

print("Dados com outlier:", dados_com_outlier.flatten())
print("Dados normalizados:", dados_com_outlier_normalizados.flatten().round(3))

# Exemplo com outlier

dados_com_outlier = np.array([[10], [20], [30], [40], [50], [1000]]) # 1000 é um outlier

scaler = MinMaxScaler()

dados_com_outlier_normalizados = scaler.fit_transform(dados_com_outlier)

print("Dados com outlier:", dados_com_outlier.flatten())

print("Dados normalizados:", dados_com_outlier_normalizados.flatten().round(3))

Neste caso, o outlier (1000) comprime todos os outros valores em uma faixa muito estreita próximo a zero.

Quando Usar Min-Max Scaling

Algoritmos Baseados em Distância

Use Min-Max Scaling para algoritmos que dependem de medidas de distância, como K-NN, K-Means e SVM.

# Pré-processamento para K-NN
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('scaler', MinMaxScaler()),
    ('classifier', KNeighborsClassifier())
])

# Pré-processamento para K-NN

from sklearn.neighbors import KNeighborsClassifier

from sklearn.pipeline import Pipeline

pipeline = Pipeline([

('scaler', MinMaxScaler()),

('classifier', KNeighborsClassifier())

])

Redes Neurais

Use Min-Max Scaling para normalizar inputs de redes neurais, especialmente com funções de ativação como sigmoid ou tanh.

# Pré-processamento para redes neurais
from sklearn.neural_network import MLPClassifier

pipeline = Pipeline([
    ('scaler', MinMaxScaler()),
    ('nn', MLPClassifier(hidden_layer_sizes=(100, 50)))
])

# Pré-processamento para redes neurais

from sklearn.neural_network import MLPClassifier

pipeline = Pipeline([

('scaler', MinMaxScaler()),

('nn', MLPClassifier(hidden_layer_sizes=(100, 50)))

])

Processamento de Imagens

Use Min-Max Scaling para normalizar valores de pixels (0-255) para o range 0-1.

# Normalizando pixels de imagem
from sklearn.preprocessing import MinMaxScaler

# Supondo que 'imagem' seja uma matriz de pixels (0-255)
scaler = MinMaxScaler(feature_range=(0, 1))
imagem_normalizada = scaler.fit_transform(imagem)

# Normalizando pixels de imagem

from sklearn.preprocessing import MinMaxScaler

# Supondo que 'imagem' seja uma matriz de pixels (0-255)

scaler = MinMaxScaler(feature_range=(0, 1))

imagem_normalizada = scaler.fit_transform(imagem)

Comparação com Outras Técnicas de Normalização

O Min-Max Scaling é uma entre várias técnicas de normalização. Vamos compará-lo com outras abordagens comuns:

Standardization (Z-score Normalization)

$X_{\text{standardized}} = \frac{X – \mu}{\sigma}$

Centraliza os dados na média 0
Escala para desvio padrão 1
Menos sensível a outliers
Ideal para dados com distribuição normal

Robust Scaling

$X_{\text{robust}} = \frac{X – \text{mediana}}{\text{IQR}}$

Usa mediana e IQR (Intervalo Interquartil)
Robusto a outliers
Ideal para dados com outliers significativos

Exemplo comparativo:

from sklearn.preprocessing import StandardScaler, RobustScaler, MinMaxScaler
import numpy as np

# Dados com outlier
dados = np.array([[10], [20], [30], [40], [50], [1000]])

# Aplicando diferentes técnicas
minmax_scaler = MinMaxScaler()
standard_scaler = StandardScaler()
robust_scaler = RobustScaler()

dados_minmax = minmax_scaler.fit_transform(dados)
dados_standard = standard_scaler.fit_transform(dados)
dados_robust = robust_scaler.fit_transform(dados)

print("Original:    ", dados.flatten())
print("Min-Max:     ", dados_minmax.flatten().round(3))
print("Standard:    ", dados_standard.flatten().round(3))
print("Robust:      ", dados_robust.flatten().round(3))

from sklearn.preprocessing import StandardScaler, RobustScaler, MinMaxScaler

import numpy as np

# Dados com outlier

dados = np.array([[10], [20], [30], [40], [50], [1000]])

# Aplicando diferentes técnicas

minmax_scaler = MinMaxScaler()

standard_scaler = StandardScaler()

robust_scaler = RobustScaler()

dados_minmax = minmax_scaler.fit_transform(dados)

dados_standard = standard_scaler.fit_transform(dados)

dados_robust = robust_scaler.fit_transform(dados)

print("Original: ", dados.flatten())

print("Min-Max: ", dados_minmax.flatten().round(3))

print("Standard: ", dados_standard.flatten().round(3))

print("Robust: ", dados_robust.flatten().round(3))

Conclusão

O Min-Max Scaling é uma técnica fundamental de pré-processamento de dados no machine learning. Sua simplicidade e eficácia o tornam uma escolha popular para normalizar features para um range específico, especialmente quando a distribuição original dos dados não é normal e não há outliers significativos.

Lembre-se de sempre:

Ajustar o scaler apenas com dados de treinamento
Aplicar a mesma transformação em dados de teste/validação
Considerar técnicas alternativas como StandardScaler ou RobustScaler quando houver outliers
Documentar os parâmetros de transformação para reprodutibilidade

Referências

Scikit-Learn Documentation: MinMaxScaler
Introduction to Machine Learning with Python: Andreas C. Müller & Sarah Guido
Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow: Aurélien Géron

Processo de KDD – Knowledge Discovery in Databases

Visão Geral do Processo

As 9 Etapas do Processo KDD

1. Compreensão do Domínio

2. Seleção do Conjunto de Dados

3. Limpeza e Pré-processamento

Técnicas Comuns:

4. Redução e Projeção

5. Escolha da Tarefa de Mineração

6. Seleção de Algoritmos

7. Mineração de Dados

8. Interpretação de Padrões

9. Implementação do Conhecimento

Conclusão

Etapas do processo de KDD

Referências Bibliográficas

Regularização Min-Max Scaling no Python

O que é Min-Max Scaling?

Implementação manual em Python:

Implementação com Scikit-Learn

Usando MinMaxScaler

Aplicação em DataFrame Pandas

Vantagens e Desvantagens do Min-Max Scaling

Vantagens:

Desvantagens:

⚠️ Cuidado com Outliers

Quando Usar Min-Max Scaling

Algoritmos Baseados em Distância

Redes Neurais

Processamento de Imagens

Comparação com Outras Técnicas de Normalização

Standardization (Z-score Normalization)

Robust Scaling

Exemplo comparativo:

Conclusão

Referências