O dimensionamento (escalonamento) é uma etapa crucial no pré-processamento dos dados, pois a maioria dos modelos de Machine Learning exige que os recursos estejam na mesma escala. Para isso, é necessário utilizar a Normalização ou Padronização, que são técnicas de pré-processamento de dados amplamente utilizadas para ajustar as escalas das features (variáveis) de um conjunto de dados. Ambas têm como objetivo melhorar o desempenho de algoritmos, especialmente aqueles sensíveis à magnitude dos dados, como redes neurais e SVM, e métodos baseados no distanciamento dos dados, como k-NN e k-means.




Dados Normalização Padronização
1 0.0 -1.41
2 0.25 -0.71
3 0.5 0.0
4 0.75 0.71
5 1 1.41

Normalização

A normalização redimensiona os valores das features para um intervalo específico, geralmente entre 0 e 1. Essa técnica é útil quando os dados têm escalas muito diferentes e precisamos que os dados estejam em um intervalo limitado.

Fórmula da Normalização:

$$\large n = \frac{x_{i} – x_{min}}{x_{max} – x_{min}}$$

Sendo:

  • $x_{i}:$ valor individual do conjunto de dados
  • $x_{min}:$ valor mínimo do conjunto de dados
  • $x_{max}:$ valor máximo do conjunto de dados

Python :

# Encontrando o valor mínimo do conjunto de dados
xmin = min(lista)

# Encontrando o valor máximo do conjunto de dados
xmax = max(lista)

# Encontrando os valores normalizados
lista_normalizada = list(map(lambda x: (x-xmin) / (xmax-xmin), lista))

Julia :

# Encontrando o valor mínimo do conjunto de dados
xmin = minimum(values)

# Encontrando o valor máximo do conjunto de dados
xmax = maximum(values)

# Encontrando os valores normalizados
normalizados = (values .- xmin) ./ (xmax - xmin)

Libs:

Linguagem Biblioteca Função
Python Numpy
+
Sklearn
 np.array([values]).reshape(-1, 1)

scaler = preprocessing.MinMaxScaler()

normalizado = scaler.fit_transform(values)
Numpy (values - np.min(values))/(np.max(values) - np.min(values))
Julia MLJ transformer = FeatureSelector(features=[:feature_name]) |> MinMaxScaler()

normalizado = transform(transformer, values)
Flux Flux.normalise(values)


Padronização

A padronização centraliza os dados em torno da média 0 com um desvio padrão 1. Que é preferido por muitos algoritmos. A padronização não limita os valores a um intervalo específico e mantém informações úteis de outliers.

Fórmula da Padronização:

$$\large z = \frac{x_{i} – \mu}{\sigma}$$

Sendo:

  • $x_{i}:$ valor individual do conjunto de dados
  • $\mu:$ média
  • $\sigma:$ desvio padrão populacional

Python :

# encontrando a média
m = sum(lista)/len(lista)

# Calculando o desvio padrão populacional
s2 = (sum(list(lambda x: (x-m)**2, lista))/len(lista))**0.5

# Encontrando os valores padronizados
lista_padronizada = list(map(lambda x: (x-m) / s2, lista))

Julia :

# encontrando a média
m = sum(values) / length(values)

# Calculando o desvio padrão populacional
s2 = (sum((values .- m).^2) / length(values))^0.5

# Encontrando os valores padronizados
padronizados = (values .- m) / s2

Libs:

Linguagem Biblioteca Função
Python Numpy
+
Sklearn.preprocessing
 np.array([values]).reshape(-1, 1)

scaler = sk.StandardScaler()

padronizado = scaler.fit_transform(values)
Numpy (values - np.mean(values)) / np.std(values)
Julia MLJ transformer = FeatureSelector(features=[:feature_name]) |> Standardizer()

padronizado = transform(transformer, values)
StatsBase zscore(values)

Exemplos

Utilizando o exemplo acima, os valores do conjunto de dados {1, 2, 3, 4, 5} serão normalizados e padronizados.

Python

'Normalização'

lista = [1, 2, 3, 4, 5]

xmin = min(lista)
xmax = max(lista)

normalizados = list(map(lambda x: (x - xmin) / (xmax - xmin), lista))

'Padronização'

lista = [1, 2, 3, 4, 5]

m = sum(lista) / len(lista)
s2 = (sum(list(map(lambda x: (x - m)**2, lista))) / len(lista))**0.5

padronizados = list(map(lambda x: (x - m) / s2, lista))

Julia

"Normalização"

values = [1, 2, 3, 4, 5]

xmin = minimum(values)
xmax = maximum(values)

normalizados = (values .- xmin) ./ (xmax - xmin)

"Padronização"

values = [1, 2, 3, 4, 5]

m = sum(values) / length(values)
s2 = (sum((values .- m).^2) / length(values))^0.5

padronizados = (values .- m) / s2

Diferenças:

Aspecto Normalização Padronização
Intervalo Escala fixa (0, 1) Sem intervalo fixo (média 0, desvio 1)
Efeito em outliers Sensível a outliers Menos sensível a outliers
Distribuição Não assume distribuição específica Assume distribuição normal ou próxima
Uso comum Algoritmos sensíveis à escala Algoritmos que assumem dados centrados

Usos da Normalização ou Padronização

  • A normalização deve ser usada quando os dados não seguem uma distribuição normal ou quando você precisa que todas as features estejam no mesmo intervalo. O impacto de outliers é muito alto na normalização.

  • A padronização deve ser usada quando os dados seguem uma distribuição normal ou quando o algoritmo assume que os dados estão centrados em zero. É a mais adequada para ser usada quando os dados tiverem uma distribuição gaussiana .