Arquivo de Análise de Dados - Página 2 de 13

Quando sua tabela tem 30 milhões de registros no MySQL

25/04/202603/11/2025 Por antonino

Imagine que você é um padeiro que precisa fatiar os pães produzidos. Agora multiplique isso por 3.000. É assim que se sente quando sua tabela MySQL cresce para 30 milhões de linhas. De repente, aquela consulta rápida vira uma espera eterna, como esperar o pão crescer em pleno inverno.

Por que 30 milhões de registros são diferentes?

Uma tabela pequena é como sua lista de compras – você encontra tudo rapidamente. Contudo, 30 milhões de registros são como a biblioteca de Alexandria: encontrar um livro específico exige organização e estratégia. O MySQL precisa de ajustes especiais para não ficar sobrecarregado, similar a como um padeiro profissional precisa de equipamentos industriais para produzir milhares de pães diariamente.

Preparando o terreno: configurando o MySQL para grandes volumes

Antes de mergulhar nos dados, precisamos ajustar nosso “forno” para assar pães em larga escala. As configurações padrão do MySQL são como um forno doméstico – perfeito para um bolo, mas insuficiente para uma padaria industrial.

Passos:

Feche o MySQL
abra o CMD como ADMINISTRADOR
Parando o MySQL pelo CMD

net stop MySQL80

1	net stop MySQL80

Navegar para a pasta de configuração onde está o arquivo my.ini

# Possível local
cd C:\ProgramData\MySQL\MySQL Server 8.0

1 2	# Possível local cd C:\ProgramData\MySQL\MySQL Server 8.0

faça um Backup do my.ini original

# Abra o arquivo de configuração e 
notepad my.ini
# salve em outro local com nome backup_my_ini.txt ANTES DE CONTINUAR

# Abra o arquivo de configuração e

notepad my.ini

# salve em outro local com nome backup_my_ini.txt ANTES DE CONTINUAR

Acessando my.ini em modeo edição

# Editar o arquivo de configuração
notepad my.ini

1 2	# Editar o arquivo de configuração notepad my.ini

Minha receita para a minha situação

Assim como diferentes tipos de pão exigem temperaturas e tempos específicos, diferentes cargas de trabalho precisam de configurações personalizadas. Principalmente, focaremos no innodb_buffer_pool_size – a memória que o MySQL usa para armazenar dados frequentemente acessados.

No meu caso tenho uma tabela vendas_medicamentos com 30468924 de linhas que preciso fazer o group by por ANO_VENDA, MUNICIPIO_VENDA, PRINCIPIO_ATIVO.

O meu my.ini ficou desta forma:

[client]
default-character-set = utf8mb4
port=3306

[mysql]
no-beep

[mysqld]

# ======================
# CONFIGURAÇÕES OTIMIZADAS PARA 41M+ LINHAS
# ======================

# Buffer Pool (CRÍTICO - use 2GB para segurança)
innodb_buffer_pool_size = 2G

# Logs para grandes transações
innodb_log_file_size = 256M
innodb_log_buffer_size = 32M

# Performance vs Durability (importante para ETL)
innodb_flush_log_at_trx_commit = 2

# Memória para operações GROUP BY
tmp_table_size = 256M
max_heap_table_size = 256M

# Buffers de ordenação
sort_buffer_size = 4M
read_buffer_size = 2M
read_rnd_buffer_size = 2M
join_buffer_size = 4M

# Timeouts maiores para queries longas
net_read_timeout = 1800
net_write_timeout = 1800
wait_timeout = 28800
interactive_timeout = 28800

# Otimizações para queries grandes
max_allowed_packet = 256M

# Máximo de conexões
max_connections = 100

# ======================
# CONFIGURAÇÕES GERAIS
# ======================
port=3306
datadir=C:/ProgramData/MySQL/MySQL Server 8.0\Data
character-set-server=utf8mb4
collation-server = utf8mb4_unicode_ci
authentication_policy=*,,
default-storage-engine=INNODB
sql-mode="ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION"
log-output=FILE
general-log=0
general_log_file="TORRECOUGAR-AMJ.log"
slow-query-log=1
slow_query_log_file="TORRECOUGAR-AMJ-slow.log"
long_query_time=10
log-error="TORRECOUGAR-AMJ.err"
log-bin="TORRECOUGAR-AMJ-bin"
server-id=1
lower_case_table_names=1
secure-file-priv="C:/ProgramData/MySQL/MySQL Server 8.0/Uploads"
max_connections=151
table_open_cache=4000
temptable_max_ram=1G
internal_tmp_mem_storage_engine=TempTable
myisam_max_sort_file_size=2146435072
myisam_sort_buffer_size=153M
key_buffer_size=8M

# ⚠️ CONFIGURAÇÕES COMENTADAS - JÁ DEFINIDAS ACIMA
# read_buffer_size=128K
# read_rnd_buffer_size=256K
# innodb_flush_log_at_trx_commit=1
# innodb_log_buffer_size=16M
# innodb_buffer_pool_size=128M

innodb_redo_log_capacity=100M
innodb_thread_concurrency=9
innodb_autoextend_increment=64
innodb_buffer_pool_instances=8
innodb_concurrency_tickets=5000
innodb_old_blocks_time=1000
innodb_stats_on_metadata=0
innodb_file_per_table=1
innodb_checksum_algorithm=0
flush_time=0

# CONFIGURAÇÕES ESSENCIAIS PARA QUERIES GRANDES
max_execution_time = 0
innodb_buffer_pool_chunk_size = 128M

# ⚠️ CONFIGURAÇÕES COMENTADAS - JÁ DEFINIDAS ACIMA  
# join_buffer_size=256K

max_allowed_packet=64M
max_connect_errors=100
open_files_limit=8161

# ⚠️ CONFIGURAÇÃO COMENTADA - JÁ DEFINIDA ACIMA
# sort_buffer_size=256K

binlog_row_event_max_size=8K
sync_source_info=10000
sync_relay_log=10000
mysqlx_port=33060

100

101

102

103

104

105

106

107

108

109

110

[client]

default-character-set = utf8mb4

port=3306

[mysql]

no-beep

[mysqld]

# ======================

# CONFIGURAÇÕES OTIMIZADAS PARA 41M+ LINHAS

# ======================

# Buffer Pool (CRÍTICO - use 2GB para segurança)

innodb_buffer_pool_size = 2G

# Logs para grandes transações

innodb_log_file_size = 256M

innodb_log_buffer_size = 32M

# Performance vs Durability (importante para ETL)

innodb_flush_log_at_trx_commit = 2

# Memória para operações GROUP BY

tmp_table_size = 256M

max_heap_table_size = 256M

# Buffers de ordenação

sort_buffer_size = 4M

read_buffer_size = 2M

read_rnd_buffer_size = 2M

join_buffer_size = 4M

# Timeouts maiores para queries longas

net_read_timeout = 1800

net_write_timeout = 1800

wait_timeout = 28800

interactive_timeout = 28800

# Otimizações para queries grandes

max_allowed_packet = 256M

# Máximo de conexões

max_connections = 100

# ======================

# CONFIGURAÇÕES GERAIS

# ======================

port=3306

datadir=C:/ProgramData/MySQL/MySQL Server 8.0\Data

character-set-server=utf8mb4

collation-server = utf8mb4_unicode_ci

authentication_policy=*,,

default-storage-engine=INNODB

sql-mode="ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION"

log-output=FILE

general-log=0

general_log_file="TORRECOUGAR-AMJ.log"

slow-query-log=1

slow_query_log_file="TORRECOUGAR-AMJ-slow.log"

long_query_time=10

log-error="TORRECOUGAR-AMJ.err"

log-bin="TORRECOUGAR-AMJ-bin"

server-id=1

lower_case_table_names=1

secure-file-priv="C:/ProgramData/MySQL/MySQL Server 8.0/Uploads"

max_connections=151

table_open_cache=4000

temptable_max_ram=1G

internal_tmp_mem_storage_engine=TempTable

myisam_max_sort_file_size=2146435072

myisam_sort_buffer_size=153M

key_buffer_size=8M

# ⚠️ CONFIGURAÇÕES COMENTADAS - JÁ DEFINIDAS ACIMA

# read_buffer_size=128K

# read_rnd_buffer_size=256K

# innodb_flush_log_at_trx_commit=1

# innodb_log_buffer_size=16M

# innodb_buffer_pool_size=128M

innodb_redo_log_capacity=100M

innodb_thread_concurrency=9

innodb_autoextend_increment=64

innodb_buffer_pool_instances=8

innodb_concurrency_tickets=5000

innodb_old_blocks_time=1000

innodb_stats_on_metadata=0

innodb_file_per_table=1

innodb_checksum_algorithm=0

flush_time=0

# CONFIGURAÇÕES ESSENCIAIS PARA QUERIES GRANDES

max_execution_time = 0

innodb_buffer_pool_chunk_size = 128M

# ⚠️ CONFIGURAÇÕES COMENTADAS - JÁ DEFINIDAS ACIMA

# join_buffer_size=256K

max_allowed_packet=64M

max_connect_errors=100

open_files_limit=8161

# ⚠️ CONFIGURAÇÃO COMENTADA - JÁ DEFINIDA ACIMA

# sort_buffer_size=256K

binlog_row_event_max_size=8K

sync_source_info=10000

sync_relay_log=10000

mysqlx_port=33060

Passo 8 -Reinicie o servidor de BD MySQL no CMD

# Iniciar MySQL
net start MySQL80

1 2	# Iniciar MySQL net start MySQL80

No MySQL execute:

SET SESSION net_read_timeout = 1800;

SET SESSION net_write_timeout = 1800;

SET GLOBAL max_allowed_packet = 268435456;

Estratégias inteligentes para trabalhar com dados massivos

Trabalhar com 30 milhões de registros exige a mesma paciência e estratégia que um alpinista precisa para escalar o Everest. Você não sobe de uma vez – divide em acampamentos-base.

Atualizações em lotes: dividir para conquistar

Atualizar 30 milhões de registros de uma vez é como tentar assinar 10.000 pães no mesmo forno. Eventualmente, algo queima. Por isso, dividimos em lotes menores:

"""
Atualização em lotes - assinando pães em fornadas menores
"""
UPDATE trampo.VENDAS_MEDICAMENTOS 
SET principio_ativo = 'SEM INFORMAÇÃO' 
WHERE principio_ativo = '' 
LIMIT 1000;  # Apenas 1000 por vez

# Execute repetidamente até terminar
# Verifique quantos faltam com:
SELECT COUNT(*) FROM trampo.VENDAS_MEDICAMENTOS 
WHERE principio_ativo = '';

"""

Atualização em lotes - assinando pães em fornadas menores

"""

UPDATE trampo.VENDAS_MEDICAMENTOS

SET principio_ativo = 'SEM INFORMAÇÃO'

WHERE principio_ativo = ''

LIMIT 1000; # Apenas 1000 por vez

# Execute repetidamente até terminar

# Verifique quantos faltam com:

SELECT COUNT(*) FROM trampo.VENDAS_MEDICAMENTOS

WHERE principio_ativo = '';

Consultas filtradas: buscando agulhas no palheiro

Encontrar dados específicos em 30 milhões de registros exige filtros inteligentes, similar a como um matemático usa equações para resolver problemas complexos:

"""
SEMPRE use WHERE para filtrar - não tente fazer tudo de uma vez
"""
SELECT 
    ANO_VENDA, 
    MUNICIPIO_VENDA, 
    PRINCIPIO_ATIVO,
    SUM(QTD_VENDIDA) as TOTAL_VENDIDO
FROM trampo.vendas_medicamentos  
WHERE MUNICIPIO_VENDA = 'Niterói'
GROUP BY ANO_VENDA, MUNICIPIO_VENDA, PRINCIPIO_ATIVO;

"""

SEMPRE use WHERE para filtrar - não tente fazer tudo de uma vez

"""

SELECT

ANO_VENDA,

MUNICIPIO_VENDA,

PRINCIPIO_ATIVO,

SUM(QTD_VENDIDA) as TOTAL_VENDIDO

FROM trampo.vendas_medicamentos

WHERE MUNICIPIO_VENDA = 'Niterói'

GROUP BY ANO_VENDA, MUNICIPIO_VENDA, PRINCIPIO_ATIVO;

Os detalhes que fazem diferença

Assim como a qualidade da farinha afeta o pão, pequenos detalhes na configuração impactam drasticamente o desempenho. Inegavelmente, o innodb_buffer_pool_size é o mais importante – ele determina quantos dados ficam na memória RAM, que é milhões de vezes mais rápida que o disco.

innodb_buffer_pool_size: Use 50-80% da RAM disponível
innodb_flush_log_at_trx_commit = 2: Acelera escrita mas reduz segurança em caso de queda de energia
Índices: Como índice de livro – aceleram buscas mas desaceleram inserções

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Por que não uso configurações gigantescas desde o início?” Analogamente a como um padeiro não usa fermento em excesso, configurações muito grandes podem travar seu servidor. Comece conservador e ajuste conforme necessário.

Uma confusão comum é pensar que mais RAM sempre resolve tudo. Surpreendentemente, sem os índices corretos, é como ter uma Ferrari em um congestionamento – o poder está lá, mas você não consegue usar.

Para onde ir agora?

Comece aplicando as configurações básicas e testando com consultas pequenas. Posteriormente, monitore o desempenho usando o slow query log para identificar gargalos. Lembre-se: otimização de banco de dados é uma jornada, não um destino.

Assuntos relacionados

Complexidade algorítmica e notação Big O
Estatística descritiva para análise de dados
Probabilidade e distribuições de dados
Otimização matemática e trade-offs
Álgebra relacional e teoria de conjuntos

Referências que valem a pena

Dominar grandes volumes de dados é como dominar a arte da panificação: requer prática, paciência e os ingredientes certos. Agora você tem a receita – mãos à obra!

Regularização Min-Max Scaling no Python

19/12/202520/09/2025 Por antonino

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