Aprendizado de máquina com Python - preparando dados

Introdução

Os algoritmos de aprendizado de máquina são totalmente dependentes de dados porque é o aspecto mais crucial que torna possível o treinamento do modelo. Por outro lado, se não conseguirmos entender esses dados, antes de alimentá-los com algoritmos de ML, uma máquina será inútil. Em palavras simples, sempre precisamos alimentar os dados corretos, ou seja, os dados em escala, formato correto e contendo recursos significativos, para o problema que queremos que a máquina resolva.

Isso torna a preparação de dados a etapa mais importante no processo de ML. A preparação de dados pode ser definida como o procedimento que torna nosso conjunto de dados mais apropriado para o processo de ML.

Por que pré-processamento de dados?

Depois de selecionar os dados brutos para o treinamento de ML, a tarefa mais importante é o pré-processamento de dados. Em sentido amplo, o pré-processamento de dados converterá os dados selecionados em um formato com o qual possamos trabalhar ou alimentar os algoritmos de ML. Sempre precisamos pré-processar nossos dados para que possam estar de acordo com a expectativa do algoritmo de aprendizado de máquina.

Técnicas de pré-processamento de dados

Temos as seguintes técnicas de pré-processamento de dados que podem ser aplicadas no conjunto de dados para produzir dados para algoritmos de ML -

Dimensionamento

Muito provavelmente, nosso conjunto de dados compreende atributos com escala variável, mas não podemos fornecer esses dados ao algoritmo de ML, portanto, ele requer redimensionamento. O reescalonamento de dados garante que os atributos estejam na mesma escala. Geralmente, os atributos são redimensionados na faixa de 0 e 1. Os algoritmos de ML, como gradiente descendente e k-vizinhos mais próximos, requerem dados escalonados. Podemos redimensionar os dados com a ajuda da classe MinMaxScaler da biblioteca Python scikit-learn.

Exemplo

Neste exemplo, vamos redimensionar os dados do conjunto de dados de Diabetes dos índios Pima que usamos anteriormente. Primeiro, os dados CSV serão carregados (como feito nos capítulos anteriores) e, em seguida, com a ajuda da classe MinMaxScaler, serão redimensionados na faixa de 0 e 1.

As primeiras linhas do script a seguir são as mesmas que escrevemos nos capítulos anteriores durante o carregamento de dados CSV.

from pandas import read_csv
from numpy import set_printoptions
from sklearn import preprocessing
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

Agora, podemos usar a classe MinMaxScaler para redimensionar os dados no intervalo de 0 e 1.

data_scaler = preprocessing.MinMaxScaler(feature_range=(0,1))
data_rescaled = data_scaler.fit_transform(array)

Também podemos resumir os dados de saída de acordo com nossa escolha. Aqui, estamos definindo a precisão para 1 e mostrando as primeiras 10 linhas na saída.

set_printoptions(precision=1)
print ("\nScaled data:\n", data_rescaled[0:10])

Resultado

Scaled data:
[
   [0.4 0.7 0.6 0.4 0.  0.5 0.2 0.5 1. ]
   [0.1 0.4 0.5 0.3 0.  0.4 0.1 0.2 0. ]
   [0.5 0.9 0.5 0.  0.  0.3 0.3 0.2 1. ]
   [0.1 0.4 0.5 0.2 0.1 0.4 0.  0.  0. ]
   [0.  0.7 0.3 0.4 0.2 0.6 0.9 0.2 1. ]
   [0.3 0.6 0.6 0.  0.  0.4 0.1 0.2 0. ]
   [0.2 0.4 0.4 0.3 0.1 0.5 0.1 0.1 1. ]
   [0.6 0.6 0.  0.  0.  0.5 0.  0.1 0. ]
   [0.1 1.  0.6 0.5 0.6 0.5 0.  0.5 1. ]
   [0.5 0.6 0.8 0.  0.  0.  0.1 0.6 1. ]
]

A partir da saída acima, todos os dados foram redimensionados para o intervalo de 0 e 1.

Normalização

Outra técnica de pré-processamento de dados útil é a normalização. Isso é usado para redimensionar cada linha de dados para ter um comprimento de 1. É útil principalmente em conjuntos de dados esparsos, onde temos muitos zeros. Podemos redimensionar os dados com a ajuda da classe Normalizer da biblioteca Python scikit-learn.

Tipos de normalização

No aprendizado de máquina, existem dois tipos de técnicas de pré-processamento de normalização, como segue -

Normalização L1

Pode ser definida como a técnica de normalização que modifica os valores do conjunto de dados de forma que em cada linha a soma dos valores absolutos seja sempre até 1. É também chamada de Mínimos Desvios Absolutos.

Example

Neste exemplo, usamos a técnica de normalização L1 para normalizar os dados do conjunto de dados de Diabetes dos índios Pima, que usamos anteriormente. Primeiro, os dados CSV serão carregados e, em seguida, com a ajuda da classe Normalizer, eles serão normalizados.

As primeiras linhas do script a seguir são as mesmas que escrevemos nos capítulos anteriores durante o carregamento de dados CSV.

from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.values

Agora, podemos usar a classe Normalizer com L1 para normalizar os dados.

Data_normalizer = Normalizer(norm='l1').fit(array)
Data_normalized = Data_normalizer.transform(array)

Também podemos resumir os dados de saída de acordo com nossa escolha. Aqui, estamos definindo a precisão para 2 e mostrando as 3 primeiras linhas na saída.

set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])

Output

Normalized data:
[
   [0.02 0.43 0.21 0.1  0. 0.1  0. 0.14 0. ]
   [0.   0.36 0.28 0.12 0. 0.11 0. 0.13 0. ]
   [0.03 0.59 0.21 0.   0. 0.07 0. 0.1  0. ]
]

Normalização L2

Pode ser definida como a técnica de normalização que modifica os valores do conjunto de dados de forma que em cada linha a soma dos quadrados seja sempre até 1. É também chamada de mínimos quadrados.

Example

Neste exemplo, usamos a técnica de normalização L2 para normalizar os dados do conjunto de dados de Diabetes dos índios Pima que usamos anteriormente. Primeiro, os dados CSV serão carregados (como feito nos capítulos anteriores) e, em seguida, com a ajuda da classe Normalizer, eles serão normalizados.

As primeiras linhas do script a seguir são as mesmas que escrevemos nos capítulos anteriores durante o carregamento de dados CSV.

from pandas import read_csv
from numpy import set_printoptions
from sklearn.preprocessing import Normalizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv (path, names=names)
array = dataframe.values

Agora, podemos usar a classe Normalizer com L1 para normalizar os dados.

Data_normalizer = Normalizer(norm='l2').fit(array)
Data_normalized = Data_normalizer.transform(array)

Também podemos resumir os dados de saída de acordo com nossa escolha. Aqui, estamos definindo a precisão para 2 e mostrando as 3 primeiras linhas na saída.

set_printoptions(precision=2)
print ("\nNormalized data:\n", Data_normalized [0:3])

Output

Normalized data:
[
   [0.03 0.83 0.4  0.2  0. 0.19 0. 0.28 0.01]
   [0.01 0.72 0.56 0.24 0. 0.22 0. 0.26 0.  ]
   [0.04 0.92 0.32 0.   0. 0.12 0. 0.16 0.01]
]

Binarização

Como o nome sugere, esta é a técnica com a qual podemos tornar nossos dados binários. Podemos usar um limite binário para tornar nossos dados binários. Os valores acima desse valor limite serão convertidos em 1 e abaixo desse limite serão convertidos em 0. Por exemplo, se escolhermos o valor limite = 0,5, o valor do conjunto de dados acima se tornará 1 e abaixo disso se tornará 0. Isso é porque podemos chamá-lobinarizing os dados ou thresholdingos dados. Essa técnica é útil quando temos probabilidades em nosso conjunto de dados e queremos convertê-las em valores nítidos.

Podemos binarizar os dados com a ajuda da classe Binarizer da biblioteca Python scikit-learn.

Exemplo

Neste exemplo, vamos redimensionar os dados do conjunto de dados de Diabetes dos índios Pima que usamos anteriormente. Primeiro, os dados CSV serão carregados e, em seguida, com a ajuda da classe Binarizer, serão convertidos em valores binários, ou seja, 0 e 1, dependendo do valor limite. Estamos tomando 0,5 como valor limite.

As primeiras linhas do script a seguir são as mesmas que escrevemos nos capítulos anteriores durante o carregamento de dados CSV.

from pandas import read_csv
from sklearn.preprocessing import Binarizer
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

Agora, podemos usar a classe Binarize para converter os dados em valores binários.

binarizer = Binarizer(threshold=0.5).fit(array)
Data_binarized = binarizer.transform(array)

Aqui, estamos mostrando as primeiras 5 linhas na saída.

print ("\nBinary data:\n", Data_binarized [0:5])

Resultado

Binary data:
[
   [1. 1. 1. 1. 0. 1. 1. 1. 1.]
   [1. 1. 1. 1. 0. 1. 0. 1. 0.]
   [1. 1. 1. 0. 0. 1. 1. 1. 1.]
   [1. 1. 1. 1. 1. 1. 0. 1. 0.]
   [0. 1. 1. 1. 1. 1. 1. 1. 1.]
]

estandardização

Outra técnica de pré-processamento de dados útil que é basicamente usada para transformar os atributos de dados com uma distribuição Gaussiana. Ela difere a média e o SD (desvio padrão) para uma distribuição gaussiana padrão com uma média de 0 e um SD de 1. Esta técnica é útil em algoritmos de ML como regressão linear, regressão logística que assume uma distribuição gaussiana no conjunto de dados de entrada e produz melhor resultados com dados redimensionados. Podemos padronizar os dados (média = 0 e SD = 1) com a ajuda da classe StandardScaler da biblioteca Python scikit-learn.

Exemplo

Neste exemplo, vamos redimensionar os dados do conjunto de dados de Diabetes dos índios Pima que usamos anteriormente. Primeiramente, os dados CSV serão carregados e, em seguida, com a ajuda da classe StandardScaler, serão convertidos para a Distribuição Gaussiana com média = 0 e DP = 1.

As primeiras linhas do script a seguir são as mesmas que escrevemos nos capítulos anteriores durante o carregamento de dados CSV.

from sklearn.preprocessing import StandardScaler
from pandas import read_csv
from numpy import set_printoptions
path = r'C:\pima-indians-diabetes.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(path, names=names)
array = dataframe.values

Agora, podemos usar a classe StandardScaler para redimensionar os dados.

data_scaler = StandardScaler().fit(array)
data_rescaled = data_scaler.transform(array)

Também podemos resumir os dados de saída de acordo com nossa escolha. Aqui, estamos definindo a precisão para 2 e mostrando as primeiras 5 linhas na saída.

set_printoptions(precision=2)
print ("\nRescaled data:\n", data_rescaled [0:5])

Resultado

Rescaled data:
[
   [ 0.64  0.85  0.15  0.91 -0.69  0.2   0.47  1.43  1.37]
   [-0.84 -1.12 -0.16  0.53 -0.69 -0.68 -0.37 -0.19 -0.73]
   [ 1.23  1.94 -0.26 -1.29 -0.69 -1.1   0.6  -0.11  1.37]
   [-0.84 -1.   -0.16  0.15  0.12 -0.49 -0.92 -1.04 -0.73]
   [-1.14  0.5  -1.5   0.91  0.77  1.41  5.48 -0.02  1.37]
]

Rotulagem de Dados

Discutimos a importância de bons dados para algoritmos de ML, bem como algumas técnicas para pré-processar os dados antes de enviá-los aos algoritmos de ML. Outro aspecto a esse respeito é a rotulagem de dados. Também é muito importante enviar os dados para algoritmos de ML com rotulagem adequada. Por exemplo, em caso de problemas de classificação, muitos rótulos em forma de palavras, números, etc. estão presentes nos dados.

O que é codificação de rótulo?

A maioria das funções do sklearn espera que os dados contenham rótulos de números em vez de rótulos de palavras. Portanto, precisamos converter esses rótulos em rótulos numéricos. Esse processo é chamado de codificação de rótulo. Podemos realizar a codificação de rótulo de dados com a ajuda da função LabelEncoder () da biblioteca Python scikit-learn.

Exemplo

No exemplo a seguir, o script Python executará a codificação do rótulo.

Primeiro, importe as bibliotecas Python necessárias da seguinte forma -

import numpy as np
from sklearn import preprocessing

Agora, precisamos fornecer os rótulos de entrada da seguinte maneira -

input_labels = ['red','black','red','green','black','yellow','white']

A próxima linha de código criará o codificador de rótulo e o treinará.

encoder = preprocessing.LabelEncoder()
encoder.fit(input_labels)

As próximas linhas do script verificarão o desempenho codificando a lista ordenada aleatória -

test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("\nLabels =", test_labels)
print("Encoded values =", list(encoded_values))
encoded_values = [3,0,4,1]
decoded_list = encoder.inverse_transform(encoded_values)

Podemos obter a lista de valores codificados com a ajuda do seguinte script python -

print("\nEncoded values =", encoded_values)
print("\nDecoded labels =", list(decoded_list))

Resultado

Labels = ['green', 'red', 'black']
Encoded values = [1, 2, 0]
Encoded values = [3, 0, 4, 1]
Decoded labels = ['white', 'black', 'yellow', 'green']