Preprocesamiento de datos
El segundo paso del camino

Preprocesamiento de datos

El preprocesamiento de datos en Machine Learning es un paso crucial que ayuda a mejorar la calidad de los datos para promover la extracción de información significativa de los datos. El preprocesamiento de datos en Machine Learning se refiere a la técnica de preparar (limpiar y organizar) los datos sin procesar para que sean adecuados para la construcción y entrenamiento de modelos de Machine Learning. En palabras simples, el preprocesamiento de datos en Machine Learning es una tecnica de mineria de datos que transforma los datos sin procesar en un formato comprensible y legible. 

¿Por qué el preprocesamiento de datos en el aprendizaje automático?

Cuando se trata de crear un modelo de aprendizaje automático, el preprocesamiento de datos es el primer paso que marca el inicio del proceso. Por lo general, los datos del mundo real son incompletos, inconsistentes, inexactos (contienen errores o valores atípicos) y, a menudo, carecen de valores / tendencias de atributos específicos. Aquí es donde el preprocesamiento de datos entra en escena: ayuda a limpiar, formatear y organizar los datos sin procesar, lo que los hace listos para usar en los modelos de aprendizaje automático. Exploremos varios pasos del preprocesamiento de datos en el aprendizaje automático. 


Pasos en el preprocesamiento de datos en el aprendizaje automático

 Hay siete pasos importantes en el preprocesamiento de datos en Machine Learning:

 1. Adquirir el conjunto de datos

La adquisición del conjunto de datos es el primer paso en el preprocesamiento de datos en el aprendizaje automático. Para construir y desarrollar modelos de Machine Learning, primero debe adquirir el conjunto de datos relevante. Este conjunto de datos estará compuesto por datos recopilados de fuentes múltiples y dispares que luego se combinan en un formato adecuado para formar un conjunto de datos. Los formatos de conjuntos de datos difieren según los casos de uso. Por ejemplo, un conjunto de datos comerciales será completamente diferente de un conjunto de datos médicos. Mientras que un conjunto de datos comerciales contendrá datos industriales y comerciales relevantes, un conjunto de datos médicos incluirá datos relacionados con la atención médica.

Hay varias fuentes en línea desde donde puede descargar conjuntos de datos como https://www.kaggle.com/uciml/datasets y https://archive.ics.uci.edu/ml/index.php . También puede crear un conjunto de datos recopilando datos a través de diferentes API de Python. Una vez que el conjunto de datos esté listo, debe ponerlo en formatos de archivo CSV, HTML o XLSX.

2. Importa todas las bibliotecas cruciales

Dado que Python es la biblioteca más utilizada y también la más preferida por los científicos de datos de todo el mundo, le mostraremos cómo importar bibliotecas de Python para el preprocesamiento de datos en Machine Learning.  Las bibliotecas de Python predefinidas pueden realizar trabajos de preprocesamiento de datos específicos. Importar todas las bibliotecas cruciales es el segundo paso en el preprocesamiento de datos en el aprendizaje automático. Las tres bibliotecas centrales de Python que se utilizan para este preprocesamiento de datos en Machine Learning son:

  • NumPy : NumPy es el paquete fundamental para el cálculo científico en Python. Por tanto, se utiliza para insertar cualquier tipo de operación matemática en el código. Con NumPy, también puede agregar grandes matrices y matrices multidimensionales en su código. 
  • Pandas : Pandas es una excelente biblioteca de Python de código abierto para la manipulación y el análisis de datos. Se usa ampliamente para importar y administrar los conjuntos de datos. Incluye estructuras de datos y herramientas de análisis de datos de alto rendimiento y fáciles de usar para Python.
  • Matplotlib : Matplotlib es una biblioteca de trazado 2D de Python que se utiliza para trazar cualquier tipo de gráficos en Python. Puede entregar cifras con calidad de publicación en numerosos formatos impresos y entornos interactivos en todas las plataformas (shells IPython, cuaderno Jupyter, servidores de aplicaciones web, etc.). 

3. Importa el conjunto de datos

En este paso, debe importar los conjuntos de datos que ha recopilado para el proyecto ML en cuestión. La importación del conjunto de datos es uno de los pasos importantes en el preprocesamiento de datos en el aprendizaje automático. Sin embargo, antes de que pueda importar los conjuntos de datos, debe establecer el directorio actual como directorio de trabajo. Puede configurar el directorio de trabajo en Spyder IDE en tres sencillos pasos:

  1. Guarde su archivo de Python en el directorio que contiene el conjunto de datos.
  2. Vaya a la opción Explorador de archivos en Spyder IDE y elija el directorio requerido.
  3. Ahora, haga clic en el botón F5 o en la opción Ejecutar para ejecutar el archivo.


Así es como debería verse el directorio de trabajo. 

Una vez que haya configurado el directorio de trabajo que contiene el conjunto de datos relevante, puede importar el conjunto de datos usando la función "read_csv ()" de la biblioteca de Pandas. Esta función puede leer un archivo CSV (ya sea localmente oa través de una URL) y también realizar varias operaciones en él. Read_csv () se escribe como:

data_set = pd.read_csv ('Dataset.csv')

En esta línea de código, "data_set" denota el nombre de la variable en la que almacenó el conjunto de datos. La función también contiene el nombre del conjunto de datos. Una vez que ejecute este código, el conjunto de datos se importará correctamente. 

Durante el proceso de importación del conjunto de datos, hay otra cosa esencial que debe hacer: extraer variables dependientes e independientes. Para cada modelo de Machine Learning, es necesario separar las variables independientes (matriz de características) y las variables dependientes en un conjunto de datos. 

Considere este conjunto de datos:

Este conjunto de datos contiene tres variables independientes: país, edad y salario, y una variable dependiente, comprada. 

¿Cómo extraer las variables independientes?

Para extraer las variables independientes, puede utilizar la función “iloc []” de la biblioteca Pandas. Esta función puede extraer filas y columnas seleccionadas del conjunto de datos.

x = data_set.iloc [:,: - 1] .values  

En la línea de código anterior, los primeros dos puntos (:) consideran todas las filas y los segundos dos puntos (:) consideran todas las columnas. El código contiene “: -1” ya que debe omitir la última columna que contiene la variable dependiente. Al ejecutar este código, obtendrá la matriz de características, así: 

[['India' 38.0 68000.0]  

 ['Francia' 43,0 45000,0]  

 ['Alemania' 30.0 54000.0]  

 ['Francia' 48.0 65000.0]  

 ['Alemania' 40.0 nan]  

 ['India' 35.0 58000.0]  

 ['Alemania' nan 53000.0]  

 ['Francia' 49.0 79000.0]  

 ['India' 50.0 88000.0]  

 ['Francia' 37.0 77000.0]] 

¿Cómo extraer la variable dependiente?

También puede utilizar la función “iloc []” para extraer la variable dependiente. Así es como lo escribes:

y = data_set.iloc [:, 3] .values  

Esta línea de código considera todas las filas con la última columna solamente. Al ejecutar el código anterior, obtendrá la matriz de variables dependientes, así: 

array (['No', 'Sí', 'No', 'No', 'Sí', 'Sí', 'No', 'Sí', 'No', 'Sí'],

      dtype = objeto)

4. Identificar y manejar los valores faltantes

En el preprocesamiento de datos, es fundamental identificar y manejar correctamente los valores faltantes; si no lo hace, es posible que extraiga conclusiones e inferencias inexactas y erróneas a partir de los datos. No hace falta decir que esto obstaculizará su proyecto de ML. 

Básicamente, hay dos formas de manejar los datos faltantes:

  • Eliminación de una fila en particular : en este método, elimina una fila específica que tiene un valor nulo para una característica o una columna en particular donde faltan más del 75% de los valores. Sin embargo, este método no es 100% eficiente y se recomienda que lo use solo cuando el conjunto de datos tenga muestras adecuadas. Debe asegurarse de que después de eliminar los datos, no quede ningún sesgo adicional. 
  • Cálculo de la media : este método es útil para características que tienen datos numéricos como edad, salario, año, etc. Aquí, puede calcular la media, la mediana o la moda de una característica, columna o fila en particular que contiene un valor faltante y reemplazar el resultado para el valor faltante. Este método puede agregar variación al conjunto de datos y cualquier pérdida de datos se puede negar de manera eficiente. Por lo tanto, produce mejores resultados en comparación con el primer método (omisión de filas / columnas). Otra forma de aproximación es mediante la desviación de valores vecinos. Sin embargo, esto funciona mejor para datos lineales.


5. Codificación de los datos categóricos

Los datos categóricos se refieren a la información que tiene categorías específicas dentro del conjunto de datos. En el conjunto de datos citado anteriormente, hay dos variables categóricas: país y comprado.

Los modelos de aprendizaje automático se basan principalmente en ecuaciones matemáticas. Por lo tanto, puede comprender intuitivamente que mantener los datos categóricos en la ecuación causará ciertos problemas, ya que solo necesitaría números en las ecuaciones.

¿Cómo codificar la variable país?

Como se ve en nuestro ejemplo de conjunto de datos, la columna de país causará problemas, por lo que debe convertirla en valores numéricos. Para hacerlo, puede usar la clase LabelEncoder () de la biblioteca de aprendizaje de sci-kit. El código será el siguiente:

#Datos catgóricos  

# para variable de país  

desde sklearn.preprocessing import LabelEncoder  

label_encoder_x = LabelEncoder ()  

x [:, 0] = label_encoder_x.fit_transform (x [:, 0]) 

 Y la salida será - 

 Fuera [15]: 

  matriz ([[2, 38.0, 68000.0],

            [0, 43,0, 45000,0],

         [1, 30,0, 54000,0],

         [0, 48,0, 65000,0],

         [1, 40.0, 65222.22222222222],

         [2, 35,0, 58000,0],

         [1, 41,111111111111114, 53000,0],

         [0, 49,0, 79000,0],

         [2, 50,0, 88000,0],

        [0, 37.0, 77000.0]], dtype = objeto)

 Aquí podemos ver que la clase LabelEncoder ha codificado correctamente las variables en dígitos. Sin embargo, hay variables de país que están codificadas como 0, 1 y 2 en el resultado que se muestra arriba. Por lo tanto, el modelo ML puede asumir que existe alguna correlación entre las tres variables, lo que produce una salida defectuosa. Para eliminar este problema, ahora usaremos la codificación ficticia.

Las variables ficticias son aquellas que toman los valores 0 o 1 para indicar la ausencia o presencia de un efecto categórico específico que puede cambiar el resultado. En este caso, el valor 1 indica la presencia de esa variable en una columna en particular, mientras que las otras variables pasan a tener el valor 0. En la codificación ficticia, el número de columnas es igual al número de categorías.

Dado que nuestro conjunto de datos tiene tres categorías, producirá tres columnas con los valores 0 y 1. Para la codificación ficticia, usaremos la clase OneHotEncoder de la biblioteca scikit-learn. El código de entrada será el siguiente: 

# para variable de país  

from sklearn.preprocessing import LabelEncoder, OneHotEncoder  

label_encoder_x = LabelEncoder ()  

x [:, 0] = label_encoder_x.fit_transform (x [:, 0])  

# Codificación de variables ficticias  

onehot_encoder = OneHotEncoder (categorical_features = [0])    

x = onehot_encoder.fit_transform (x) .toarray ()

 Al ejecutar este código, obtendrá el siguiente resultado:

 matriz ([[0.00000000e + 00, 0.00000000e + 00, 1.00000000e + 00, 3.80000000e + 01,

        6.80000000e + 04],

       [1.00000000e + 00, 0.00000000e + 00, 0.00000000e + 00, 4.30000000e + 01,

        4.50000000e + 04],

       [0.00000000e + 00, 1.00000000e + 00, 0.00000000e + 00, 3.00000000e + 01,

        5.40000000e + 04],

       [1.00000000e + 00, 0.00000000e + 00, 0.00000000e + 00, 4.80000000e + 01,

        6.50000000e + 04],

       [0.00000000e + 00, 1.00000000e + 00, 0.00000000e + 00, 4.00000000e + 01,

        6.52222222e + 04],

       [0.00000000e + 00, 0.00000000e + 00, 1.00000000e + 00, 3.50000000e + 01,

        5.80000000e + 04],

       [0.00000000e + 00, 1.00000000e + 00, 0.00000000e + 00, 4.11111111e + 01,

        5.30000000e + 04],

       [1.00000000e + 00, 0.00000000e + 00, 0.00000000e + 00, 4.90000000e + 01,

        7.90000000e + 04],

       [0.00000000e + 00, 0.00000000e + 00, 1.00000000e + 00, 5.00000000e + 01,

        8.80000000e + 04],

       [1.00000000e + 00, 0.00000000e + 00, 0.00000000e + 00, 3.70000000e + 01,

        7.70000000e + 04]])

 En el resultado que se muestra arriba, todas las variables se dividen en tres columnas y se codifican en los valores 0 y 1.

¿Cómo codificar la variable comprada?

Para la segunda variable categórica, es decir, comprada, puede usar el objeto "labelencoder" de la clase LableEncoder. No estamos usando la clase OneHotEncoder ya que la variable comprada solo tiene dos categorías sí o no, las cuales están codificadas en 0 y 1.

El código de entrada para esta variable será: 

labelencoder_y = LabelEncoder ()  

y = labelencoder_y.fit_transform (y) 

La salida será - 

Salida [17]: matriz ([0, 1, 0, 0, 1, 1, 0, 1, 0, 1])

6. División del conjunto de datos

Dividir el conjunto de datos es el siguiente paso en el preprocesamiento de datos en el aprendizaje automático. Cada conjunto de datos para el modelo de aprendizaje automático debe dividirse en dos conjuntos separados: conjunto de entrenamiento y conjunto de prueba. 


El conjunto de entrenamiento denota el subconjunto de un conjunto de datos que se usa para entrenar el modelo de aprendizaje automático. Aquí, ya conoce el resultado. Un conjunto de prueba, por otro lado, es el subconjunto del conjunto de datos que se utiliza para probar el modelo de aprendizaje automático. El modelo ML usa el conjunto de pruebas para predecir resultados. 

Por lo general, el conjunto de datos se divide en una proporción de 70:30 o una proporción de 80:20. Esto significa que toma el 70% o el 80% de los datos para entrenar el modelo y deja fuera el 30% o 20% restante. El proceso de división varía según la forma y el tamaño del conjunto de datos en cuestión. 

 Para dividir el conjunto de datos, debe escribir la siguiente línea de código: 

from sklearn.model_selection importar train_test_split  

x_train, x_test, y_train, y_test = train_test_split (x, y, test_size = 0.2, random_state = 0)  

Aquí, la primera línea divide las matrices del conjunto de datos en subconjuntos de prueba y tren aleatorio. La segunda línea de código incluye cuatro variables:

  • x_train - características para los datos de entrenamiento
  • x_test - características para los datos de prueba
  • y_train - variables dependientes para los datos de entrenamiento
  • y_test - variable independiente para probar datos

Por tanto, la función train_test_split () incluye cuatro parámetros, los dos primeros de los cuales son para matrices de datos. La función test_size especifica el tamaño del conjunto de prueba. Test_size puede ser .5, .3 o .2; esto especifica la relación de división entre los conjuntos de entrenamiento y de prueba. El último parámetro, "random_state" establece la semilla para un generador aleatorio para que la salida sea siempre la misma. 

7. Escala de funciones

El escalado de funciones marca el final del preprocesamiento de datos en Machine Learning. Es un método para estandarizar las variables independientes de un conjunto de datos dentro de un rango específico. En otras palabras, la escala de características limita el rango de variables para que pueda compararlas en términos comunes.

Considere este conjunto de datos, por ejemplo: 

En el conjunto de datos, puede observar que las columnas de edad y salario no tienen la misma escala. En tal escenario, si calcula dos valores cualesquiera de las columnas de edad y salario, los valores de salario dominarán los valores de edad y arrojarán resultados incorrectos. Por lo tanto, debe eliminar este problema realizando un escalado de funciones para Machine Learning.

La mayoría de los modelos ML se basan en la distancia euclidiana, que se representa como:

Puede realizar el escalado de funciones en Machine Learning de dos formas:

Estandarización

Normalización

Para nuestro conjunto de datos, usaremos el método de estandarización. Para hacerlo, importaremos la clase StandardScaler de la biblioteca sci-kit-learn usando la siguiente línea de código:

from sklearn.preprocessing import StandardScaler  

El siguiente paso será crear el objeto de la clase StandardScaler para variables independientes. Después de esto, puede ajustar y transformar el conjunto de datos de entrenamiento con el siguiente código:

st_x = Escalador estándar ()  

x_train = st_x.fit_transform (x_train) 

Para el conjunto de datos de prueba, puede aplicar directamente la función transform () (no necesita usar la función fit_transform () porque ya está hecha en el conjunto de entrenamiento). El código será el siguiente: 

x_test = st_x.transform (x_test) 

La salida para el conjunto de datos de prueba mostrará los valores escalados para x_train y x_test como:



Todas las variables de la salida se escalan entre los valores -1 y 1.

Ahora, para combinar todos los pasos que hemos realizado hasta ahora, obtiene: 

 

# importando bibliotecas  

import numpy as nm  

import  matplotlib.pyplot as  mtp  

import  pandas as  pd  

  

#importación de conjuntos de datos  

data_set = pd.read_csv ('Dataset.csv')  

  

# Extraer variable independiente  

x = data_set.iloc [:,: -1] .values  

  

# Extraer variable dependiente  

y = data_set.iloc [:, 3] .values  

  

# manejo de datos faltantes (Reemplazo de datos faltantes con el valor medio)  

from sklearn.preprocessing import Imputer  

imputador = Imputer (missing_values ​​= 'NaN', estrategia = 'media', eje = 0)  

  

# Ajuste del objeto imputer a las variables independientes x.   

imputerimputer = imputer.fit (x [:, 1: 3])  

  

# Reemplazo de datos faltantes con el valor medio calculado  

x [:, 1: 3] = imputer.transform (x [:, 1: 3])  

  

# para variable de país  

from sklearn.preprocessing import LabelEncoder, OneHotEncoder  

label_encoder_x = LabelEncoder ()  

x [:, 0] = label_encoder_x.fit_transform (x [:, 0])  

  

# Codificación de variables ficticias  

onehot_encoder = OneHotEncoder (categorical_features = [0])    

x = onehot_encoder.fit_transform (x) .toarray ()  

  

#encoding para variable comprada  

labelencoder_y = LabelEncoder ()  

y = labelencoder_y.fit_transform (y)  

  

# Dividir el conjunto de datos en conjunto de entrenamiento y de prueba.  

from sklearn.model_selection import train_test_split  

x_train, x_test, y_train, y_test = train_test_split (x, y, test_size = 0.2, random_state = 0)  

  

#Feature Escalado de conjuntos de datos  

from sklearn.preprocessing import StandardScaler  

st_x = Escalador estándar ()  

x_train = st_x.fit_transform (x_train)  

x_test = st_x.transform (x_test)  


Así ha sido como se pre procesan los datos.  


Empiece a escribir aquí...

Compartir
Identificarse dejar un comentario
Trucos panda
Un lugar para recordar
/*
*/