Aprendizaje automático con Python: preparación de datos

Introducción

Los algoritmos de aprendizaje automático dependen completamente de los datos porque es el aspecto más crucial que hace posible el entrenamiento de modelos. Por otro lado, si no podemos encontrarle sentido a esos datos, antes de alimentarlos a los algoritmos ML, una máquina será inútil. En palabras simples, siempre necesitamos alimentar los datos correctos, es decir, los datos en la escala y el formato correctos y que contengan características significativas, para el problema que queremos que la máquina resuelva.

Esto hace que la preparación de datos sea el paso más importante en el proceso de AA. La preparación de datos puede definirse como el procedimiento que hace que nuestro conjunto de datos sea más apropiado para el proceso de AA.

¿Por qué preprocesar datos?

Después de seleccionar los datos sin procesar para el entrenamiento de ML, la tarea más importante es el preprocesamiento de datos. En un sentido amplio, el preprocesamiento de datos convertirá los datos seleccionados en una forma con la que podamos trabajar o que podamos alimentar a los algoritmos de ML. Siempre necesitamos preprocesar nuestros datos para que puedan cumplir con las expectativas del algoritmo de aprendizaje automático.

Técnicas de preprocesamiento de datos

Contamos con las siguientes técnicas de preprocesamiento de datos que se pueden aplicar en conjuntos de datos para producir datos para algoritmos ML:

Escalada

Lo más probable es que nuestro conjunto de datos se componga de los atributos con una escala variable, pero no podemos proporcionar dichos datos al algoritmo ML, por lo que requiere un cambio de escala. El cambio de escala de datos asegura que los atributos estén a la misma escala. Generalmente, los atributos se reescalan en el rango de 0 y 1. Los algoritmos ML como el descenso de gradiente y k-Vecinos más cercanos requieren datos escalados. Podemos cambiar la escala de los datos con la ayuda de la clase MinMaxScaler de la biblioteca de Python scikit-learn.

Ejemplo

En este ejemplo, cambiaremos la escala de los datos del conjunto de datos de diabetes de los indios Pima que usamos anteriormente. Primero, se cargarán los datos CSV (como se hizo en los capítulos anteriores) y luego, con la ayuda de la clase MinMaxScaler, se volverá a escalar en el rango de 0 y 1.

Las primeras líneas del siguiente script son las mismas que hemos escrito en capítulos anteriores al cargar datos 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

Ahora, podemos usar la clase MinMaxScaler para cambiar la escala de los datos en el rango de 0 y 1.

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

También podemos resumir los datos para la salida según nuestra elección. Aquí, establecemos la precisión en 1 y mostramos las primeras 10 filas en la salida.

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

Salida

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. ]
]

De la salida anterior, todos los datos se volvieron a escalar en el rango de 0 y 1.

Normalización

Otra técnica útil de preprocesamiento de datos es la normalización. Esto se usa para cambiar la escala de cada fila de datos para que tenga una longitud de 1. Es principalmente útil en conjuntos de datos dispersos donde tenemos muchos ceros. Podemos cambiar la escala de los datos con la ayuda de la clase Normalizer de la biblioteca de Python scikit-learn.

Tipos de normalización

En el aprendizaje automático, existen dos tipos de técnicas de preprocesamiento de normalización de la siguiente manera:

Normalización L1

Se puede definir como la técnica de normalización que modifica los valores del conjunto de datos de manera que en cada fila la suma de los valores absolutos siempre sea hasta 1. También se le llama Desviaciones Mínimas Absolutas.

Example

En este ejemplo, usamos la técnica de Normalizar L1 para normalizar los datos del conjunto de datos de Diabetes de los Indios Pima que usamos anteriormente. Primero, se cargarán los datos CSV y luego, con la ayuda de la clase Normalizer, se normalizarán.

Las primeras líneas del siguiente script son las mismas que hemos escrito en capítulos anteriores al cargar datos 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

Ahora, podemos usar la clase Normalizer con L1 para normalizar los datos.

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

También podemos resumir los datos para la salida según nuestra elección. Aquí, establecemos la precisión en 2 y mostramos las primeras 3 filas en la salida.

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. ]
]

Normalización L2

Se puede definir como la técnica de normalización que modifica los valores del conjunto de datos de manera que en cada fila la suma de los cuadrados siempre sea hasta 1. También se le llama mínimos cuadrados.

Example

En este ejemplo, usamos la técnica de normalización L2 para normalizar los datos del conjunto de datos de diabetes de los indios Pima que usamos anteriormente. Primero, se cargarán los datos CSV (como se hizo en los capítulos anteriores) y luego con la ayuda de la clase Normalizer se normalizarán.

Las primeras líneas del siguiente script son las mismas que hemos escrito en capítulos anteriores al cargar datos 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

Ahora, podemos usar la clase Normalizer con L1 para normalizar los datos.

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

También podemos resumir los datos para la salida según nuestra elección. Aquí, establecemos la precisión en 2 y mostramos las primeras 3 filas en la salida.

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]
]

Binarización

Como sugiere el nombre, esta es la técnica con la que podemos convertir nuestros datos en binarios. Podemos utilizar un umbral binario para convertir nuestros datos en binarios. Los valores por encima de ese valor de umbral se convertirán a 1 y por debajo de ese umbral se convertirán a 0. Por ejemplo, si elegimos el valor de umbral = 0.5, entonces el valor del conjunto de datos por encima de él se convertirá en 1 y por debajo de este se convertirá en 0. Es decir por qué podemos llamarlobinarizing los datos o thresholdinglos datos. Esta técnica es útil cuando tenemos probabilidades en nuestro conjunto de datos y queremos convertirlas en valores nítidos.

Podemos binarizar los datos con la ayuda de la clase Binarizer de la biblioteca de Python scikit-learn.

Ejemplo

En este ejemplo, cambiaremos la escala de los datos del conjunto de datos de diabetes de los indios Pima que usamos anteriormente. Primero, se cargarán los datos CSV y luego, con la ayuda de la clase Binarizer, se convertirán en valores binarios, es decir, 0 y 1, dependiendo del valor de umbral. Estamos tomando 0,5 como valor umbral.

Las primeras líneas del siguiente script son las mismas que hemos escrito en capítulos anteriores al cargar datos 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

Ahora, podemos usar la clase Binarize para convertir los datos en valores binarios.

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

Aquí, mostramos las primeras 5 filas en la salida.

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

Salida

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.]
]

Estandarización

Otra técnica útil de preprocesamiento de datos que se utiliza básicamente para transformar los atributos de los datos con una distribución gaussiana. Difiere la media y la DE (desviación estándar) a una distribución gaussiana estándar con una media de 0 y una DE de 1. Esta técnica es útil en algoritmos ML como regresión lineal, regresión logística que asume una distribución gaussiana en el conjunto de datos de entrada y produce mejores resultados. resultados con datos reescalados. Podemos estandarizar los datos (media = 0 y SD = 1) con la ayuda de la clase StandardScaler de la biblioteca de Python scikit-learn.

Ejemplo

En este ejemplo, cambiaremos la escala de los datos del conjunto de datos de diabetes de los indios Pima que usamos anteriormente. Primero, se cargarán los datos CSV y luego, con la ayuda de la clase StandardScaler, se convertirán en Distribución Gaussiana con media = 0 y SD = 1.

Las primeras líneas del siguiente script son las mismas que hemos escrito en capítulos anteriores al cargar datos 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

Ahora, podemos usar la clase StandardScaler para cambiar la escala de los datos.

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

También podemos resumir los datos para la salida según nuestra elección. Aquí, establecemos la precisión en 2 y mostramos las primeras 5 filas en la salida.

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

Salida

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]
]

Etiquetado de datos

Discutimos la importancia de los buenos resultados para los algoritmos ML, así como algunas técnicas para preprocesar los datos antes de enviarlos a los algoritmos ML. Un aspecto más a este respecto es el etiquetado de datos. También es muy importante enviar los datos a algoritmos ML que tengan el etiquetado adecuado. Por ejemplo, en caso de problemas de clasificación, en los datos hay muchas etiquetas en forma de palabras, números, etc.

¿Qué es la codificación de etiquetas?

La mayoría de las funciones de sklearn esperan que los datos tengan etiquetas de números en lugar de etiquetas de palabras. Por lo tanto, necesitamos convertir dichas etiquetas en etiquetas numéricas. Este proceso se denomina codificación de etiquetas. Podemos realizar la codificación de etiquetas de datos con la ayuda de la función LabelEncoder () de la biblioteca de Python scikit-learn.

Ejemplo

En el siguiente ejemplo, la secuencia de comandos de Python realizará la codificación de etiquetas.

Primero, importe las bibliotecas de Python necesarias de la siguiente manera:

import numpy as np
from sklearn import preprocessing

Ahora, debemos proporcionar las etiquetas de entrada de la siguiente manera:

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

La siguiente línea de código creará el codificador de etiquetas y lo entrenará.

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

Las siguientes líneas de secuencia de comandos verificarán el rendimiento codificando la lista ordenada aleatoriamente:

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 obtener la lista de valores codificados con la ayuda del siguiente script de Python:

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

Salida

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