Manejo de Conjuntos de datos (Datasets) para Machine Learning II

 Análisis de componentes principales PCA

Cuando tenemos varias características en nuestro conjunto de datos que están fuertemente correlacionadas entre sí. Y no está claro cuál de estas características es, de hecho, el mejor predictor del resultado que estamos tratando de predecir. Entonces podemos emplear la técnica del análisis de componentes principales. El análisis de componentes principales, o PCA, se puede definir como un procedimiento matemático, el cual puede transformar un número de variables correlacionadas en un número menor de variables no correlacionadas que se denominan componentes principales. Cuando se pasa de una gran cantidad de dimensiones (columnas con datos)  a una menor cantidad de componentes principales. Lo que se ha efectuado se llama reducción de dimensionalidad. A continuación veremos un ejemplo de  cómo funciona esto usando scikit-learn. Para aplicar el análisis de componentes principales, invocamos la clase PCA desde el módulo decomposition scikit-learn.

from sklearn.decomposition import PCA

pca = PCA (n_components = 3, whiten = True)

Podemos inicializar este modelo PCA pasando algunos parámetros. Primero, especificamos el número de componentes principales que necesitamos usar. Nuestros datos de entrada originales contienen ocho características. Y reduciremos esto a un total de tres (por ejemplo) componentes principales. El parámetro whiten se usa para asegurar salidas no correlacionadas, y lo configuramos como True.

Ajustamos este modelo PCA con nuestros datos de entrenamiento.

x_reduced = pca.fit_transform(X)

Hacemos uso del método fit_transform. Y pasamos todos los datos X que contienen todos los valores escalados para nuestras características de entrada.

El valor devuelto por fit_transform incluirá los tres componentes principales para cada uno de los puntos de datos en nuestro conjunto de datos. Por tanto, esta variable se denominará x_reduced. Una vez que nuestro modelo PCA se ha ajustado a nuestros datos de entrada, podemos hacer uso de su campo explained_variance_. Para ver la cantidad de variación que se explica por cada uno de los componentes principales.

pca.explained_variance_

Lo que obtenemos aquí es una matriz, y podemos ver que el primer componente principal explica buena parte de la varianza. Aunque el resto de componentes también tienen valores próximos. 

En vez de mirar estos números de varianza sin procesar, podemos hacer uso del campo explained_variance_ratio en el modelo PCA. Para ver qué proporción de la varianza subyacente es capturada por cada uno de los componentes principales.

pca.explained_variance_ratio_

Una vez lo que ejecutemos, obtenemos una matriz más y podemos ver aquí que el primer componente principal de hecho explica aproximadamente el 17 % de la varianza total. Mientras que el último componente principal explica solo la mitad del 12% de la varianza. Hay que tener en cuenta aquí que cada uno de estos componentes principales está organizado en el orden de varianza explicada.

 

Una vez tenemos estos números de varianza, podemos generar un gráfico donde trazamos una línea para cada uno de los componentes principales y sus variaciones explicadas.Hacemos uso de la función de diagrama de Matplotlib, y luego le pasamos la matriz.

plt.plot (pca.explained_variance_ratio_)

Y formateamos el gráfico de modo que haya etiquetas para los ejes x e y.

plt.xlabel ('Dimensión')

plt.ylabel ('Explicar varias proporciones')

plt.show ()

Ahora podemos visualizar muy claramente la caída en la varianza explicada para cada uno de los componentes principales. En este caso la caía no es muy significativa del primer componente principal al segundo ni del segundo al tercero.

 

Ahora que el modelo PCA ha reducido el tamaño de nuestros datos de entrada de un total de ocho columnas (o funciones o dimensiones) a tres componentes principales. Podemos construir un nuevo modelo de clasificación utilizando estos componentes principales.

x_train, x_test, y_train, y_test = train_test_split(x_reduced, Y, test_size = 0.2, random_state = 1)  

Una vez más hemos hecho uso de la función train_test_split. Y en esta ocasión pasamos la variable x_reduced que contiene estos componentes principales en el lugar de la X. Todo lo demás es exactamente igual que antes, donde pasamos nuestras variables Y y especificamos un tamaño de conjunto de prueba del 20% del conjunto de datos. 

Después inicializamos un clasificador de vectores de soporte. También en esta ocasión, no especificamos ningún parámetro para este clasificador y simplemente usamos los valores predeterminados.

svc_clf_pca = SVC()

svc_clf_pca.fit(x_train, y_train)

Utilizaremos el método de ajuste del clasificador SVC para entrenar nuestro modelo. Y  le pasamos las variables de entrenamiento x e y. En esta ocasión, el x_train contiene las tres componentes principales en lugar de ocho. Después de esto, nuestro entrenamiento del modelo está completo.

accuracy = svc_clf_pca.score(x_test, y_test)

print(accuracy)

Hacemos uso de la función score una vez más a la que pasamos en nuestros datos de testeo. Y nos devuelve una precisión de alrededor del 98%. Este valor tan cercano a 1 es porque en nuestro dataset están las “respuestas” por tanto es muy fácil predecir. Para tener valores reales tendríamos que eliminar directamente los goles, pues se trata de un dataset con resultados de partidos de fútbol. A pesar de reducir las dimensiones en nuestra entrada, hemos obtenido casi la misma precisión que si no lo hubiésemos reducido 100% en este caso. Esto sugiere que nuestro nuevo modelo será más robusto porque es menos susceptible a problemas causados por los valores correlacionados.

 ¿Qué pasaría si redujéramos aún más el número de componentes principales?

pca = PCA (n_components = 2, whiten = True)

incluso con dos componentes principales, todavía obtenemos una precisión de aproximadamente el 82%. (sobre 100%) vemos que no es tan preciso como tener tres componentes principales u ocho características de entrada.

Así que hemos visto cómo podemos reducir el número de dimensiones en nuestros datos de entrada y aun así obtener resultados muy precisos de nuestro modelo. Nuestro conjunto de datos solo contenía unos miles de filas. Si tuviéramos muchos más la precisión debería mejorar aún más.

Normalizar un conjunto de datos (dataset)

Anteriormente, usamos un escalar estándar para escalar todas las columnas de características en el conjunto de datos de resultados de los partidos para hacer una quiniela (hemos utilizado un dataset diferente; En la primera parte utilizamos una sola etiqueta de caracteres para representar 1,X,2 y ahora utilizamos tres columnas de etiquetas binarias, Q1; 1 para 1 y 0 para el resto, QX; 1 para la X y 0 para el resto y Q2; 1 para el 2 y 0 para el resto, lo mismo para los resultados del quinigol que representan los valores del quinigol; QGC0 ; 1 si el equipo local mete cero goles y 0 para el resto, QGC1; 1 si mete un gol, QGCM; 1 si mete más de dos goles, ídem para el visitante.

Después aplicamos la técnica de análisis de componentes principales, con el fin de reducir el número de dimensiones en nuestros datos de entrada. A continuación utilizaremos un normalizador en lugar de un escalador estándar en nuestras funciones de entrada y veremos cómo afecta esto a la precisión de nuestro modelo. Comenzamos importando la clase Normalizer de la biblioteca de preprocesamiento scikit-learn. Y también importamos la biblioteca NumPy.

import numpy as np

from sklearn.preprocessing import Normalizer

vemos cómo se ve el conjunto de datos de quinielas. Eliminamos todas las columnas de etiquetas.

x_datos = quinielas.drop(['Q1','QX','Q2','QGC0','QGC1','QGC2','QGCM','QGF0','QGF1','QGF2','QGFM'], axis = 1)

q1_datos = quinielas['Q1']

qx_datos = quinielas['QX']

q2_datos = quinielas['Q2']

x_datos.head()

 

Aquí vemos que el dataset contiene cinco características y once etiquetas (que hemos eliminado), que son las columnas que comienzan por Q. Nos quedamos con las  cinco características o columnas después de eliminar las columnas de etiquetas. 

Para aplicar el normalizador en nuestras columnas de características, ahora redefiniremos nuestros datos x e y.

Los datos x incluirán las columnas en nuestro Dataset de quinielas sin las  etiquetas (las columnas de quinielas que empiezan por Q). Hemos utilizado la función drop para eliminarlas. Los datos y, solo incluyen las columnas de etiquetas, en este caso Q1, QX y Q2 para simplificar, aunque podríamos haber incluido las otras. 

Antes de aplicar el normalizador a nuestros datos de entrada, necesitamos transformarlo en una matriz NumPy. Para hacer eso, podemos hacer uso del campo de valores de este Dataset. cuando ejecutamos la celda, nos queda una matriz de valores.

array = x_datos.values

array

Podemos ver su contenido. Vemos que tiene todos los datos en las celdas del Dataset. A continuación, aplicamos el normalizador a estos datos, lo inicializamos con los valores predeterminados. Y luego, utilizamos el método de ajuste del normalizador, al que alimentamos con la matriz que contiene todos los datos de características de nuestro conjunto de datos de quinielas.

scaler = Normalizer().fit(array)

scaler

El normalizador trabajará en cada una de las filas de nuestro conjunto de datos de forma independiente. Es decir, trabaja sobre una base transversal en lugar de una base longitudinal. Una vez que ejecutamos esta celda, nos queda un normalizador, que se ha ajustado a todos nuestros datos de entrada.

Podemos ver este normalizador. Y vemos los parámetros con los que se ha inicializado.

Confirmamos estos parámetros examinando el método get_params.

scaler.get_params 

Transformamos el contenido de la matriz de entrada haciendo uso del método de transformación del normalizador.

Normalized_array = scaler.transform(array)

Esto tendrá el efecto de normalizar todas las características de nuestro conjunto de datos en cada fila de forma individual. Podemos echar un vistazo a cómo se ve este conjunto de datos normalizado. Y dado que todos los valores estarán entre 0 y 1 y se extenderán a múltiples dígitos más allá del punto decimal, estableceremos un valor de precisión de 3, utilizando el método set_printoptions de NumPy. Después, imprimiremos las primeras cinco filas de nuestra matriz normalizada.

np.set_printoptions(precision = 3)

print(array_Normalizado[0:5,:])

Podemos usar estos datos normalizados para construir un modelo de clasificación. Sin embargo, antes de esto, necesitaremos cargar el contenido en un DataFrame de pandas.  Y si queremos redondear el contenido de todo el DataFrame a dos lugares decimales, podemos hacer uso de la función de redondeo aquí, donde el primer argumento es el DataFrame completo.

DataFrame_Normalizado = round(pd.DataFrame(data=array_Normalizado),2)

Después de esto, podemos establecer los encabezados de columna para este DataFrame que acabamos de crear.

nombres_columnas = ['temporada', 'division', 'jornada', 'EquipoLocal', 'EquipoVisitante']

Estos son los mismos encabezados de columna que existían en el Dataset original. Para asignar estos encabezados de columna al DataFrame que hemos creado, podemos establecer el campo de columnas de ese DataFrame en esta lista de columnas que acabamos de crear.

DataFrame_Normalizado.columns = nombres_columnas

 

Ahora que tenemos todas las características normalizadas dentro de un DataFrame, podemos considerar combinar las características normalizadas con las etiquetas correspondientes. Para que tengamos ambas funciones y las etiquetas dentro del mismo DataFrame. Podemos hacer uso de la función pandas concat para eso.

DataFrame_Normalizado = pd.concat([DataFrame_Normalizado,q1_datos,qx_datos,q2_datos], axis = 1)

DataFrame_Normalizado.head()

 

Ahora podemos ver todas las características normalizadas y a qué etiquetas corresponden. Pasamos a definir nuestros datos de entrenamiento y prueba. Pero antes definiremos variables separadas para nuestros datos x e y. Los datos x incluirán todas las características normalizadas, mientras que los datos y solo incluirán las columnas de las etiquetas de nuestro DataFrame.

X = DataFrame_Normalizado.drop(['Q1','QX','Q2'], axis=1)

Y1 = DataFrame_Normalizado['Q1']

YX = DataFrame_Normalizado['QX']

Y2 = DataFrame_Normalizado['Q2']

Después de esto, dividimos los datos en conjuntos de prueba y de entrenamiento usando la función train_test_split una vez más.

x_train,x_test,y1_train,y1_test = train_test_split(X,Y1,test_size=0.2,random_state=1)

x_train,x_test,yx_train,yx_test = train_test_split(X,YX,test_size=0.2,random_state=1)

x_train,x_test,y2_train,y2_test = train_test_split(X,Y2,test_size=0.2,random_state=1)

Definimos el clasificador de vectores de soporte lineal SVC. Una vez que inicializamos el clasificador, utilizando parámetros predeterminados, ajustaremos el clasificador a nuestros datos de entrenamiento.

svc_clf = SVC()

svc_clf.fit(x_train, y1_train)

 

Pasamos x_train e y1_train a este método de ajuste. Y en unos segundos, el modelo debería estar listo. Ahora podemos comenzar a evaluar este modelo. Y para eso, utilizamos el método de puntuación del clasificador, con el fin de verificar la precisión de las predicciones de este modelo con los datos de prueba.

svc_clf.fit(x_train, y1_train)

accuracy = svc_clf.score(x_test, y1_test)

print (accuracy)

svc_clf.fit(x_train, yx_train)

accuracy = svc_clf.score(x_test, yx_test)

print (accuracy)

svc_clf.fit(x_train, y2_train)

accuracy = svc_clf.score(x_test, y2_test)

print (accuracy)

 

Y lo que obtenemos es una precisión de aproximadamente el 50,6% para los unos. Así que no está mal, aunque no particularmente bueno. Para las X es del 71,8 cual está muy bien para las X. Pero mucho ojo, no nos llevemos a engaño con esto, en realidad esto una clasificación binaria, si tenemos en cuenta que sólo el 27% de los valores son X, el resto es el 73% (n realidad tenemos un 27% de X y un 73% de no X) por tanto un 72% de aciertos significa que el 72% de las veces acierta si no es X tanto como si es X. Es como decir que si siempre ponemos no X, acertaremos el 73% de las veces, lo cual no es un gran avance.

Lo mismo sucede con los doses, un 78,8 % para los 2 tampoco nos esclarece mucho pues es la misma probabilidad de acierto que si siempre ponemos no 2.

Un normalizador es una mejor opción cuando realizamos agrupaciones en clústeres o clasificación de texto. Y esto no es necesariamente un buen ajuste para el modelo de clasificación que estamos tratando de construir aquí.

Pero en esta ocasión pasaremos algunos parámetros. No entraremos en detalles de cada uno de estos parámetros. Pero hay que saber que podemos ajustar los parámetros de nuestro modelo, para ver si eso mejora su rendimiento al hacer predicciones. Con este modelo SVC inicializado, podemos entrenarlo ajustándolo a los datos de entrenamiento. Y ahora nuestro modelo SVC está listo.

x_train,x_test,y1_train,y1_test = train_test_split(X,Y1,test_size=0.2,random_state=0)

slv_clf_mod = SVC(random_state=5,tol=1e-3, C=1)

slv_clf_mod.fit(x_train,y1_train)

accuracy = slv_clf_mod.score(x_test, y1_test)

print (accuracy)

Así que es hora de que examinemos su precisión con los datos de prueba con la reducción de tolerancia que hemos hecho, para ver si esto mejora la precisión.

Como podemos ver, para el 1, la precisión es del 56,8 % prácticamente igual que antes, incluso peor, lo cual nos indica que este cambio de tolerancia no beneficia nuestra precisión de aciertos en nuestro modelo.

AWS in a nutshell 17. Administración de VPC

Administración VPC 

Vamos a explorar la conectividad VPC, la forma de habilitar la conectividad a AWS a través de VPN, conexión directa y tránsito VPC en las puertas de enlace NAT. ¿Cómo configurar la conexión VPN de sitio a sitio? ¿Cómo configurar un punto final VPN de cliente y cómo ver la propagación de la tabla de ruta? También hay que saber cuándo se deben aprovisionar los circuitos de Direct Connect y configurar AWS Direct Connect.

Cómo permitir el tráfico saliente de IPv6 usando una puerta de enlace de Internet de solo salida. Como usar las puertas de enlace de tránsito VPC para vincular múltiples VPC. Y como crear una política personalizada de punto final de VPC.

17.1 Soluciones VPN 

Una red privada virtual, o VPN, se utiliza para conectarse de forma segura a través de una red no confiable, como Internet, a una red de destino en otro lugar. Es un túnel de red punto a punto encriptado. Para hacer esto, necesitamos tener un dispositivo VPN.  Puede ser hardware o software que se ejecuta en un host que permite la conectividad VPN. También necesitamos una dirección IP pública.

17.2 Configuración VPN de punto a punto

En AWS, podemos configurar una VPN punto a punto para vincular y en la red local a la nube de AWS. Este tipo de VPN es una VPN IPsec que usa el protocolo IP tipo 50 y también el puerto UDP 500 o IKE.

Desde la consola de administración de AWS. Ponemos VPC y sobre el panel en la parte VPN pulsamos Customer Gateways

17.3 Puntos finales de VPN de cliente

Si bien las VPN punto a punto funcionan bien cuando necesitamos conectar una red completa, por ejemplo, un grupo de dispositivos en una red local en una VPC de nube de AWS. Sin embargo, hay ocasiones en las que necesitaremos un tipo de instancia única de conectividad VPN. Como para los usuarios que trabajan en casa o los empleados que viajan por trabajo que necesitan un enlace seguro a través de Internet, ese es el túnel VPN para conectarse de forma segura a AWS.

En la consola de administración escribimos acm y pulsamos sobre certificate manager para ver los certificados.

Volvemos a la consola y ponemos VPC → VPN → Client VPN endpoints

17.4 Propagación de tabla de ruta

Es donde se configura la tabla de ruta en AWS para tener una idea de la propagación de la tabla de ruta. La propagación de la tabla de rutas es importante para que el enrutamiento funcione correctamente, como en las conexiones VPN de sitio a sitio. Para que los clientes en un lado del túnel sepan que si desean enviar tráfico a una red de destino específica, se enrutará a través de nuestro punto final VPN local.

Consola → VPC → Your VPCs

Consola → VPC → Route tables

17.5 AWS Direct Connect  

La comunicación a través de Internet no es la única forma de conectarse a la nube de AWS. Otra opción es usar AWS Direct Connect. Esto es un circuito de red privada dedicado, lo que significa que tenemos nuestro propio tipo de enlace de comunicación que no atraviesa Internet. Vinculamos nuestra red local directamente a una VPC de AWS. Ahora, al no atravesar Internet, esto significa que tenemos un enlace de red privado o dedicado, también llamado Circuito de red.

17.6 AWS  Aprovisionar un nuevo circuito de conexión directa

Para ello desde la consola de AWS tecleamos → Direct Connect

17.7 Puerta de enlace NAT

Amazon Web Services, configura una puerta de enlace NAT para permitir que las instancias EC2 que solo tienen direcciones IP privadas accedan a Internet a través de la dirección IP pública de las puertas de enlace NAT.

Consola → VPC → Nat gateways

17.7 Internet Gateway

En Amazon Web Services, dentro de una VPC podemos configurar una puerta de enlace a Internet. Y esto permite la conectividad a Internet. También permite la conectividad a instancias EC2 con IP públicas desde Internet.

Consola → VPC → Internet  Gateways

17.8 Pasarela de Internet de solo salida

Una puerta de enlace de Internet de salida de Amazon Web Services, como su nombre indica, es para comunicaciones salientes de Internet. Específicamente, está vinculado solo a las direcciones IPv6. Por lo tanto, el tráfico saliente de IPv6 a Internet, al igual que lo haríamos con IPv4 configurando una puerta de enlace NAT de AWS. Permitiría el acceso saliente a Internet, instancias EC2, solo con IP privadas, al tiempo que evitaría que se iniciaran conexiones desde Internet.

Consola → VPC → Egress-Only Internet Gateway

17.9 VPC Transit Gateways 

En Amazon Web Services, las puertas de enlace de tránsito de VPC son un componente de red crucial cuando deseamos vincular recursos en múltiples VPC. Contiene dos ubicaciones locales que pueden usar un enlace VPN punto a punto o un circuito de conexión directa que se conecta a la nube de Amazon Web Services. Específicamente, pueden hacer un enlace a la puerta de enlace de tránsito VPC que podemos considerar como un centro de comunicaciones de red.

Consola → VPC → transit gateways → transit gateways

17.10 Puntos finales de VPC (endpoints) 

Un punto final de VPC se utiliza para permitir una conexión privada desde una VPC a servicios específicos de AWS. Esto significa que el tráfico entre la VPC especificada y el servicio de AWS, digamos que es un depósito S3, no sale de la red de Amazon. Por lo tanto, no atraviesa Internet.

Por ejemplo, tenemos una instancia EC2 en una VPC privada que tiene un software que necesita comunicarse con los archivos en un depósito S3, podemos hacerlo utilizando un punto final VPC en lugar de configurar algún tipo de puerta de enlace o tipo de conexión NAT

consola → VPC → Virtual Private Cloud -> endpoints

Manejo de Conjuntos de datos (Datasets) para Machine Learning I

 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.

Ahora que todas las características, están en el formato correcto, podemos definir las variables X e Y para nuestro conjunto de datos.

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.

Sin embargo, dado que hay varias columnas diferentes disponibles en nuestro conjunto de datos. Es posible que muchos de ellos estuvieran, de hecho, muy fuertemente correlacionados entre sí. Tener características altamente correlacionadas podría afectar el rendimiento del modelo al hacer predicciones sobre datos reales. Por eso siempre es bueno recortar las características que no son necesarias. Para comprobar si hay campos en nuestro conjunto de datos que estén muy correlacionados, podemos hacer uso de una matriz de correlación. Podemos visualizar las correlaciones utilizando un mapa de calor. Para este propósito, usaremos las bibliotecas de visualización de datos matplotlib y seaborn. Así que importamos el objeto matplotlib.pyplot, así como la biblioteca seaborn a nuestro cuaderno.

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