Cargar y escalar un conjunto de datos (Dataset)
En este post vamos a ver cómo tratar un conjunto de datos (dataset) desde el principio para tratarlo con algoritmos de Machine Learning. Partiremos con un archivo .csv (valores separados por comas) que es bastante común en ML, todas sus columnas ya están con valores numéricos, excepto las etiquetas que son cadenas de caracteres.
Vamos a crear un modelo de clasificación utilizando la biblioteca scikit-learn y el lenguaje Python 3 sobre un cuaderno de notas de Jupyter. Primero, desactivaremos las advertencias. Pues es posible que aparezcan algunas advertencias debido a que las bibliotecas que usaremos a su vez tienen dependencias de otras bibliotecas que pueden quedar obsoletas.
import
warnings
warnings.filterwarnings('ignore')
Importamos la biblioteca pandas que utilizaremos para cargar los datos de un archivo CSV en un Dataset de pandas.
import pandas as pd
quinielas = pd.read_csv('Escalar_Dataset_Curso.csv')
Estamos cargando este archivo 'Escalar_Dataset_Curso.csv' en un conjunto de datos (dataset) y esto se hace usando la función read_csv en pandas.
Podemos obtener una vista previa de su contenido usando la función head.
quinielas.head()
Y lo que contiene este conjunto de datos es información sobre los resultados de los partidos. La idea es predecir el resultado adaptado a las quinielas, 1, X o 2. Los nombres de los equipos ya se han traducido a datos numéricos.
Las características del dataset incluyen representaciones numéricas excepto en las etiquetas. Las etiquetas de este conjunto de datos incluyen el resultado del partido en formato 1, X, 2. Hay algunas columnas que posiblemente no las necesitemos para construir un buen modelo de clasificación.
Antes de comenzar examinaremos el conjunto de datos comenzando con el número total de registros. Para esto, usaremos la función le, y vemos que en nuestro caso particular tenemos 36147 registros con los que trabajar.
quinielas.le
Recortaremos algunas características de este conjunto de datos, con lo que haremos uso de la función drop de pandas.
Así por ejemplo el IdPartido no es relevante para el resultado, entonces, como argumento, especificamos todas las columnas del dataset que deben eliminarse, y especificamos estas nueve columnas aquí. Aunque parezca contraproducente, hay que eliminar también las columnas de los resultados de los partidos, pues lo que realmente nos interesa es obtener el valor de la quiniela, 1,X, 2 y si no eliminamos esa información, el modelo será capaz de ‘prececir’ el 100% de los valores 1, X, 2 basándose en el número de goles de cada y lo que queremos es predecir estos valores antes del partido, es decir, antes de conocer los goles.
La guía real para predecir la quiniela, serán entonces las etiquetas, 1, X,2 de resultados pasados y el código del equipo que juega. El modelo deberá establecer que equipos tienen más o menos probabilidades de ganar, perder o empatar contra otros equipos.
quinielas.drop(['idPartido','golesLocal','golesVisitante'],axis = 1, inplace = True)
quinielas.head()
Para asegurarnos de que son las columnas las que se eliminan, especificamos que el argumento para el eje es = 1. Y al establecer el argumento inplace a True, el conjunto de datos (dataset) original se modificará con las columnas eliminadas. Podemos examinar las primeras cinco filas usando la función head una vez más.
Y lo que nos queda son seis columnas en total. Estas incluyen las cinco columnas de características, y la etiqueta al final que es la llamada Quiniela. Podemos ver los diferentes valores de las etiquetas 1,X y 2. Todas las columnas de este conjunto de datos en particular son numéricas. Pero los valores de la etiqueta (Quiniela) están en forma de cadenas de caracteres. Los algoritmos de aprendizaje automático no pueden trabajar con estos datos de cadena directamente, por lo que necesitaremos transformar esta columna de Quiniela en forma numérica. Esto es lo que haremos al codificar la etiqueta de la columna de clase.
Para eso, importaremos la clase LabelEncoder de la biblioteca de preprocesamiento scikit-learn. Y luego inicializaremos este LabelEncoder con todos los valores predeterminados para no definir explícitamente ningún parámetro. A continuación, para etiquetar y codificar la columna de clase de nuestro dataset simplemente lo pasaremos como un argumento con el método de transformación de ajuste de LabelEncoder.
import
sklearn
from
sklearn.preprocessing import
LabelEncoder
le = sklearn.preprocessing.LabelEncoder()
#quinielas['Quiniela'] =
le.fit_transform(quinielas['Quiniela'].astype(str))
quinielas.head()
Hay que tener en cuenta que estamos lanzando las etiquetas originales como tipo cadena.
LabelEncoder necesita trabajar con tipos de cadenas para realizar una codificación. Una vez hemos codificado la etiqueta de la columna de clase de nuestro dataset, obtenemos una vista previa de su contenido una vez más. Podemos ver que la columna Quiniela contiene números en lugar de los valores de cadena originales.
Este resultado muestra que hay tres clases diferentes de resultado de Quiniela, el 1, X, 2 se ha traducido por 0,1,2 en el nuevo conjunto de datos. Esto, nos da un punto de referencia para el modelo de clasificación. Si tuviéramos que hacer conjeturas aleatorias para cada resultado, deberíamos esperar obtener una precisión de 33% dado que hay tres opciones diferentes. Nuestro modelo debe funcionar significativamente mejor que esto al hacer sus predicciones. También hay que tener en cuenta que los datos no son completamente aleatorios, con lo que en realidad la distribución de las frecuencias en el dataset vienen del siguiente modo: la del 1 es del 51%, la de la X del 27% y la del 2 del 22%
quinielas['Quiniela'].unique()
Nos devuelve la lista de valores que se han asignado a las etiquetas, en nuestro caso, 0,1y 2.
X = quinielas.drop('Quiniela', axis=1)
Y = quinielas['Quiniela']
Así que definimos las variables X como todas las columnas del dataset de quinielas excepto la columna con la Quiniela (la etiqueta), razón por la que hemos utilizado la instrucción drop. Estas serán todas nuestras características de entrada.
Definimos una variable Y como la columna de las etiquetas, en nuestro caso Quiniela. Así que ahora tenemos cinco funciones de entrada que representan varios detalles sobre las quinielas. Y estos se utilizarán para predecir un valor de Y que representa el resultado final.
Ahora que nuestro conjunto de datos se ha preparado y todas nuestras características de entrada son valores numéricos continuos, podemos seguir adelante y escalar todas estas características de entrada. Para eso, hacemos uso del módulo de preprocesamiento en la biblioteca scikit-learn, y luego hacemos uso de su función de escala para escalar todas nuestras características de entrada.
from sklearn import preprocessing
X=preprocessing.scale(X)
from
sklearn.model_selection import
train_test_split
El escalar que se utilizará para realizar esto será el escalar estándar. El escalar estándar tendrá el efecto de ajustar los valores en cada una de las columnas del dataset de manera independiente, de modo que cada distribución tenga una media cero y una unidad de varianza y desviación estándar. Y una vez que hayamos escalado todas las características de entrada, dividiremos nuestro conjunto de datos en conjuntos de prueba y de entrenamiento. Para eso, hacemos uso de la función de división de prueba de entrenamiento disponible en la biblioteca scikit-learn.
x_train, x_test,y_train,y_test = train_test_split(X,Y,test_size=0.2,random_state=1)
Los argumentos que le pasamos incluyen todas nuestras características de entrada de escala, esta es la variable Y. También podemos especificar el tamaño de nuestro conjunto de entrenamiento. Vemos que el 20% del conjunto de datos debe usarse para pruebas y el 80% restante se usará con fines de entrenamiento. Los datos de entrenamiento y prueba estarán disponibles en las variables x_train, x_test, y_train e y_test. Con todos los datos de prueba y entrenamiento listos, podemos seguir adelante y construir nuestro modelo de clasificación.
Detectando correlaciones en un conjunto de datos (dataset)
Hemos preparado previamente nuestro conjunto de datos de quinielas, de modo que contenga cinco características de entrada que son valores numéricos continuos. Luego pasamos a realizar un escalado estándar para estandarizar esas variables continuas. Y también etiquetamos y codificamos la columna de Quiniela de nuestro dataset. A continuación, hemos dividido nuestro conjunto de datos en componentes de entrenamiento y prueba, donde los datos de entrenamiento son el 80% del conjunto de datos y el 20% se utilizará para las pruebas. Ahora podemos usar esos datos para construir un modelo de clasificación.
Para entrenar este clasificador. Para ello le pasaremos nuestros datos de entrenamiento, las variables x_train e y_train. Estos datos de entrenamiento se pasan al método de ajuste del clasificador de vectores de soporte.
from sklearn.svm import SVC
svc_clf =SVC()
svc_clf.fit(x_train,y_train)
Una vez que el modelo está listo, podemos comenzar a evaluarlo con los datos de prueba.
accuracy=
svc_clf.score(x_test,y_test)
print(accuracy)
Para eso, utilizamos la función score a la que pasamos las variables _test, que son las características de entrada de los datos de prueba, así como los valores reales de las etiquetas en los datos de prueba. La variable x_test que contiene todas las características de entrada será utilizada por el clasificador de vectores de soporte para hacer predicciones. Estas predicciones luego se compararán con la variable y_test, que contiene todos los valores reales. El valor devuelto por la función de puntuación (score) será la precisión del modelo. ¿Cuántas predicciones coincidieron realmente con los valores reales?
La precisión que obtenemos aquí es de 0.50 o aproximadamente 50%. Cuando se considera que había tres clases, las suposiciones a ciegas nos habrían dado una precisión de aproximadamente del 33%, pero al tener una parte predecible nos da una precisión del 50% en este caso es, de hecho, un rendimiento bastante mediocre, pues es lo que acierta cualquier persona con ciertos criterios al hacer una quiniela.
import matplotlib.pyplot as plt
import seaborn as snb
Hecho esto, para ver los valores de correlación entre todas las características en nuestro marco de datos, podemos hacer uso de la función corr. Esto devolverá una matriz de correlación, donde cada una de las características de nuestro conjunto de datos se emparejará con cada una de las demás, y luego se mostrarán los valores de correlación correspondientes.
corr = quinielas.corr()
corr
Podemos ver exactamente cómo se ve esta matriz de correlación, y podemos ver todos los valores de correlación. De modo que tenemos todas las características representadas a lo largo de las filas y columnas. Cada una de las celdas representa los valores de correlación para los pares de características correspondientes representados en la fila y la columna. Los valores de correlación van de menos 1 a más 1. Un valor negativo implica una correlación negativa, donde el aumento de un valor corresponde a una disminución del otro. Un valor de correlación positivo sugiere que un aumento en el valor de una característica da como resultado un aumento en la otra también.
Un problema con esta matriz de correlación es que contiene muchos números y hace difícil juzgar qué par de características están altamente correlacionadas. Por esa razón, ahora generaremos un mapa de calor. En una matriz de correlación con colores que se utilizan para indicar el grado de correlación.
Generamos una figura matplotlib, y luego la función de mapa de calor, cuyos argumentos incluyen la propia matriz de correlación, así como una serie de argumentos para formatear el mapa de calor. Esto representará una matriz de correlación de una manera mucho más intuitiva.
plt.figure(figsize=(12,7))
snb.heatmap(corr, vmax=0.8,square=True,annot=True,fmt='.2f',cmap=('inferno'))
plt.show
Los colores más claros, representan valores altamente correlacionados positivamente. Mientras que los colores oscuros representan valores correlacionados negativamente. También podemos ver los números de correlación dentro de cada una de las celdas. Y podemos ver claramente si hay una serie de características en nuestro conjunto de datos que están fuertemente correlacionadas. En nuestro caso apenas hay correlación (la diagonal no cuenta porque es la correlación de cada columna consigo misma) por que ya hemos eliminado del dataset los goles, que era la característica altamente correlacionada, pero si se nos hubiera escapado alguna columna , aquí la veríamos claramente.
Si hubiéramos encontrado muchas características transmitiendo de hecho la misma información. No es necesario que los incluyéramos todos al crear nuestro modelo de aprendizaje automático. Una forma de manejar situaciones en las que tenemos características altamente correlacionadas es eliminar manualmente algunas de las columnas que están altamente correlacionadas con otras. Esta técnica, no es eficaz además en las características fuertemente correlacionadas, es posible que no esté del todo claro cuál de esas características tiene una fuerte relación de causa y efecto con el valor que estamos tratando de predecir.
En este caso, existe un grave riesgo de que terminemos eliminando la columna que explica en gran medida la variación subyacente en nuestros datos. Para evitarlo, podemos emplear la técnica de análisis de componentes principales que exploraremos en el siguiente post
No hay comentarios:
Publicar un comentario