Aprendizaje supervisado.

Parte 1
 Índice de contenidos
Definición y aplicaciones ....................................................................................................................................................... 3
Introducción ................................................................................................................................................................ 3
Tipos de aprendizaje supervisado y su aplicación ....................................................................................................... 3
Pasos básicos del aprendizaje supervisado ................................................................................................................. 7
Medidas de rendimiento ....................................................................................................................................................... 8
Introducción ................................................................................................................................................................ 8
La matriz de confusión ................................................................................................................................................ 8
Métricas creadas ....................................................................................................................................................... 11
Modelos lineales ................................................................................................................................................................. 15
Introducción .............................................................................................................................................................. 15
Regresión lineal ......................................................................................................................................................... 15
Regresión logística..................................................................................................................................................... 16
Diferencias entre la regresión lineal y logística ......................................................................................................... 16
Ejemplo regresión lineal ............................................................................................................................................ 18
Ejemplo de regresión logística .................................................................................................................................. 24
Modelos supervisados de ML: Árboles, SVM, redes neuronales ......................................................................................... 29
Arboles de decisión ................................................................................................................................................... 29
Implementación del algoritmo del árbol de decisión ................................................................................................ 30
Construir el árbol ....................................................................................................................................................... 30

Página 2 de 82
Definición y aplicaciones

Introducción

El aprendizaje supervisado es la rama de Machine Learning, que implementa un método de análisis de datos que utiliza
algoritmos que aprenden iterativamente de estos para permitir que los ordenadores encuentren información escondida sin
tener que programar de manera explícita dónde buscar. El aprendizaje supervisado es uno de los dos métodos de la forma en
que las máquinas "aprenden": supervisado y no supervisado. A su vez, es el tipo de algoritmo más frecuente. Utiliza un conjunto
de datos conocidos (denominado conjunto de datos de entrenamiento) para entrenar un algoritmo con un conjunto de datos
de entrada conocidos
(denominados características) y respuestas conocidas para realizar predicciones.

El conjunto de datos de entrenamiento incluye datos de entrada etiquetados que se emparejan con los valores de salida o de
respuesta deseados. A partir de él, el algoritmo de aprendizaje supervisado intenta crear un modelo estableciendo relaciones
entre las características y los datos de salida para realizar predicciones acerca de los valores de respuesta para un nuevo
conjunto de datos.

En ciertas ocasiones antes de aplicar el aprendizaje supervisado, el aprendizaje no supervisado se suele utilizar primero para
encontrar patrones en los datos de entrada que indiquen características potenciales; luego, la ingeniería de características las
transforma para que resulten más adecuadas para el aprendizaje supervisado.

Además de identificar las características, también se debe identificar la categoría o la respuesta correctas para todas las
observaciones del conjunto de datos de entrenamiento, que es un paso muy laborioso.

Una vez entrenado el algoritmo, se suele utilizar un conjunto de datos de prueba, que no se haya utilizado en el entrenamiento,
para predecir el rendimiento y validar el algoritmo. Para obtener resultados de rendimiento precisos, es fundamental que el
conjunto de datos de entrenamiento y el conjunto de datos de prueba sean correctos; es decir, que tanto los datos del modelo
como los del entorno de producción se hayan validado correctamente.
Tipos de aprendizaje supervisado y su aplicación

Existen dos tipos principales de aprendizaje supervisado, la clasificación y la regresión. A continuación, vamos a exponer sus
conceptos y aplicaciones.

La clasificación

La clasificación es el lugar donde se entrena a un algoritmo para clasificar los datos de entrada en variables discretas. Durante
el entrenamiento, los algoritmos reciben datos de entrada de entrenamiento con una etiqueta de “clasificación”. Por ejemplo,
Página 3 de 82
los datos de entrenamiento pueden consistir en las últimas facturas de tarjetas de crédito de un conjunto de clientes, con la
etiqueta de si realizaron una compra futura o no.

Cuando el saldo de la tarjeta de un nuevo cliente se presenta al algoritmo, este clasificará al cliente en el grupo de "comprará"
o "no comprará".

Aplicaciones prácticas de la clasificación:

• Clasificación binaria

Este algoritmo clasifica los datos de entrada en uno de dos grupos posibles. A menudo, una de las clases indica un estado
"normal/deseado" y la otra indica un estado "anormal/no deseado". Las aplicaciones prácticas de la clasificación binaria
incluyen:

Detección de spam
El algoritmo recibe ejemplos de correos electrónicos que están etiquetados como "spam" o "no spam" durante la fase de
aprendizaje supervisado. Posteriormente, cuando el algoritmo recibe una nueva entrada de correo electrónico, predice si el
correo corresponde a un "spam" o "no spam".

Predicción de migración de clientes

El algoritmo utiliza un conjunto de datos de entrenamiento de clientes que previamente cancelaron la suscripción de un
servicio. Según el entrenamiento, el algoritmo predice si un nuevo cliente finalizará la suscripción o no en función de los
parámetros de entrada.

Predicción de conversión
El algoritmo se entrena con los datos del comprador y si compró el artículo o no. Luego, basándose en esta capacitación, el
algoritmo predice si un nuevo cliente realizará una compra o no. Los principales algoritmos utilizados para la clasificación binaria
incluyen la regresión logística y las máquinas de vectores de soporte.

• Clasificación mutilase

En la clasificación multiclase, el conjunto de datos de entrenamiento se etiqueta con una de las múltiples clases posibles. A
diferencia de la clasificación binaria, un algoritmo multiclase se entrena con datos que se pueden clasificar en una de las muchas
clases posibles. Las aplicaciones para la clasificación multiclase incluyen:

Clasificación de rostros
Según los datos de entrenamiento, un modelo categoriza una foto y la asigna a una persona específica. Un detalle a tener en
cuenta aquí es que podría haber una gran cantidad de etiquetas de clase. En este caso, miles de personas.

Clasificación de correo electrónico

La clasificación multiclase se utiliza para segregar los correos electrónicos en varias categorías: social, educación, trabajo y
familia.

Los principales algoritmos utilizados para la clasificación multiclase son los bosques aleatorios, naive bayes, árbol de decisiones,
K-nearest neighbors y Gradient Boosting.

Página 4 de 82
 • Clasificación de etiquetas múltiples

A diferencia de la clasificación binaria y multiclase donde el resultado tiene solo una clase posible, la salida de etiquetas
múltiples pertenece a una o más clases, lo cual significa que los mismos datos de entrada podrían clasificarse en diferentes
compartimentos. Las aplicaciones de la clasificación de etiquetas múltiples incluyen:

Detección de fotos
En los casos en que las fotos tienen varios objetos, como un vehículo, un animal y personas, la foto podría caer en varias
etiquetas.

Clasificación de audio/video
Las canciones y los videos pueden encajar en varios géneros y estados de ánimo. Se puede utilizar la clasificación de etiquetas
múltiples para asignar estas etiquetas múltiples.

Clasificación de documentos
Es posible clasificar artículos en función de su contenido.

Clasificación con datos desbalanceados:

Este es un caso especial de clasificación binaria, donde existe un desbalance de clases en el conjunto de datos de entrenamiento.
La mayoría de los ejemplos de los datos de entrenamiento pertenecen a un conjunto y una pequeña parte pertenece al segundo
conjunto. Desafortunadamente, la mayoría de los algoritmos de Machine Learning funcionan mejor cuando existe una
distribución equitativa entre las clases.

Por ejemplo, en los datos de entrenamiento, si tenemos 10.000 transacciones de clientes genuinos y solo 100 son fraudulentas.

Para igualar la precisión, se necesitan técnicas especializadas debido al desbalance en los datos. Las aplicaciones de la
clasificación con datos desbalanceados podrían ser:

Detección de fraude
En el conjunto de datos etiquetados que se utilizan para el entrenamiento, solo una pequeña cantidad de entradas se etiquetan
como fraude.

Diagnósticos médicos
En una gran cantidad de muestras, las que tienen un caso positivo de una enfermedad podrían ser mucho menos.

Las principales técnicas a utilizar son los enfoques basados en costos y enfoques basados en muestreo para ayudar a lidiar con
casos de clasificación con datos desbalanceados.

La Regresión

La regresión es un método de aprendizaje supervisado en el que se entrena a un algoritmo para predecir una salida a partir de
un rango continuo de valores posibles. Por ejemplo, los datos de entrenamiento inmobiliario tomarán nota de la ubicación, el
área y otros parámetros relevantes, la salida será el precio de un inmueble específico.

En la regresión, un algoritmo necesita identificar una relación funcional entre los parámetros de entrada y salida. El valor de
salida no es discreto como en la clasificación, sino que es una función de los parámetros de entrada.

La exactitud de un algoritmo de regresión se calcula en función de la desviación entre la salida precisa y la salida prevista.
Página 5 de 82
Aplicaciones prácticas de la regresión:

Regresión lineal
La regresión lineal en el aprendizaje supervisado entrena a un algoritmo para encontrar una relación lineal entre los datos de
entrada y salida. Es el modelo más simple utilizado donde las salidas representan una combinación linealmente ponderada de
las salidas. La regresión lineal se puede utilizar para predecir valores dentro de un rango continuo (por ejemplo, ventas,
pronóstico de precios) o clasificarlos en categorías (por ejemplo, gato, perro,etc). En los datos de entrenamiento para la
regresión lineal, se proporcionan una variable de entrada (independiente) y una respectiva variable de salida (la variable
dependiente).
Luego, a partir de los datos proporcionados de entrada que son etiquetados, el algoritmo de regresión calcula la intersección y
el coeficiente x en la función lineal. Las aplicaciones de la regresión lineal pueden incluir:

• El pronóstico: es una de las aplicaciones más importantes de la regresión lineal. Además, puede ser de diferentes
naturalezas.

Las empresas utilizan la regresión lineal para pronosticar las ventas o los comportamientos de compra de sus clientes. También
se utiliza para predecir el crecimiento económico, las ventas de bienes raíces y los precios de productos básicos como el
petróleo. La regresión lineal también se utiliza para estimar el salario óptimo para un nuevo empleado, basándose en los datos
históricos de los salarios.

Regresión logística
Se utiliza para determinar la probabilidad de que ocurra un evento. Los datos de entrenamiento tendrán una variable
independiente, y el resultado deseado será un valor entre 0 y 1. Una vez que el algoritmo se entrena con la regresión logística,
podrá predecir el valor de una variable dependiente (entre 0 y 1) en función del valor de la variable independiente (entrada).

La regresión logística utiliza la función sigmoidea clásica en forma de S. En la regresión logística en el contexto de aprendizaje
supervisado, un algoritmo calcula los valores del coeficiente beta b0 y b1 a partir de los datos de entrenamiento proporcionados.

Probabilidad = e^(b0 + b1 * X)
Las aplicaciones de la regresión logística incluyen:

Determinación de la probabilidad
Una de las principales aplicaciones de la regresión logística es determinar la probabilidad de un evento. La probabilidad de
cualquier evento se encuentra entre 0 y 1, y ese es el resultado de una función logística. Los algoritmos de regresión logística
en Machine Learning se pueden utilizar para predecir los resultados de las elecciones, las probabilidades de un desastre natural
y otros eventos similares.

Clasificación
Aunque la regresión logística utiliza una función continua, algunas de sus aplicaciones están en la clasificación. Se puede utilizar
para la segregación de imágenes y problemas de clasificación relacionados.

Regresión polinomial

La regresión polinomial se utiliza para un conjunto de datos más complejo que no encajaría perfectamente en una regresión
lineal. Un algoritmo se entrena con un conjunto de datos complejos y etiquetados que podrían no encajar adecuadamente en
una regresión en línea recta. Si dichos datos de entrenamiento se utilizan con regresión lineal, podría causar un ajuste
insuficiente, donde el algoritmo no capturará las tendencias verdaderas de los datos.

Página 6 de 82
Las regresiones polinomiales permiten una mayor curvatura en la línea de regresión y, por lo tanto, una mejor aproximación
de la relación entre la variable dependiente y la independiente. El sesgo y la desviación son dos términos principales asociados
con la regresión polinomial. En donde:

El sesgo
Es el error en el modelado que se produce al simplificar la función de ajuste.

La desviación
También se refiere a un error causado por el uso de una función demasiado compleja para ajustar los datos.

Como hemos visto, el aprendizaje supervisado se emplea en aplicaciones financieras, para puntuación crediticia, negociación
algorítmica y clasificación; en aplicaciones de imagen y vídeo, para clasificar y rastrear objetos; en aplicaciones industriales, para
detectar valores atípicos; en mantenimiento predictivo, para estimar la vida útil de equipos industriales; en aplicaciones
biológicas, para detectar tumores y descubrir fármacos; y en aplicaciones de energía eléctrica, para pronosticar la generación
de electricidad y tarifas correspondientes. Es decir que es aplicable en todas las disciplinas.
Pasos básicos del aprendizaje supervisado

Para ejecutar y resolver un problema mediante Machine Learning supervisado, se recomienda:

Seleccionar el tipo de datos de entrenamiento

El primer paso en el aprendizaje supervisado es determinar cuál es la naturaleza de los datos que se utilizarán para el
entrenamiento. Por ejemplo, en el caso del análisis de escritura a mano, esto podría ser una sola letra, una palabra o una
oración.

Recopilar y limpiar los datos de entrenamiento

En este paso, los datos de entrenamiento se recopilan de varias fuentes y se someten a una limpieza rigurosa de datos.

Elegir un modelo utilizando un algoritmo de aprendizaje supervisado

Según la naturaleza de los datos de entrada y el uso deseado, elija un algoritmo de clasificación o de regresión.

Pueden ser árboles de decisión, SVM, Naïve Bayes o bosques aleatorios.

La consideración principal al seleccionar un algoritmo es la velocidad de entrenamiento, el uso de la memoria, la precisión de la
predicción de nuevos datos y la transparencia/interpretación del algoritmo.

Entrenar el modelo
La función de ajuste se perfecciona a través de múltiples iteraciones de datos de entrenamiento para mejorar la precisión y la
velocidad de predicción.

Realizar predicciones y evaluar el modelo

Una vez que la función de ajuste sea satisfactoria, se podrán proporcionar nuevos conjuntos de datos al algoritmo para realizar
nuevas predicciones.

Optimizar y volver a entrenar el modelo

La degradación de datos es una parte natural de Machine Learning. Por lo tanto, los modelos se deberán volver a entrenar
periódicamente con datos actualizados para garantizar la precisión.

Página 7 de 82
Medidas de rendimiento

Introducción

Como medidas de rendimiento en el aprendizaje supervisado tenemos la matriz de confusión. Ésta nos proporciona muchas
métricas que nos ayudan a evaluar nuestro modelo de clasificación.
Las diferentes medidas incluyen: exactitud, precisión, sensibilidad (Recordatorio), especificidad y la puntuación F, que se
explicarán a continuación a través de una matriz de confusión.
La matriz de confusión

La matriz de confusión

La matriz de confusión es una tabla que se utiliza en problemas de clasificación para evaluar dónde se cometieron errores en el
modelo. Esta está conformada por filas y columnas, las filas representan las clases reales que deberían haber sido los resultados.
Mientras que las columnas representan las predicciones que hemos hecho. Usando esta tabla, es fácil ver qué predicciones
están equivocadas. Las matrices de confusión se pueden crear mediante predicciones hechas a partir de una regresión logística.

A continuación, vamos a exponer un ejemplo para implementar una matriz de confusión. Por ahora, generaremos valores reales
y predichos utilizando NumPy.

1
Lo primero es crear un programa nuevo en Phyton e importar la biblioteca de Numpy:
import numpy

2
A continuación, necesitaremos generar los números para los valores "reales" y "predichos".

actual = numpy.random.binomial(1, 0.9, size = 1000)

predicted = numpy.random.binomial(1, 0.9, size = 1000)

3
Para crear la matriz de confusión, necesitamos importar métricas del módulo sklearn.
from sklearn import metrics

4
Una vez que se importan las métricas, podemos usar la función de matriz de confusión en nuestros valores reales y previstos.

confusion_matrix = metrics.confusion_matrix(actual, predicted)

5
Para crear una pantalla visual más interpretable, necesitamos convertir la tabla en una pantalla de matriz de confusión.

cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix,

display_labels = [False, True])

6
Página 8 de 82
Para visualizar la pantalla se requiere que importemos pyplot desde matplotlib.
import matplotlib.pyplot as plt

7
Finalmente, para mostrar el diagrama, podemos usar las funciones plot() y show() de pyplot.
cm_display.plot()
plt.show()

8
Quedando el código de la siguiente manera:

import numpy
import matplotlib.pyplot as plt

actual = numpy.random.binomial(1, 0.9, size = 1000)

predicted = numpy.random.binomial(1, 0.9, size = 1000)
from sklearn import metrics
confusion_matrix = metrics.confusion_matrix(actual, predicted)
cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix,
display_labels = [False, True])

cm_display.plot()
plt.show()

Al ejecutarlo tenemos como resultado el siguiente diagrama:

Página 9 de 82
Explicación del Resultado

Como podemos observar la Matriz de Confusión creada tiene cuatro cuadrantes diferentes:

Los valores de la diagonal principal a y d, se corresponden con los valores estimados de forma correcta por el modelo, tanto los
verdaderos positivos_ TP(d), como los verdaderos negativos_TN (a). Los cuales se definen como:

Verdadero negativo (TN)

Corresponde al cuadrante superior izquierdo.

Falso negativo (FN)

Corresponde al cuadrante superior derecho.

Falso positivo (FP)

Corresponde al cuadrante inferior izquierdo.

Verdadero positivo (TP)

Corresponde al cuadrante inferior derecho.

En donde:

• Verdadero significa que los valores se predijeron con precisión,

• Falso significa que hubo un error o una predicción incorrecta.

En nuestro caso, si volvemos a analizar nuestro diagrama. Los valores de la diagonal principal a=9 y d=816 se corresponden con
los valores estimados de forma correcta por el modelo, tanto los verdaderos positivos_ TP(d), como los verdaderos
negativos_TN (a).

Página 10 de 82
Y la otra diagonal, por tanto, representa los casos en los que el modelo «se ha equivocado» (c=75 falsos negativos_FN, b=100
falsos positivos_FP).

Cuyos valores son:

• Verdadero negativos (TN) : 9

• Falso negativo (FN): 75

• Falso positivo (FP): 100

• Verdadero positivo (TP) : 816

Ahora que hemos creado una matriz de confusión, podemos calcular diferentes medidas para cuantificar la calidad del modelo.
Métricas creadas

La matriz nos proporciona muchas métricas útiles que nos ayudan a evaluar nuestro modelo de clasificación. Las diferentes
medidas incluyen: Exactitud, Precisión, Sensibilidad (Recordatorio), Especificidad y la puntuación F, que se explican a
continuación:

Exactitud
La exactitud representa el porcentaje de predicciones correctas frente al total. Por tanto, es el cociente entre los casos bien
clasificados por el modelo (verdaderos positivos y verdaderos negativos, es decir, los valores en la diagonal de la matriz de
Página 11 de 82
confusión), y la suma de todos los casos. Ademas La precisión mide con qué frecuencia el modelo es correcto. Fórmula para
calcularla:
(Verdadero positivo + Verdadero negativo) / Predicciones totales
Es decir;

(816+9) / (816+9 +75+100) = 0,825 = 82%

Para utilizar esta fórmula directamente con NumPy en Phyton, solo debemos utilizar:

Accuracy = metrics.accuracy_score(actual, predicted)

Y para imprimirla:
print("Exactitud=",Accuracy)

Precisión
La precisión, se refiere a lo cerca que está el resultado de una predicción del valor verdadero. Por tanto, es el cociente entre
los casos positivos bien clasificados por el modelo y el total de predicciones positivas. Para calcularlo a mano, a partir de la
matriz de confusión:

Ahora, de los positivos pronosticados, ¿qué porcentaje es realmente positivo? Fórmula para calcularla:

Verdadero Positivo / (Verdadero Positivo + Falso Positivo)

Hay que recalcar que la precisión no evalúa los casos negativos predichos correctamente. Para utilizar esta fórmula directamente
con NumPy en Phyton, solo debemos utilizar:

Precision = metrics.precision_score(actual, predicted)

Y para imprimirla:
print("Presicion=",Precision)

Sensibilidad
La sensibilidad representa la tasa de verdaderos positivos (True Positive Rate) ó TP. Es la proporción entre los casos positivos
bien clasificados por el modelo, respecto al total de positivos.

De todos los casos positivos, ¿qué porcentaje se pronostican positivos? La sensibilidad (a veces denominada recuperación) mide
qué tan bueno es el modelo para predecir aspectos positivos. Esto significa que analiza los verdaderos positivos y los falsos
negativos (que son positivos que se han predicho incorrectamente como negativos). Fórmula para calcularla:
Verdadero Positivo / (Verdadero Positivo + Falso Negativo)

La sensibilidad es buena para comprender qué tan bien el modelo predice que algo es positivo. Para utilizar esta fórmula
directamente con NumPy en Phyton, solo debemos utilizar:

Sensitivity_recall = metrics.recall_score(actual, predicted)

Y para imprimirla:
print("Sensibilidad=",Sensitivity_recall)

Página 12 de 82
Especificidad
La especificidad, por su parte, es la tasa de verdaderos negativos, (“true negative rate”) o TN. Es la proporción entre los casos
negativos bien clasificados por el modelo, respecto al total de negativos. ¿Qué tan bien el modelo predice resultados negativos?
Fórmula para calcularla:

Verdadero Negativo / (Verdadero Negativo + Falso Positivo)

Dado que es justo lo contrario de Recall, usamos la funciónrecall_score, tomando la etiqueta de posición opuesta: Para utilizar
esta fórmula directamente con NumPy en Phyton, solo debemos utilizar:

Specificity = metrics.recall_score(actual, predicted, pos_label=0)

Y para imprimirla:
print("Especificidad= ", Specificity)

Puntuación F
Esta es otra métrica muy empleada porque nos resume la precisión y sensibilidad en una sola métrica. Por ello es de gran
utilidad cuando la distribución de las clases es desigual, por ejemplo cuando el número de pacientes con una condición es del
15% y el otro es 85%, lo que en el campo de la salud es bastante común. Es decir, F-score es la "media armónica" de precisión y
sensibilidad. Considera casos falsos positivos y falsos negativos y es bueno para conjuntos de datos desequilibrados. Fórmula
para calcularla:

2 * ((Precisión * Sensibilidad) / (Precisión + Sensibilidad))

Esta puntuación no tiene en cuenta los valores True Negative. Para utilizar esta fórmula directamente con NumPy en Phyton,
solo debemos utilizar:
F1_score = metrics.f1_score(actual, predicted)

Y para imprimirla:
print("Puntuación F= ", F1_score)

A continuación, en el siguiente código, se mostrarán tanto el diagrama, como todos los cálculos en uno:

Sintaxis
import matplotlib.pyplot as plt
import numpy
from sklearn import metrics

actual = numpy.random.binomial(1,.9,size = 1000) predicted =

numpy.random.binomial(1,.9,size = 1000) confusion_matrix =
metrics.confusion_matrix(actual, predicted)

#Metrics
Accuracy = metrics.accuracy_score(actual, predicted)
Precision = metrics.precision_score(actual, predicted)
Sensitivity_recall = metrics.recall_score(actual, predicted)
Specificity = metrics.recall_score(actual, predicted, pos_label=0)
F1_score = metrics.f1_score(actual, predicted)

print("Exactitud=",Accuracy)
print("Presicion=",Precision)
print("Sencibilidad=",Sensitivity_recall)

Página 13 de 82
 print("Especificidad= ", Specificity)
print("Puntuación F= ", F1_score)

cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix,

display_labels = [False, True])

cm_display.plot()
plt.show()

Resultado

Al interpretar el resultado tenemos:

Exactitud
El valor obtenido es de un 0,83 = 82%. No es maravilloso, pero podemos considerar aceptable).

Precisión
El valor obtenido para este modelo es de un 0,91 = 91%. Por tanto, nuestro modelo es más exacto que preciso.

Sensibilidad
El valor obtenido para este modelo es de un 0,89 = 89%. Es claramente un valor muy bueno para una métrica.
Podemos decir que nuestro algoritmo de clasificación es sensible, «no se le escapan» muchos positivos.
Especificidad
El valor obtenido para este modelo es de un 0,10 = 10%. En este caso, la especificad tiene un valor muy bajo. Esto
significa que su capacidad de discriminar los casos negativos es muy deficiente. O lo que es lo mismo, es muy
factible obtener falsos positivos.

Puntuación F
El valor obtenido para este modelo es de un 0,90 = 90%. Ello quiere decir que la precisión y sensibilidad están bien
equilibradas con un valor notable.

Además, conforme a estas métricas podemos obtener cuatro casos posibles para cada clase:

Alta precisión y alta sensibilidad

El modelo de Machine Learning escogido maneja perfectamente esa clase.

Página 14 de 82
Alta precisión y baja sensibilidad
El modelo de Machine Learning escogido no detecta la clase muy bien, pero cuando lo hace es altamente confiable.

Baja precisión y alta sensibilidad

El modelo de Machine Learning escogido detecta bien la clase, pero también incluye muestras de la otra clase.

Baja precisión y baja sensibilidad

El modelo de Machine Learning escogido no logra clasificar la clase correctamente.

En nuestro caso tenemos una presicion del 91% y una sensibilidad del 89%, esto quiere decir que nuestro modelo maneja
perfectamente esa clase
Modelos lineales

Introducción

Los modelos lineales generan una fórmula para crear una línea de mejor ajuste para predecir valores desconocidos. Los modelos
lineales se consideran de la vieja escuela y, a menudo, no son tan predictivos como las clases de algoritmos más nuevos, pero
se pueden entrenar con relativa rapidez y, en general, son más fáciles de interpretar, lo que puede ser una gran ventaja.

La regresión es una forma estadística de establecer una relación entre una variable dependiente y un conjunto de variables
independientes. Es un enfoque muy simple para el aprendizaje supervisado. Aunque puede parecer algo tedioso en
comparación con algunos de los algoritmos más modernos, este algoritmo sigue siendo un método de aprendizaje estadístico
útil y ampliamente utilizado.

Exploraremos dos tipos de modelos lineales:

Regresión lineal
Se utiliza para la regresión (predicciones numéricas).

Regresión logística
Se utiliza para la clasificación (predicciones categóricas).

Regresión lineal

La regresión líneal es un método para predecir la variable dependiente (y) en función de los valores de las variables
independientes (X). Se puede usar para los casos donde queremos predecir alguna cantidad continua, por ejemplo, predecir el
tráfico en una tienda minorista, predecir el tiempo de permanencia de un usuario o el número de páginas visitas en un blog,
etc. Este algoritmo consiste en hallar una línea recta que mejor encaje en un conjunto de datos dados, este conjunto de datos
comprende las variables independientes e dependientes. Para esto podremos utilizar métodos matemáticos como el de los
mínimos cuadrados, para buscar minimizar la distancia vertical de todos los puntos a la línea recta. Una vez obtenida esta línea
recta, seremos capaces de hacer predicciones hipotéticas sobre cuál será el valor de “y” dado “X”.

Las variables dependientes y las variables independientes:

Página 15 de 82
Variables independientes (características)
Es una variable que se manipula para determinar el valor de una variable dependiente. Simplemente, son las características que
queremos usar para predecir algún valor dado de y.

Variable dependiente (objetivo)

La variable dependiente depende de los valores de la variable independiente. En pocas palabras, es la característica que estamos
tratando de predecir. Esto también se puede conocer comúnmente como una variable de respuesta.
Regresión logística

La regresión logística o Logistic Regression es un algoritmo de clasificación que se utiliza para predecir la probabilidad de una
variable dependiente categórica. En la regresión logística, la variable dependiente es una variable binaria que contiene datos
codificados como 1 – 0, sí – no, abierto – cerrado, etc. Este modelo logístico binario se utiliza para estimar la probabilidad de
una respuesta binaria basada en una o más variables de predicción o independientes. Permite decir que la presencia de un
factor de riesgo aumenta la probabilidad de un resultado dado un porcentaje específico.

Como todos los análisis de regresión, la regresión logística es un análisis predictivo. Se usa para describir datos y explicar la
relación entre una variable binaria dependiente y una o más variables independientes nominales, ordinales, de intervalo o de
nivel de razón.
La regresión logística requiere tamaños de muestra bastante grandes. La razón por la cual la regresión logística es ampliamente
utilizada, a pesar de los algoritmos avanzados como redes neuronales profunda, es porque es muy eficiente y no requiere
demasiados recursos computacionales que hacen que sea asequibles ejecutar la producción. Algunas de las características que
debes considerar para este algoritmo son las siguientes:

Variable de salida binaria

Esto puede ser obvio, pero la regresión logística está destinada a problemas de clasificación binarios (dos clases). Predicará la
probabilidad de que una instancia pertenezca a la clase predeterminada, que puede dividirse en una clasificación 0 ó 1.

Eliminar ruido
La regresión logística no asume ningún error en la variable de salida (y). Considera la eliminación de los valores atípicos y
posiblemente las instancias más clasificadas de sus datos de entrenamiento.

Distribución gaussiana
La regresión logística es un algoritmo lineal, con una transformación no lineal en la salida. Las transformaciones de datos de sus
variables de entrada que exponen mejor esta relación lineal pueden dar como resultado un modelo más preciso.

Eliminar entradas correlacionadas

Al igual que la regresión lineal, el modelo puede sobre ajustarse si tiene múltiples entradas altamente correlacionadas.
Consideremos calcular las correlaciones por pares entre todas las entradas y eliminar las entradas altamente correlacionadas.

No se puede converger
Es posible que el proceso de estimación de probabilidad esperado aprenda que los coeficientes no convergen, esto puede
suceder si hay muchas entradas altamente correlacionadas en sus datos o si los datos son muy escasos.
Diferencias entre la regresión lineal y logística

La Regresión Lineal, se utiliza para proyectos de regresión, es decir cuando queremos predecir un valor numérico, por ejemplo,
queremos predecir el precio de una casa o el sueldo de una persona de acuerdo a los años de experiencia.

Por su parte el algoritmo de Regresión Logística se utiliza para proyectos de clasificación, si queremos conocer si una persona
vive o no el naufragio del Titanic, o si una acción de la bolsa de valores va a subir o no.
Página 16 de 82
Por lo tanto, la Regresión Lineal es un algoritmo de regresión mientras que la Regresión Logística es un algoritmo de
clasificación. Pero veamos esto con un ejemplo práctico en donde implementemos ambos algoritmos, tenemos los datos
históricos del tiempo de una ciudad, entonces queremos predecir lo siguiente: Si durante el día va a llover y cuál es la
probabilidad de que llueve muy fuerte.
Para el primer caso, que es el de predecir si va a llover, debemos utilizar el algoritmo de Regresión Logística, ya que acá vamos
a predecir una de dos opciones, si llueve o no llueve, por lo que utilizamos un algoritmo de clasificación.

Por su parte para calcular la probabilidad de que llueva muy fuerte utilizamos el algoritmo de Regresión Lineal, ya que debemos
calcular el porcentaje de probabilidad, por lo que es un valor numérico, por lo tanto, debemos implementar un algoritmo de
regresión.

En conclusión, la Regresión Lineal es un algoritmo de regresión por lo que la utilizamos para predecir un valor numérico,
mientras que la Regresión Logística es un algoritmo de clasificación por lo que la utilizamos para predecir entre dos opciones.

Página 17 de 82
Ejemplo regresión lineal

La regresión lineal utiliza la relación entre los puntos de datos para dibujar una línea recta a través de todos ellos. Esta línea se
puede utilizar para predecir valores futuros.

Python tiene métodos para encontrar una relación entre puntos de datos y dibujar una línea de regresión lineal. A
continuación, mostraremos cómo usar estos métodos en lugar de pasar por la fórmula matemática.
En el siguiente ejemplo, el eje x representa la edad y el eje y representa la velocidad. Hemos registrado la edad y la velocidad
de 13 coches cuando pasaban por una cabina de peaje. Veamos si los datos que recopilamos podrían usarse en una regresión
lineal:
import matplotlib.pyplot as plt

x = [5,7,8,7,2,17,2,9,4,11,12,9,6]
y = [99,86,87,88,111,86,103,87,94,78,77,85,86]

plt.scatter(x, y)
plt.show()

El resultado gráfico es el siguiente:

Página 18 de 82
Ahora, vamos a importar Scipy para que dibuje la línea de Regresión Lineal:
import matplotlib.pyplot as plt
from scipy import stats

x = [5,7,8,7,2,17,2,9,4,11,12,9,6]
y = [99,86,87,88,111,86,103,87,94,78,77,85,86]

slope, intercept, r, p, std_err = stats.linregress(x, y)

def myfunc(x):
return slope * x + intercept

mymodel = list(map(myfunc, x))

plt.scatter(x, y)
plt.plot(x, mymodel)
plt.show()

Cuyo resultado es el siguiente:

Página 19 de 82
Explicación del codigo:

Primero se ha Importado los módulos que necesitamos.

import matplotlib.pyplot as plt
from scipy import stats

Se crean las matrices que representan los valores de los ejes x e y:

x = [5,7,8,7,2,17,2,9,4,11,12,9,6]
y = [99,86,87,88,111,86,103,87,94,78,77,85,86]

Ejecutamos un método que devuelva algunos valores clave importantes de la regresión lineal: slope,

intercept, r, p, std_err = stats.linregress(x, y)

Creamos una función que use los valores slope e intercept para devolver un nuevo valor. Este nuevo valor representa dónde
en el eje y se colocará el valor x correspondiente:
def myfunc(x):
return slope * x + intercept

Ejecute cada valor de la matriz x a través de la función. Esto dará como resultado una nueva matriz con nuevos valores para el
eje y:
mymodel = list(map(myfunc, x))

Luego para dibujar el diagrama de dispersión original, hemos puesto:

plt.scatter(x, y)

Página 20 de 82
Y para Dibujar la línea de regresión lineal:
plt.plot(x, mymodel)

Por último le pedimos que nos muestre el diagrama:

plt.show()

R de Relación

Es importante saber cómo es la relación entre los valores del eje x y los valores del eje y, si no hay relación la regresión lineal no
puede usarse para predecir nada. Esta relación, el coeficiente de correlación, se llama “r”.

El rvalor varía de -1 a 1, donde 0 significa que no hay relación y 1 (y -1) significa 100% relacionado. Python y el módulo Scipy
calcularán este valor por nosotros, todo lo que tenemos que hacer es alimentarlo con los valores x e y.

Sintaxis
from scipy import stats

import matplotlib.pyplot as plt

from scipy import stats

x = [5,7,8,7,2,17,2,9,4,11,12,9,6]
y = [99,86,87,88,111,86,103,87,94,78,77,85,86]

slope, intercept, r, p, std_err = stats.linregress(x, y)

def myfunc(x):
return slope * x + intercept

mymodel = list(map(myfunc, x))

plt.scatter(x, y)
plt.plot(x, mymodel)
plt.show()

slope, intercept, r, p, std_err = stats.linregress(x, y)

print(r)

Resultado:

Nota: El resultado -0.75 muestra que existe una relación, no perfecta, pero indica que podríamos usar la regresión lineal en
futuras predicciones.

A continuación, vamos a crear un ejemplo donde la regresión lineal no sería el mejor método para predecir valores futuros.
Estos valores para los ejes x e y deberían dar como resultado un ajuste deficiente para la regresión lineal:

Página 21 de 82
Sintaxis
import matplotlib.pyplot as plt
from scipy import stats

x = [89,43,36,36,95,10,66,34,38,20,26,29,48,64,6,5,36,66,72,40]
y = [21,46,3,35,67,95,53,72,58,10,26,34,90,33,38,20,56,2,47,15]

slope, intercept, r, p, std_err = stats.linregress(x, y)

def myfunc(x):
return slope * x + intercept

mymodel = list(map(myfunc, x))

plt.scatter(x, y)
plt.plot(x, mymodel)
plt.show()

Resultado

Ahora vamos a realizar la comprobación de relación:

Página 22 de 82
Sintaxis
import matplotlib.pyplot as plt
from scipy import stats

x = [89,43,36,36,95,10,66,34,38,20,26,29,48,64,6,5,36,66,72,40]
y = [21,46,3,35,67,95,53,72,58,10,26,34,90,33,38,20,56,2,47,15]

slope, intercept, r, p, std_err = stats.linregress(x, y)

def myfunc(x):
return slope * x + intercept

slope, intercept, r, p, std_err = stats.linregress(x, y)

print(r)

mymodel = list(map(myfunc, x))

plt.scatter(x, y)
plt.plot(x, mymodel)
plt.show()

Resultado
Al ejecutarlo, hemos obtenenido un valor muy bajo:

Predecir valores futuros

Ahora podemos usar la información que hemos recopilado para predecir valores futuros.

Ejemplo: Intentemos predecir la velocidad de un automóvil de 10 años. Para hacerlo, necesitamos también la función myfunc()
del ejemplo anterior:

Sintaxis
A continuación, vamos a predecir la velocidad de un automóvil de 10 años. Por medio de este codigo:
import matplotlib.pyplot as plt
from scipy import stats

x = [5,7,8,7,2,17,2,9,4,11,12,9,6]
y = [99,86,87,88,111,86,103,87,94,78,77,85,86]

slope, intercept, r, p, std_err = stats.linregress(x, y)

def myfunc(x):
return slope * x + intercept

mymodel = list(map(myfunc, x))

speed = myfunc(10)
print(speed)

plt.scatter(x, y)
plt.plot(x, mymodel)
plt.show()

Página 23 de 82
Resultado
El ejemplo predijo una velocidad de 85,6

Gráfico
Que a su vez podemos interpretar dentro del gráfico.

Ejemplo de regresión logística

Como hemos expuesto con anterioridad, la regresión logística tiene como objetivo resolver problemas de clasificación. Lo hace
mediante la predicción de resultados categóricos, a diferencia de la regresión lineal que predice un resultado continuo.

En el caso más simple hay dos resultados, lo que se llama binomial, un ejemplo para la medicina es predecir si un tumor es
maligno o benigno. Otros casos tienen más de dos resultados para clasificar, en este caso se llama multinomial. Un ejemplo
común de regresión logística multinomial sería predecir la clase de una flor de iris entre 3 especies diferentes.

Aquí usaremos la regresión logística básica para predecir una variable binomial. Esto significa que solo tiene dos resultados
posibles. En Python tenemos módulos que harán el trabajo por nosotros. A continuacion, comenzaremos por importar el
módulo NumPy.

1
Escribiremos lo siguiente:

Página 24 de 82
 import numpy

2
Luego debemos:
• Almacenar las variables independientes en X.

• Almacenar la variable dependiente en y.

3
Posteriormente, vamos a colocar un conjunto de datos de muestra:

#X represents the size of a tumor in centimeters.

X = numpy.array([3.78, 2.44, 2.09, 0.14, 1.72, 1.65, 4.92, 4.37, 4.96, 4.52, 3.69,
5.88]).reshape(-1,1)

#Note: X has to be reshaped into a column from a row for the LogisticRegression()
function to work.
#y represents whether or not the tumor is cancerous (0 for "No", 1 for "Yes").
y = numpy.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1])

4
Usaremos un método del módulo sklearn, por lo que también tendremos que importar ese módulo:

from sklearn import linear_model

Desde el módulo sklearn usaremos el método LogisticRegression() para crear un objeto de regresión logística.

5
Este objeto tiene un método llamado fit() que toma los valores independientes y dependientes como parámetros y llena el
objeto de regresión con datos que describen la relación:
logr = linear_model.LogisticRegression()
logr.fit(X,y)

6
Ahora tenemos un objeto de regresión logística que está listo para determinar si un tumor es cancerígeno en función del
tamaño del tumor:

#predict if tumor is cancerous where the size is 3.46mm:

predicted = logr.predict(numpy.array([3.46]).reshape(-1,1))

7
Veamos el ejemplo completo en acción:

Página 25 de 82
 import numpy
from sklearn import linear_model

X = numpy.array([3.78, 2.44, 2.09, 0.14, 1.72, 1.65, 4.92, 4.37, 4.96, 4.52, 3.69,
5.88]).reshape(-1,1)
y = numpy.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1])

logr = linear_model.LogisticRegression()
logr.fit(X,y)

log_odds = logr.coef_
odds = numpy.exp(log_odds)

print(odds)

Resultado

Esto nos dice que a medida que el tamaño de un tumor aumenta en 1 mm, las probabilidades de que sea un tumor aumentan
en 4x.

La Probabilidad

Los valores del coeficiente y del intercepto se pueden usar para encontrar la probabilidad de que cada tumor sea cancerígeno.
Para ello, creamos una función que use el coeficiente del modelo y los valores de intercepción para devolver un nuevo valor.
Este nuevo valor representa la probabilidad de que la observación dada sea un tumor:

Sintaxis
def logit2prob(logr,x):
log_odds = logr.coef_ * x + logr.intercept_
odds = numpy.exp(log_odds)
probability = odds / (1 + odds)
return(probability)

Explicación
Para encontrar las probabilidades logarítmicas de cada observación, primero debemos crear una fórmula similar a la de la
regresión lineal, extrayendo el coeficiente y la intersección.
log_odds = logr.coef_ * x + logr.intercept_

Para luego convertir las probabilidades logarítmicas en probabilidades, debemos exponenciar las probabilidades logarítmicas.
odds = numpy.exp(log_odds)

Ahora que tenemos las probabilidades, podemos convertirlo en probabilidad dividiéndolo por 1 más las probabilidades.
probability = odds / (1 + odds)

Usemos ahora la función con lo que hemos aprendido para averiguar la probabilidad de que cada tumor sea cancerígeno.

Página 26 de 82
Veamos el ejemplo completo en acción:

Ejemplo:
Import numpy
from sklearn import linear_model

X = numpy.array([3.78, 2.44, 2.09, 0.14, 1.72, 1.65, 4.92, 4.37, 4.96, 4.52, 3.69,
5.88]).reshape(-1,1)
y = numpy.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1])

logr = linear_model.LogisticRegression()
logr.fit(X,y)

def logit2prob(logr, X):

log_odds = logr.coef_ * X + logr.intercept_
odds = numpy.exp(log_odds)
probability = odds / (1 + odds)
return(probability)

print(logit2prob(logr, X))

Resultado:

Página 27 de 82
,

Página 28 de 82
 es de
19%.

• El 3er dato introducido 2.09 da como resultado 0,12 Esto quiere deci,r que la probabilidad de que un tumor de 2.09 cm sea
canceroso es de 12%.

Y así sucesivamente…

Modelos supervisados de ML: Árboles, SVM, redes neuronales

Arboles de decisión

En general, el análisis del árbol de decisiones es una herramienta de modelado predictivo que se puede aplicar en muchas áreas.
Los árboles de decisión se pueden construir mediante un enfoque algorítmico que puede dividir el conjunto de datos de
diferentes maneras en función de diferentes condiciones.

Las decisiones son los algoritmos más poderosos que se incluyen en la categoría de algoritmos supervisados.

Se pueden utilizar tanto para tareas de clasificación como de regresión. Las dos entidades principales de un árbol son nodos de
decisión, donde los datos se dividen y se van, donde obtuvimos el resultado. A continuación, se muestra el ejemplo de un árbol
binario para predecir si una persona está en forma o no, proporcionando información diversa como la edad, los hábitos
alimenticios y los hábitos de ejercicio.

En diagrama de árbol de decisión anterior, las preguntas son nodos de decisión y los resultados finales son hojas. Tenemos los
siguientes dos tipos de árboles de decisión:

Árboles de decisión de clasificación

En este tipo de árboles de decisión, la variable de decisión es categórica. El árbol de decisión anterior es un ejemplo de árbol de
decisión de clasificación.
Árboles de decisión de regresión
En este tipo de árboles de decisión, la variable de decisión es continua.

Página 29 de 82
Implementación del algoritmo del árbol de decisión

Índice Gini

Es el nombre de la función de costo que se usa para evaluar las divisiones binarias en el conjunto de datos y funciona con la
variable objetivo categórica; "Éxito" o "Fracaso".

Cuanto mayor sea el valor del índice de Gini, mayor será la homogeneidad. Un valor de índice de Gini perfecto es 0 y el peor es
0,5 (para un problema de 2 clases). El índice de Gini para una división se puede calcular con la ayuda de los siguientes pasos:

Primero, calculamos el índice de Gini para los subnodos usando la fórmula p^2+q^2, que es la suma del cuadrado de la
probabilidad de éxito y fracaso.

A continuación, calculamos el índice de Gini para la división utilizando la puntuación de Gini ponderada de cada nodo de esa
división.

El algoritmo del árbol de clasificación y regresión (CART) utiliza el método de Gini para generar divisiones binarias.

Creación dividida

Una división básicamente incluye un atributo en el conjunto de datos y un valor. Podemos crear una división en el conjunto de
datos con la ayuda de las siguientes tres partes:

Parte 1: Cálculo del puntaje de Gini

Acabamos de discutir esta parte en la sección anterior.

Parte 2: dividir un conjunto de datos

Se puede definir como separar un conjunto de datos en dos listas de filas que tienen el índice de un atributo y un valor de
división de ese atributo. Después de obtener los dos grupos, derecho e izquierdo, del conjunto de datos, podemos calcular el
valor de división utilizando el puntaje de Gini calculado en la primera parte. El valor dividido decidirá en qué grupo residirá el
atributo.

Parte 3: Evaluación de todas las divisiones

La siguiente parte después de encontrar el puntaje de Gini y dividir el conjunto de datos es la evaluación de todas las divisiones.
Para este propósito, primero, debemos verificar cada valor asociado con cada atributo como una división de candidatos. Luego
necesitamos encontrar la mejor división posible evaluando el costo de la división. La mejor división se utilizará como nodo en
el árbol de decisión.
Construir el árbol

Como sabemos, un árbol tiene un nodo raíz y nodos terminales. Después de crear el nodo raíz, podemos construir el árbol
siguiendo dos partes: Parte 1: creación del nodo terminal y Parte 2: división recursiva. Parte 1: creación del nodo terminal

Al crear nodos terminales del árbol de decisión, un punto importante es decidir cuándo dejar de hacer crecer el árbol o crear
más nodos terminales. Se puede hacer utilizando dos criterios, a saber, la profundidad máxima del árbol y los registros mínimos
de nodos de la siguiente manera:

Profundidad máxima del árbol

Como sugiere el nombre, este es el número máximo de nodos en un árbol después del nodo raíz. Debemos dejar de agregar
nodos terminales una vez que un árbol alcanzó la profundidad máxima, es decir, una vez que un árbol obtuvo el número
máximo de nodos terminales.

Página 30 de 82
Registros mínimos de nodos
Se puede definir como el número mínimo de patrones de entrenamiento de los que es responsable un nodo determinado.
Debemos dejar de agregar nodos terminales una vez que el árbol alcance estos registros mínimos de nodos o por debajo de
este mínimo.

El nodo terminal se utiliza para hacer una predicción final.

Parte 2: división recursiva

Ahora podemos comenzar a construir nuestro árbol. La división recursiva es un método para construir el árbol. En este método,
una vez que se crea un nodo, podemos crear los nodos secundarios (nodos agregados a un nodo existente) recursivamente en
cada grupo de datos, generado al dividir el conjunto de datos, llamando a la misma función una y otra vez.

Predicción
• Después de construir un árbol de decisión, necesitamos hacer una predicción al respecto. Básicamente, la predicción
implica navegar por el árbol de decisiones con la fila de datos proporcionada específicamente.

• Podemos hacer una predicción con la ayuda de la función recursiva, como se hizo anteriormente. Se vuelve a llamar a la
misma rutina de predicción con los nodos izquierdo o derecho secundario.

Suposiciones
Las siguientes son algunas de las suposiciones que hacemos al crear el árbol de decisiones:

• Mientras se preparan los árboles de decisión, el conjunto de entrenamiento es como nodo raíz.

• El clasificador del árbol de decisión prefiere que los valores de las características sean categóricos. En caso de que desee
utilizar valores continuos, debe hacerlos discretizados antes de la construcción del modelo.

• Según los valores del atributo, los registros se distribuyen recursivamente.

• Se utilizará un enfoque estadístico para colocar atributos en cualquier posición de nodo, es decir, como nodo raíz o nodo
interno.

A continuación mostraremos cómo crear un "árbol de decisiones". Como hemos visto, un árbol de decisiones es un diagrama
de flujo y puede ayudarlo a tomar decisiones basadas en la experiencia previa.

En el siguiente ejemplo, una persona intentará decidir si debe ir a un programa de comedia o no.

1
Afortunadamente, nuestra persona de ejemplo se ha registrado cada vez que hubo un espectáculo de comedia en la ciudad, y
registró cierta información sobre el comediante, y también registró sí asistió o no.

Página 31 de 82
2
Lo primero es pasar estos datos a una tabla de Excel como se muestra a continuación:

Página 32 de 82
3
Luego lo guardamos como archivo (CVS separado por comas) y le asignamos un nombre (en nuestro caso es shows).

Página 33 de 82
Página 34 de 82
4
Luego, nos vamos a la carpeta y abrimos el archivo con el editor de texto de Windows.

Página 35 de 82
5
Una vez abierto, vemos que los datos no están separados por comas. Sino por puntos y comas.

6
Para solventar esto, pulsamos en la barra de herramientas>Reemplazar..

Página 36 de 82
7
Aquí colocamos en el campo Buscar un “punto y coma”, en el campo reemplazar una “coma” y pulsamos en reemplazar.

8
Quedando de la siguiente manera:

Página 37 de 82
9
A continuación, guardamos el archivo con los cambios. Ahora, en función de este conjunto de datos, Python puede crear un
árbol de decisiones que se puede usar para decidir si vale la pena asistir a algún programa nuevo.

Para crear el árbol basado en los datos:

Primero, abrimos una nueva ventana en el idle de Phyton, le asignamos un nombre y guardamos el archivo en la misma carpeta
en donde está ubicado el archivo CVS anterior. A continuación, debemos importar los módulos que necesita y para que lea el
conjunto de datos con pandas. Para ello copiamos el siguiente código y lo ejecutamos.

Ejemplo
import pandas
from sklearn import tree
import pydotplus
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
import matplotlib.image as pltimg

df = pandas.read_csv("shows.csv")

print(df)

Página 38 de 82
Resultado

Vemos que carga el listado perfectamente. Ahora, para hacer un árbol de decisión, todos los datos deben ser numéricos.
Tenemos que convertir las columnas no numéricas 'Nationality' y 'Go' en valores numéricos. Pandas tiene un método llamado
map() que toma un diccionario con información sobre cómo convertir los valores.
{'UK': 0, 'USA': 1, 'N': 2}

Significa convertir los valores 'UK' a 0, 'USA' a 1 y 'N' a 2. Para ello, en el código agregamos las siguientes sentencias. Con esto
cambiamos los valores de cadena a valores numéricos:

Sintaxis
d = {'UK': 0, 'USA': 1, 'N': 2}
df['Nationality'] = df['Nationality'].map(d)
d = {'YES': 1, 'NO': 0}
df['Go'] = df['Go'].map(d)

print(df)

Código
Quedando el código de la siguiente manera:
import pandas
from sklearn import tree
import pydotplus
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
import matplotlib.image as pltimg

df = pandas.read_csv("shows.csv")

Página 39 de 82
 d = {'UK': 0, 'USA': 1, 'N': 2}
df['Nationality'] = df['Nationality'].map(d)
d = {'YES': 1, 'NO': 0}
df['Go'] = df['Go'].map(d)

print(df)

Resultado
Al ejecutarlo vemos el resultado:

Luego tenemos que separar las columnas de características de la columna de destino. Las columnas de características son las
columnas a partir de las cuales tratamos de predecir, y la columna de destino es la columna con los valores que intentamos
predecir. En donde:

Sintaxis
“X” son las columnas de características, e “y” es la columna de destino:
features = ['Age', 'Experience', 'Rank', 'Nationality']

X = df[features]
y = df['Go']

print(X)
print(y)

Código
Al implementarlo en el codigo nos queda de la siguiente manera:
import pandas

Página 40 de 82
from sklearn import tree
import pydotplus
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt

df = pandas.read_csv("shows.csv")

d = {'UK': 0, 'USA': 1, 'N': 2}

df['Nationality'] = df['Nationality'].map(d)
d = {'YES': 1, 'NO': 0}
df['Go'] = df['Go'].map(d)

features = ['Age', 'Experience', 'Rank', 'Nationality']

X = df[features]
y = df['Go']

print(X)
print(y)

Resultado

Página 41 de 82
Ahora podemos crear el árbol de decisiones real, ajustarlo con nuestros detalles y mostrarlo con estas líneas de comando:

Página 42 de 82
Sintaxis
dtree = DecisionTreeClassifier()
dtree = dtree.fit(X, y)
data = tree.export_graphviz(dtree, out_file=None, feature_names=features)

plt.figure(figsize=(20,20))
_ = tree.plot_tree(dtree, feature_names = X.columns,
filled=None, fontsize=10, rounded = True)
plt.show()

Código
Quedando el código completo de la siguiente manera:
import pandas
from sklearn import tree
import pydotplus
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
from sklearn import tree
import pydot

df = pandas.read_csv("shows.csv")

d = {'UK': 0, 'USA': 1, 'N': 2}

df['Nationality'] = df['Nationality'].map(d)
d = {'YES': 1, 'NO': 0}
df['Go'] = df['Go'].map(d)

features = ['Age', 'Experience', 'Rank', 'Nationality']

X = df[features]
y = df['Go']

print(df)
print(X)
print(y)

dtree = DecisionTreeClassifier()
dtree = dtree.fit(X, y)
data = tree.export_graphviz(dtree, out_file=None, feature_names=features)

plt.figure(figsize=(20,20))
_ = tree.plot_tree(dtree, feature_names = X.columns,
filled=None, fontsize=10, rounded = True)

plt.show()
Solo debemos ejecutarlo y obtenemos el árbol de decisiones:

Página 43 de 82
Explicación del resultado

El árbol de decisiones utiliza sus decisiones anteriores para calcular las probabilidades de que quiera ir a ver a un comediante o
no. En donde las decisiones verdaderas (True) van hacia la izquierda y las decisiones falsas a la derecha. Leamos los diferentes
aspectos del árbol de decisión:

• El Rango

Página 44 de 82
Rank < = 6.5
Significa que cada comediante con un rango de 6.5 o menor seguirá la Flecha verdadera (true) hacia la izquierda, y

el resto seguirá la flecha falsa (False) hacia la derecha. gini = 0.497

Se refiere a la calidad de la división y siempre es un número entre 0,0 y 0,5, donde 0,0 significaría que todas las
muestras obtuvieron el mismo resultado y 0,5 significaría que la división se realizó exactamente en el medio.

samples = 13
Significa que quedan 13 comediantes en este punto de la decisión, que son todos ya que este es el primer paso.

value = [6, 7]
Significa que, de estos 13 comediantes, 6 obtendrán un "NO" y 7 obtendrán un "SI".

Página 45 de 82
 • El Gini

Hay muchas formas de dividir las muestras, usamos el método GINI. El método Gini utiliza esta fórmula:
Gini = 1 - (x/n)2 - (y/n)2

En donde en “x” está el número de respuestas positivas ("GO"), “n” es el número de muestras y “y” es el número de respuestas
negativas ("NO"), lo que nos da este cálculo:
1 - (7 / 13)2 - (6 / 13)2 = 0.497

El siguiente paso contiene dos casillas, una casilla para los comediantes con un 'Rango' de 6.5 o menor, y una casilla con el resto.
En donde:

True (Cierto)
5 comediantes terminan aquí.
Gini = 0.0
Significa que todas las muestras obtuvieron el mismo resultado.
Página 46 de 82
Samples = 5
Significa que quedan 5 comediantes en esta rama (5 comediantes con un Rango de 6.5 o menos).

value = [5, 0]
Significa que 5 obtendrá un "NO" y 0 obtendrá un "SI".

False
8 comediantes continúan.

• Nacionality (Nacionalidad)

Nationality <= 0.5

Significa que los comediantes con un valor de nacionalidad inferior a 0,5 seguirán la flecha hacia la izquierda (lo que
significa que todos los del Reino Unido), y el resto seguirá la flecha hacia la derecha.

gini = 0.219
Significa que alrededor del 22% de las muestras irían en una dirección.

samples = 8
Significa que quedan 8 comediantes en esta rama (8 comediantes con un Rango superior a 6.5). value = [1, 7]

Significa que, de estos 8 comediantes, 1 obtendrá un "NO" y 7 obtendrán un "SI".

Continuando más hacia abajo tenemos:

Página 47 de 82
True (Cierto)
4 comediantes continúan.

Age
Años

Age <= 35.5

Significa que los comediantes de 35,5 años o menos seguirán la flecha hacia la izquierda, y el resto seguirá la flecha hacia
la derecha.

gini = 0.375
Significa que alrededor del 37,5% de las muestras irían en una dirección.

Página 48 de 82
samples = 4
Significa que quedan 4 comediantes en esta rama (4 comediantes del Reino Unido). value = [1, 3]

significa que, de estos 4 comediantes, 1 obtendrá un "NO" y 3 obtendrán un "SI". Falso: 4 comediantes terminan aquí.

gini = 0.0
Significa que todas las muestras obtuvieron el mismo resultado.

samples = 4
Significa que quedan 4 comediantes en esta rama (4 comediantes que no son del Reino Unido). value = [0, 4]

Significa que, de estos 4 comediantes, 0 obtendrá un "NO" y 4 obtendrá un "GO".

Siguiendo más hacia abajo tenemos:

Página 49 de 82
True (Cierto)
2 comediantes terminan aquí.

gini = 0.0
Significa que todas las muestras obtuvieron el mismo resultado.

samples = 2
Significa que quedan 2 comediantes en esta rama (2 comediantes de 35,5 años o menos).

value = [0, 2]
Significa que de estos 2 comediantes, 0 obtendrá un "NO" y 2 obtendrá un "GO".

False (Falso)
2 comediantes continúan
• Experience (experiencia)
Página 50 de 82
Experience <= 9.5
Significa que los comediantes con 9.5 años de experiencia, o menos, seguirán la flecha hacia la izquierda y el resto seguirá
la flecha hacia la derecha.

gini = 0.5
Significa que el 50% de las muestras irían en una dirección.

samples = 2
Significa que quedan 2 comediantes en esta sucursal (2 comediantes mayores de 35.5). value = [1, 1]

Significa que de estos 2 comediantes, 1 obtendrá un "NO" y 1 obtendrá un "SI".

Por último tenemos:

True (Cierto)
1 comediante termina aquí.

gini = 0.0
Significa que todas las muestras obtuvieron el mismo resultado.

samples = 1
Significa que queda 1 comediante en esta rama (1 comediante con 9.5 años de experiencia o menos).

value = [0, 1]
Significa que 0 obtendrá un "NO" y 1 obtendrá un "SI". Falso - 1 comediante termina aquí: gini = 0.0

Significa que todas las muestras obtuvieron el mismo resultado.

samples = 1
Significa que queda 1 comediante en esta rama (1 comediante con más de 9.5 años de experiencia).

value = [1, 0]
Significa que 1 obtendrá un "NO" y 0 obtendrá un "SI".
Predecir los valores

Podemos usar el árbol de decisiones para predecir nuevos valores.

Ejemplo: ¿Debería ir a ver un programa protagonizado por un comediante estadounidense de 40 años, con 10 años de
experiencia y un ranking de comedia de 7? Para ello debemos utilizar el método predict() para predecir nuevos valores con el
siguiente codigo:
print(dtree.predict([[40, 10, 7, 1]]))

Página 51 de 82
Sintaxis
Al implementarlo tenemos el codigo final:
import pandas
from sklearn import tree
from sklearn.tree import DecisionTreeClassifier

df = pandas.read_csv("shows.csv")

d = {'UK': 0, 'USA': 1, 'N': 2}

df['Nationality'] = df['Nationality'].map(d)
d = {'YES': 1, 'NO': 0}
df['Go'] = df['Go'].map(d)

features = ['Age', 'Experience', 'Rank', 'Nationality']

X = df[features]
y = df['Go']

dtree = DecisionTreeClassifier()
dtree = dtree.fit(X, y)

print(dtree.predict([[40, 10, 7, 1]]))

print("[1] means 'GO'")

print("[0] means 'NO'")

Resultado

En donde:

El resultado nos indica =1, lo cual nos aconseja ir.

Ahora, ¿Cuál sería la respuesta si el rango de comedia fuera 6? Sustituimos el valor en el tercer dato (antes
7):
print(dtree.predict([[40, 10, 6, 1]]))

Ejemplo:

Página 52 de 82
 import pandas
from sklearn import tree
from sklearn.tree import DecisionTreeClassifier

df = pandas.read_csv("shows.csv")

d = {'UK': 0, 'USA': 1, 'N': 2}

df['Nationality'] = df['Nationality'].map(d)
d = {'YES': 1, 'NO': 0}
df['Go'] = df['Go'].map(d)

features = ['Age', 'Experience', 'Rank', 'Nationality']

X = df[features]
y = df['Go']

dtree = DecisionTreeClassifier()
dtree = dtree.fit(X, y)

print(dtree.predict([[40, 10, 6, 1]]))

print("[1] means 'GO'")

print("[0] means 'NO'")

Resultado:

Aquí, el resultado nos indica =0, por lo cual NO nos aconseja ir.

Resultados diferentes

Vemos que el árbol de decisión nos da resultados diferentes si lo ejecutamos suficientes veces, incluso si lo alimentamos con
los mismos datos.

Esto se debe a que el árbol de decisiones no nos da una respuesta 100 % segura. Se basa en la probabilidad de un resultado, y
la respuesta variará. En el siguiente ejemplo, vamos a implementar el clasificador Decision Tree en una base de datos llamada
Pima Indian Diabetes:

1
Primero, comenzaremos con la importación de los paquetes de python necesarios:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import sklearn.metrics as metrics
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report,confusion_matrix, accuracy_score
from sklearn.model_selection import train_test_split
from sklearn import tree

Página 53 de 82
2
A continuación, utilizaremos el conjunto de datos “pima-indians-diabetes.csv” de la siguiente manera:

col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree',

'age', 'label']
pima = pd.read_csv(r"pima-indians-diabetes.csv", header=None, names=col_names)
print(pima.head())

3
Al ejecutarlo tenemos el listado:

4
Ahora, dividimos el conjunto de datos en características y variable de destino:

feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']

X = pima[feature_cols] # Features
y = pima.label # Target variable

5
A continuación, dividiremos los datos en train y división de prueba. El siguiente código dividirá el conjunto de datos en un 70 %
de datos de entrenamiento y un 30 % de datos de prueba:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,

random_state=1)

6
Luego, entrenamos el modelo con la ayuda de la clase DecisionTreeClassifier de sklearn de la siguiente manera:
clf = DecisionTreeClassifier()
clf = clf.fit(X_train,y_train)

7
Para realizar la predicción. Se puede hacer con la ayuda del siguiente comando:
y_pred = clf.predict(X_test)

8
A continuación, podemos obtener la puntuación de precisión, la matriz de confusión y el informe de clasificación con el
siguiente codigo:

result = confusion_matrix(y_test, y_pred)

print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
Página 54 de 82
 print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

9
Con ello obtenemos:

Visualización del árbol de decisiones

Sintaxis
El árbol de decisión anterior se puede visualizar con la ayuda del siguiente código:

plt.figure(figsize=(40,20))
_ = tree.plot_tree(clf, feature_names = X.columns,
filled=True, fontsize=2.5, rounded = True)
plt.show()

Página 55 de 82
Resultado

Código
El código completo del ejemplo es el siguiente:

import pandas as pd import numpy as np import

matplotlib.pyplot as plt import sklearn.metrics
as metrics from sklearn.tree import
DecisionTreeClassifier
from sklearn.metrics import classification_report,confusion_matrix, accuracy_score
from sklearn.model_selection import train_test_split
from sklearn import tree

col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree',

'age', 'label']
pima = pd.read_csv(r"pima-indians-diabetes.csv", header=None, names=col_names)
pima.head()

feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']

X = pima[feature_cols] # Features
y = pima.label # Target variable

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,

random_state=1)

clf = DecisionTreeClassifier()
clf = clf.fit(X_train,y_train)
y_pred = clf.predict(X_test)

result = confusion_matrix(y_test, y_pred)

print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)

print("Accuracy:",result2)

plt.figure(figsize=(40,20))

Página 56 de 82
 _ = tree.plot_tree(clf, feature_names = X.columns,
filled=True, fontsize=2.5, rounded = True)
plt.show()

A continuación, mostraremos otro ejemplo: utilizando una base de datos de kyphosis.csv (cifosis)

La cifosis es una condición médica que causa una curvatura hacia adelante de la espalda. Puede ocurrir a cualquier edad, pero
es más común en mujeres mayores. Aquí, el marco de datos tiene 81 filas y 4 columnas. Representando datos sobre pacientes
que han tenido cirugía espinal correctiva. Este marco de datos contiene las siguientes columnas:

kyphosis
Un factor con niveles ausentes presentes que indica si una cifosis estaba presente después de la operación.

Age
En meses.

Number
El número de vértebras involucradas.

Start
El número de la primera vértebra operada.

Importación de bibliotecas de Python

import pandas as pd import numpy

as np import matplotlib.pyplot as
plt import sklearn.metrics as
metrics
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report,confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn import tree

Importar datos del conjunto de datos de cifosis

df = pd.read_csv('kyphosis.csv')
df.head()

Página 57 de 82
Preprocesamiento de datos

La variable X contiene las últimas tres columnas (Edad, Número, Inicio) del conjunto de datos, mientras que y contiene la
primera columna (Cifosis).
X = df.drop('Kyphosis',axis=1)
y = df['Kyphosis']

División de prueba de train

X_train, X_test, y_train, y_test = train_test_split (X, y, test_size=0.30)

El código anterior divide el conjunto de datos en un 70 % de datos de entrenamiento y un 30 % de datos de prueba. El siguiente
paso es ajustar el modelo al conjunto de entrenamiento.
dtree = DecisionTreeClassifier()
dtree.fit(X_train,y_train)
Realizar predicciones y comprobar la precisión

Después de ajustar los datos de entrenamiento al Clasificador de Árbol de Decisión, el siguiente paso es hacer predicciones
sobre los datos de prueba al vector y_pred y encontrar el Puntaje de Precisión.

Página 58 de 82
Ejemplo
y_pred = dtree.predict(X_test)
accuracy = metrics.accuracy_score(y_test,y_pred)
print('Accuracy Score:',accuracy )

Resultado
Al ejecutarlo, el primer resultado es:

El clasificador de árboles de decisión dio una precisión de 0.76. Es decir del 76%.

Matriz de confusión e informe de clasificación

El paso final es evaluar el modelo y ver qué tan bien se está desempeñando. Para eso puedes usar métricas como la matriz de
confusión.

Código
cfMatrix = confusion_matrix(y_test,y_pred)
print(cfMatrix)

Resultado

En la parte superior, Confusion Matrix muestra que 5 observaciones han sido clasificadas como falsas.

A continuación elaboramos un reporte, de presicion, simplicidad(recall), F1-score y soporte:

Código
cReport = classification_report(y_test,y_pred)
print(cReport)

Resultado
Y al ejecutarlo obtenemos los datos:

Página 59 de 82
Para visualizar el arbol tenemos:

Sintaxis
plt.figure(figsize=(40,20))
_ = tree.plot_tree(dtree, feature_names = X.columns,
filled=True, fontsize=6, rounded = True)
plt.show()

Resultado

Código completo
import pandas as pd import numpy
as np import matplotlib.pyplot as
plt import sklearn.metrics as
metrics
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report,confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn import tree

df = pd.read_csv('kyphosis.csv')
df.head()
X = df.drop('Kyphosis',axis=1)
y = df['Kyphosis']
Página 60 de 82
 X_train, X_test, y_train, y_test = train_test_split (X, y, test_size=0.30)
dtree = DecisionTreeClassifier()
dtree.fit(X_train,y_train)
y_pred = dtree.predict(X_test)
accuracy = metrics.accuracy_score(y_test,y_pred)
print('Accuracy Score:',accuracy ) cfMatrix =
confusion_matrix(y_test,y_pred) cReport =
classification_report(y_test,y_pred)
print(cfMatrix)
print(cReport)

plt.figure(figsize=(40,20))
_ = tree.plot_tree(dtree, feature_names = X.columns,
filled=True, fontsize=6, rounded = True)
plt.show()

En el gráfico de árbol de decisión, cada nodo interno tiene una regla de decisión que divide los datos y Gini que mide la impureza
del nodo. Se puede decir que un nodo es puro cuando todos sus registros pertenecen a la misma clase.

SVN

Las máquinas de vectores de soporte (SVM) son algoritmos de aprendizaje automático supervisados potentes pero flexibles
que se utilizan tanto para la clasificación como para la regresión. Pero generalmente, se utilizan en problemas de clasificación.
En la década de 1960, las SVM se introdujeron por primera vez, pero luego se refinaron en 1990. Las SVM tienen su forma única
de implementación en comparación con otros algoritmos de aprendizaje automático. Últimamente, son extremadamente
populares debido a su capacidad para manejar múltiples variables continuas y categóricas.
• Modelo de SVM

Un modelo SVM es básicamente una representación de diferentes clases en un hiperplano en un espacio multidimensional.
SVM generará el hiperplano de manera iterativa para que el error pueda minimizarse. El objetivo de SVM es dividir los conjuntos
de datos en clases para encontrar un hiperplano marginal máximo (MMH).

Página 61 de 82
Los siguientes son conceptos importantes en SVM:

Vectores de soporte
Los puntos de datos que están más cerca del hiperplano se denominan vectores de soporte. La línea de separación se definirá
con la ayuda de estos puntos de datos.

Hiperplano
Como podemos ver en el diagrama anterior, es un plano o espacio de decisión que se divide entre un conjunto de objetos que
tienen diferentes clases.

Margen
Se puede definir como la brecha entre dos líneas en los puntos de datos más cercanos de diferentes clases. Se puede calcular
como la distancia perpendicular de la línea a los vectores de soporte. El margen grande se considera un buen margen y el margen
pequeño se considera un margen malo.

El objetivo principal de SVM es dividir los conjuntos de datos en clases para encontrar un hiperplano marginal máximo (MMH)
y se puede hacer en los siguientes dos pasos:

• Primero, SVM generará hiperplanos iterativamente que segregan las clases de la mejor manera.

Página 62 de 82
 • Luego, elegirá el hiperplano que separa las clases correctamente.

• Implementando SVM en Python

Importación de bibliotecas
Para implementar SVM en Python, comenzaremos con la importación de bibliotecas estándar de la siguiente manera:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from scipy import stats
import seaborn as sns; sns.set()

Conjunto de datos de muestra

A continuación, estamos creando un conjunto de datos de muestra, con datos linealmente separables, de
sklearn.dataset.sample_generator para la clasificación mediante SVM:

X, y = make_blobs(n_samples=100, centers=2, random_state=0, cluster_std=0.50)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer'); plt.show()

Resultado
El siguiente sería el resultado después de generar un conjunto de datos de muestra con 100 muestras y 2 grupos:

Página 63 de 82
Sabemos que SVM admite la clasificación discriminativa. Divide las clases entre sí simplemente encontrando una línea en el
caso de dos dimensiones o una variedad en el caso de múltiples dimensiones. Esta se puede implementar en el conjunto de
datos anterior de la siguiente manera:

Código
import pandas as pd import numpy as np
import matplotlib.pyplot as plt from
sklearn.datasets import make_blobs
from scipy import stats import
seaborn as sns; sns.set()

X, y = make_blobs(n_samples=100, centers=2, random_state=0, cluster_std=0.50)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');

xfit = np.linspace(-1, 3.5)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
plt.plot([0.6], [2.1], 'x', color='black', markeredgewidth=4, markersize=12)
for m, b in [(1, 0.65), (0.5, 1.6), (-0.2, 2.9)]: plt.plot(xfit, m * xfit +
b, '-k') plt.xlim(-1, 3.5); plt.show()

Resultado
Cuyo resultado será el siguiente:

Podemos ver en el resultado anterior que hay tres separadores diferentes que discriminan perfectamente las muestras
anteriores.

Página 64 de 82
Como hemos visto, el objetivo principal de SVM es dividir los conjuntos de datos en clases para encontrar un hiperplano
marginal máximo (MMH), por lo tanto, en lugar de dibujar una línea cero entre clases, podemos dibujar alrededor de cada línea
un margen de cierto ancho hasta el punto más cercano.

Código
Esto se puede realizar de la siguiente manera:

import pandas as pd import numpy as np

import matplotlib.pyplot as plt from
sklearn.datasets import make_blobs
from scipy import stats import
seaborn as sns; sns.set()

X, y = make_blobs(n_samples=100, centers=2, random_state=0, cluster_std=0.50)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');

xfit = np.linspace(-1, 3.5)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer') for m, b, d
in [(1, 0.65, 0.33), (0.5, 1.6, 0.55), (-0.2, 2.9, 0.2)]: yfit = m *
xfit + b plt.plot(xfit, yfit, '-k')
plt.fill_between(xfit, yfit - d, yfit + d, edgecolor='none',
color='#AAAAAA', alpha=0.4) plt.xlim(-1, 3.5);
plt.show()

Resultado
Obteniendo el siguiente resultado:

Página 65 de 82
A partir de la imagen de arriba en la salida, podemos observar fácilmente los "márgenes" dentro de los clasificadores
discriminativos. SVM elegirá la línea que maximice el margen.

A continuación, utilizaremos el clasificador de vectores de soporte de Scikit-Learn para entrenar un modelo SVM en estos datos.

1
Aquí, estamos usando kernel lineal para ajustar SVM de la siguiente manera:

from sklearn.svm import SVC # "Support vector classifier"

model = SVC(kernel='linear', C=1E10)
model.fit(X, y)

2
Ahora, para una mejor comprensión, lo siguiente trazará las funciones de decisión para 2D SVC:
def decision_function(model, ax=None, plot_support=True):
"""Plot the decision function for a 2D SVC"""
if ax is None:
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()

3
Para evaluar el modelo, necesitamos crear una cuadrícula de la siguiente manera:

x = np.linspace(xlim[0], xlim[1], 30)

y = np.linspace(ylim[0], ylim[1], 30)
Y, X = np.meshgrid(y, x)
xy = np.vstack([X.ravel(), Y.ravel()]).T P =
model.decision_function(xy).reshape(X.shape)

4
A continuación, debemos trazar los límites y márgenes de decisión de la siguiente manera:
ax.contour(X, Y, P, colors='k',
levels=[-1, 0, 1], alpha=0.5,
linestyles=['--', '-', '--'])

5
Con el siguiente codigo se grafica de manera similar los vectores de soporte:

if plot_support:
ax.scatter(model.support_vectors_[:, 0],
model.support_vectors_[:, 1], s=300,
linewidth=1, facecolors='none');
ax.set_xlim(xlim) ax.set_ylim(ylim)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
decision_function(model);

6
Página 66 de 82
Ahora, utilizamos esta función para ajustar nuestros modelos:
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
decision_function(model);

plt.show()

7
El gráfico resultante es el siguiente:

Código
El código completo es el siguiente:

import pandas as pd import numpy as np

import matplotlib.pyplot as plt from
sklearn.datasets import make_blobs
from scipy import stats import
seaborn as sns; sns.set()

X, y = make_blobs(n_samples=100, centers=2, random_state=0, cluster_std=0.50)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');

xfit = np.linspace(-1, 3.5)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer') for m, b, d
in [(1, 0.65, 0.33), (0.5, 1.6, 0.55), (-0.2, 2.9, 0.2)]: yfit = m *
xfit + b plt.plot(xfit, yfit, '-k')
plt.fill_between(xfit, yfit - d, yfit + d, edgecolor='none',
color='#AAAAAA', alpha=0.4)
plt.xlim(-1, 3.5);
# plt.show()

Página 67 de 82
 from sklearn.svm import SVC # "Support vector classifier"
model = SVC(kernel='linear', C=1E10)
model.fit(X, y)

def decision_function(model, ax=None, plot_support=True):

"""Plot the decision function for a 2D SVC"""
if ax is None:
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()

# create grid to evaluate model

x = np.linspace(xlim[0], xlim[1], 30)
y = np.linspace(ylim[0], ylim[1], 30)
Y, X = np.meshgrid(y, x)
xy = np.vstack([X.ravel(), Y.ravel()]).T
P = model.decision_function(xy).reshape(X.shape)

# plot decision boundary and margins

ax.contour(X, Y, P, colors='k',
levels=[-1, 0, 1], alpha=0.5,
linestyles=['--', '-', '--'])

# plot support vectors

if plot_support:
ax.scatter(model.support_vectors_[:, 0],
model.support_vectors_[:, 1],
s=300, linewidth=1, facecolors='none');
ax.set_xlim(xlim)
ax.set_ylim(ylim)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
decision_function(model);

print(model.support_vectors_)

plt.show()

Podemos observar en el resultado anterior que un clasificador SVM se ajusta a los datos con márgenes, es decir, líneas
discontinuas y vectores de soporte, los elementos fundamentales de este ajuste, tocando la línea discontinua.

1
Estos puntos de vector de soporte se almacenan en el atributo support_vectors_ del clasificador de la siguiente manera:
(model.support_vectors_)

2
Para verlo solo debemos agregar el siguiente codigo a la línea anter de plt.show:
print(model.support_vectors_)

3
Con esta operación, obtenemos el siguiente resultado:

Página 68 de 82
Una clave del éxito de este clasificador es que, para el ajuste, solo importa la posición de los vectores de soporte; los puntos
más alejados del margen que están en el lado derecho no modifican el ajuste.

Técnicamente, esto se debe a que estos puntos no contribuyen a la función de pérdida utilizada para ajustar el modelo, por lo
que su posición y número no importan siempre que no crucen el margen.

Podemos ver esto, por ejemplo, si trazamos el modelo aprendido de los primeros 60 puntos y los primeros 120 puntos de este
conjunto de datos:

Código
Simplemente agregando el siguiente fragmento de código:
def plot_svm(N=10, ax=None):
X, y = make_blobs(n_samples=200, centers=2,
random_state=0, cluster_std=0.60)
X = X[:N]
y = y[:N]
model = SVC(kernel='linear', C=1E10)
model.fit(X, y)

ax = ax or plt.gca()
ax.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
ax.set_xlim(-1, 4)
ax.set_ylim(-1, 6)
decision_function(model, ax)

fig, ax = plt.subplots(1, 2, figsize=(16, 6))

fig.subplots_adjust(left=0.0625, right=0.95, wspace=0.1)
for axi, N in zip(ax, [60, 120]):
plot_svm(N, axi)
axi.set_title('N = {0}'.format(N))

plt.show()

Resultado
Obteniendo el siguiente resultado:

Página 69 de 82
Código completo
import pandas as pd import numpy as np
import matplotlib.pyplot as plt from
sklearn.datasets import make_blobs
from scipy import stats import
seaborn as sns; sns.set()

X, y = make_blobs(n_samples=100, centers=2, random_state=0, cluster_std=0.50)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer');

xfit = np.linspace(-1, 3.5)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer') for m, b, d
in [(1, 0.65, 0.33), (0.5, 1.6, 0.55), (-0.2, 2.9, 0.2)]: yfit = m *
xfit + b plt.plot(xfit, yfit, '-k')
plt.fill_between(xfit, yfit - d, yfit + d, edgecolor='none',
color='#AAAAAA', alpha=0.4)
plt.xlim(-1, 3.5);
# plt.show()

from sklearn.svm import SVC # "Support vector classifier"

model = SVC(kernel='linear', C=1E10)
model.fit(X, y)

def decision_function(model, ax=None, plot_support=True):

"""Plot the decision function for a 2D SVC"""
if ax is None:
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()

# create grid to evaluate model x =

np.linspace(xlim[0], xlim[1], 30) y
= np.linspace(ylim[0], ylim[1], 30)
Y, X = np.meshgrid(y, x)
xy = np.vstack([X.ravel(), Y.ravel()]).T P =
model.decision_function(xy).reshape(X.shape)

# plot decision boundary and margins

ax.contour(X, Y, P, colors='k', levels=[-
1, 0, 1], alpha=0.5, linestyles=['--', '-
', '--'])

# plot support vectors

if plot_support:

Página 70 de 82
 ax.scatter(model.support_vectors_[:, 0],
model.support_vectors_[:, 1],
s=300, linewidth=1, facecolors='none');
ax.set_xlim(xlim)
ax.set_ylim(ylim)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
decision_function(model);

print(model.support_vectors_)

def plot_svm(N=10, ax=None):

X, y = make_blobs(n_samples=200, centers=2,
random_state=0, cluster_std=0.60)
X = X[:N]
y = y[:N]
model = SVC(kernel='linear', C=1E10)
model.fit(X, y)

ax = ax or plt.gca()
ax.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='summer')
ax.set_xlim(-1, 4)
ax.set_ylim(-1, 6)
decision_function(model, ax)

fig, ax = plt.subplots(1, 2, figsize=(16, 6))

fig.subplots_adjust(left=0.0625, right=0.95, wspace=0.1)
for axi, N in zip(ax, [60, 120]):
plot_svm(N, axi)
axi.set_title('N = {0}'.format(N))

plt.show()

Redes neurales

Las redes neuronales (NN), también llamadas redes neuronales artificiales (ANN), son un subconjunto de algoritmos de
aprendizaje dentro del campo del aprendizaje automático que se basan libremente en el concepto de redes neuronales
biológicas.

Según, Andrey Bulezyuk, un especialista alemán en aprendizaje automático con más de cinco años de experiencia, opina que
"las redes neuronales están revolucionando el aprendizaje automático porque son capaces de modelar de manera eficiente
abstracciones sofisticadas en una amplia gama de disciplinas e industrias".

Básicamente, una ANN se compone de los siguientes componentes:

1
Una capa de entrada que recibe datos y los pasa

2
Una capa oculta

3
Una capa de salida

4
Pesos entre las capas.

Página 71 de 82
5
Una función de activación deliberada para cada capa oculta.

Hay varios tipos de redes neuronales. En este nuestro caso vamos a exponer las redes neuronales del tipo feed-forward o de
percepción. Este tipo de red Neural transmite datos directamente de adelante hacia atrás.

El entrenamiento de las neuronas de alimentación hacia adelante a menudo necesita propagación hacia atrás, lo que
proporciona a la red el conjunto correspondiente de entradas y salidas. Cuando los datos de entrada se transmiten a la neurona,
se procesan y se genera una salida. Aquí hay un diagrama que muestra la estructura de una red neuronal simple:

Hay dos formas de crear una red neuronal en Python:

Desde cero
Este puede ser un buen ejercicio de aprendizaje, ya que nos puede enseñar cómo funcionan las redes neuronales desde el
principio.

Uso de una biblioteca de redes neuronales

Paquetes como Keras y TensorFlow simplifican la creación de redes neuronales al abstraer el código de bajo nivel. Es decir, que
esta es la forma más rápida y sencilla de crearlas.

Independientemente del método que se elija, trabajar con una red neuronal para hacer una predicción es esencialmente lo
mismo.

Para ello debemos:

1
Importar las bibliotecas. Por ejemplo: importar numpy como np
2
Definir/crear datos de entrada. Por ejemplo, usando Numpy para crear un conjunto de datos y una matriz de valores de datos.

Página 72 de 82
3
Agregar pesos y sesgos (si corresponde) a las características de entrada. Estos son parámetros que se pueden aprender, lo que
significa que se pueden ajustar durante el entrenamiento. Los pesos son parámetros de
entrada que influyen en la salida y los sesgos son valores de umbral adicional agregado a la salida

4
Entrenar la red con datos buenos y conocidos para encontrar los valores correctos para los pesos y sesgos.

5
Probar la red con un conjunto de datos de prueba para ver cómo funciona.

6
Ajusta el modelo con hiperparámetros (parámetros cuyos valores se utilizan para controlar el proceso de aprendizaje),
calculando la precisión y realizando una predicción.

La mejor manera de entender cómo funcionan las redes neuronales es aprender a construir una desde cero. En este apartado,
explicaremos cómo usar el lenguaje de programación Python para crear una red neuronal simple.

A continuación vamos a crear una red neural simple, utilizando la siguiente tabla de datos. En donde falta un posible valor de
salida en la nueva situación:

Vamos a entrenar la red neuronal de modo que pueda predecir el valor de salida correcto cuando se le proporcione un nuevo
conjunto de datos. Como podemos ver en la tabla, el valor de la salida siempre es igual al primer valor en la sección de entrada.
Por lo tanto, esperamos que el valor de la salida ( ? ) sea 1.

Creación de una clase de red neuronal

Crearemos una clase NeuralNetwork en Python para entrenar a la neurona para que proporcione una predicción precisa. La
clase también tendrá otras funciones auxiliares.

Aunque no usaremos una biblioteca de red neuronal para este ejemplo de red neuronal simple, importaremos la biblioteca
NumPy para ayudar con los cálculos.
Numpy viene con los siguientes cuatro métodos importantes:

Exp
Para generar el exponencial natural. array

Página 73 de 82
Para generar una matriz. dot

Para multiplicar matrices.

random
Para generar números aleatorios. Tenga en cuenta que sembraremos los números aleatorios para asegurar su distribución
eficiente.

Página 74 de 82
A su vez, usaremos la función Sigmoid, que dibuja una curva característica en forma de "S", como función de activación de la
red neuronal.

Esta función puede asignar cualquier valor a un valor de 0 a 1. Nos ayudará a normalizar la suma ponderada de las entradas. A
partir de entonces, crearemos la derivada de la función Sigmoid para ayudar a calcular los ajustes esenciales de los pesos.

La salida de una función sigmoidea se puede emplear para generar su derivada. Por ejemplo, si la variable de salida es "x",
entonces su derivada será x * (1-x).

Entrenando al modelo

Esta es la etapa en la que le enseñaremos a la red neuronal a hacer una predicción precisa. Cada entrada tendrá un peso, ya
sea positivo o negativo.

Esto implica que una entrada que tenga una gran cantidad de peso positivo o una gran cantidad de peso negativo influirá más
en la salida resultante. Recordemos que inicialmente comenzamos asignando cada peso a un número aleatorio. Este es el
procedimiento para el proceso de entrenamiento que usaremos en este problema de ejemplo de red neuronal, para ello vamos
a:

1
Tomar las entradas del conjunto de datos de entrenamiento, realizamos algunos ajustes en función de sus pesos y los
extrajimos a través de un método que calculó la salida de la ANN.

2
Calcular la tasa de error retropropagada. En este caso, es la diferencia entre la salida predicha de la neurona y la salida esperada
del conjunto de datos de entrenamiento.

Página 75 de 82
3
Realizar algunos ajustes de ponderación menores utilizando la fórmula Derivada ponderada del error. En función de la
magnitud del error obtenido.

4
Repetir este proceso un número arbitrario de 15.000 veces. En cada iteración, todo el conjunto de entrenamiento se procesa
simultáneamente.

Usamos la función ".T" para transponer la matriz de la posición horizontal a la posición vertical. Por lo tanto, los números se
almacenarán de esta manera:

En última instancia, los pesos de la neurona se optimizarán para los datos de entrenamiento proporcionados. En consecuencia,
si se hace pensar a la neurona en una nueva situación, que sea igual a la anterior, podría hacer una predicción certera. Así es
como se lleva a cabo la retro-propagación.

Por ultimo, inicializamos la clase NeuralNetwork y ejecutamos el código.

Código
Aquí está el código completo:
import numpy as np

class NeuralNetwork():

def __init__(self):
# seeding for random number generation
np.random.seed(1)

#converting weights to a 3 by 1 matrix with values from -1 to 1 and mean

of 0
self.synaptic_weights = 2 * np.random.random((3, 1)) - 1

def sigmoid(self, x):

#applying the sigmoid function
return 1 / (1 + np.exp(-x))

def sigmoid_derivative(self, x):

#computing derivative to the Sigmoid function
return x * (1 - x)

def train(self, training_inputs, training_outputs, training_iterations):

Página 76 de 82
 #training the model to make accurate predictions while adjusting weights
continually for iteration in range(training_iterations):
#siphon the training data via the neuron
output = self.think(training_inputs)

#computing error rate for back-propagation

error = training_outputs - output

#performing weight adjustments

adjustments = np.dot(training_inputs.T, error *
self.sigmoid_derivative(output))

self.synaptic_weights += adjustments

def think(self, inputs):

#passing the inputs via the neuron to get output
#converting values to floats

inputs = inputs.astype(float)
output = self.sigmoid(np.dot(inputs, self.synaptic_weights))
return output

if __name__ == "__main__":

#initializing the neuron class

neural_network = NeuralNetwork()

print("Beginning Randomly Generated Weights: ")

print(neural_network.synaptic_weights)

#training data consisting of 4 examples--3 input values and 1 output

training_inputs = np.array([[0,0,1],
[1,1,1],
[1,0,1],
[0,1,1]])

training_outputs = np.array([[0,1,1,0]]).T

#training taking place

neural_network.train(training_inputs, training_outputs, 15000)

print("Ending Weights After Training: ")

print(neural_network.synaptic_weights)

user_input_one = str(input("User Input One: "))

user_input_two = str(input("User Input Two: "))
user_input_three = str(input("User Input Three: "))

print("Considering New Situation: ", user_input_one, user_input_two,

user_input_three) print("New Output data: ")
print(neural_network.think(np.array([user_input_one, user_input_two,
user_input_three]))) print("Wow, we did it!")

Resultado
Una vez ejecutado le introducimos como datos 1,0,0 y obtenemos el siguiente resultado:

Página 77 de 82
Logramos crear una red neuronal simple. La neurona comenzó asignándose algunos pesos aleatorios. A partir de entonces, se
entrenó usando los ejemplos de entrenamiento. En consecuencia, si se le presentaba una nueva situación [1,0,0], daba el valor
de 0,9999584. Recordemos, que la respuesta correcta que queríamos era 1. En donde el valor obtenido estuvo muy cerca,
considerando que la función Sigmoid genera valores entre
0 y 1. Por supuesto, solo usamos una red de neuronas para llevar a cabo la tarea simple.

En esta sección, realizaremos la predicción de abandono de empleados utilizando Multi-Layer Perceptron. La predicción de
abandono de empleados nos ayuda a diseñar mejores planes de retención de empleados y a mejorar la satisfacción de los
empleados. Comencemos con la construcción práctica del modelo en Python.

Cargar conjunto de datos

Primero, carguemos el conjunto de datos de recursos humanos requerido ”hr-comma-sep.csv” usando la función de CSV de
lectura de pandas. Puede descargar los datos desde el siguiente:

Código
import numpy as np
import pandas as pd
from sklearn import preprocessing

# Load data
data=pd.read_csv('HR_comma_sep.csv')

print(data.head())

Página 78 de 82
Resultado
Al ejecutarlo obtenemos los primeros datos:

Preprocesamiento: codificación de etiquetas

Muchos algoritmos de aprendizaje automático requieren datos de entrada numéricos, por lo que debe representar columnas
categóricas en una columna numérica. Para codificar estos datos, se puede asignar cada valor a un número.

Por ejemplo, el valor de la columna de salario se puede representar como bajo: 0, medio: 1 y alto: 2. Este proceso se conoce
como codificación de etiquetas. En sklearn, podemos hacer esto usando LabelEncoder. Código:

# Import LabelEncoder
from sklearn.preprocessing import StandardScaler

# Creating labelEncoder

le = preprocessing.LabelEncoder()
data["salary"]=le.fit_transform(data["salary"])
data["sales"]=le.fit_transform(data["sales"])

Dividir el conjunto de datos

Para evaluar el rendimiento del modelo, necesitamos dividir el conjunto de datos en un conjunto de entrenamiento y un
conjunto de prueba. Dividamos el conjunto de datos usando la función train_test_split(). necesita pasar básicamente 3
características de parámetros, objetivo y tamaño de test_set.

# Spliting data into Feature and

X=data[['satisfaction_level', 'last_evaluation', 'number_project',
'average_montly_hours', 'time_spend_company', 'Work_accident',
'promotion_last_5years', 'sales', 'salary']]
y=data['left']

# Import train_test_split function

from sklearn.model_selection import train_test_split

# Split dataset into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=42) # 70% training and 30% test
Construir el modelo de clasificación

A continuacion vamos a construir un modelo de predicción de abandono de empleados. Aquí, nuestro objetivo es predecir la
rotación usando MLPClassifier. Primero, importamos el módulo MLPClassifier y creamos el objeto MLP Classifier utilizando la
función MLPClassifier(). Luego, ajustamos el modelo en el conjunto de train usando fit() y realizamos la predicción en el
conjunto de prueba usando predict().

Página 79 de 82
 # Import MLPClassifer
from sklearn.neural_network import MLPClassifier

# Create model object

clf = MLPClassifier(hidden_layer_sizes=(6,5),
random_state=5,
verbose=True,
learning_rate_init=0.01)

# Fit data onto the model

clf.fit(X_train,y_train)

Parámetros:

hidden_layer_sizes
Es una tupla donde cada elemento representa una capa y su valor representa el número de neuronas en cada capa oculta.

learning_rate_init
Solía controlar el tamaño del paso en la actualización de los pesos.

activación
Función de activación de la capa oculta. Ejemplos, identidad, logística, tanh y relu. por defecto, relu se utiliza como una función
de activación.

random_state
Define el número aleatorio para la inicialización de los pesos y sesgos.

verbose
Imprimir mensajes de progreso en la salida estándar.

Realizar las predicciones y evalar el modelo

En esta sección, haremos predicciones sobre el conjunto de datos de prueba y evaluaremos la precisión del modelo en función
de las etiquetas reales disponibles del conjunto de datos de prueba.

Código
#Make prediction on test dataset
ypred=clf.predict(X_test)

# Import accuracy score

from sklearn.metrics import accuracy_score

# Calcuate accuracy
print(accuracy_score(y_test,ypred))

Resultado
Resultado de la ejecucion:

Página 80 de 82
Después de una iteración de 136 cálculos, obtuvimos una tasa de clasificación del 93,8 %, lo que se considera una buena
precisión.

Código completo
El código completo es el siguiente:
import numpy as np
import pandas as pd
from sklearn import preprocessing

# Load data
data=pd.read_csv('HR_comma_sep.csv')

print(data.head())

# Import LabelEncoder
from sklearn.preprocessing import StandardScaler

# Creating labelEncoder

le = preprocessing.LabelEncoder()
data["salary"]=le.fit_transform(data["salary"])

Página 81 de 82
 data["sales"]=le.fit_transform(data["sales"])

# Spliting data into Feature and

X=data[['satisfaction_level', 'last_evaluation', 'number_project',
'average_montly_hours', 'time_spend_company', 'Work_accident',
'promotion_last_5years', 'sales', 'salary']]
y=data['left']

# Import train_test_split function

from sklearn.model_selection import train_test_split

# Split dataset into training set and test set

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=42) # 70% training and 30% test

# Import MLPClassifer
from sklearn.neural_network import MLPClassifier

# Create model object

clf = MLPClassifier(hidden_layer_sizes=(6,5),
random_state=5,
verbose=True,
learning_rate_init=0.01)

# Fit data onto the model

clf.fit(X_train,y_train)

#Make prediction on test dataset

ypred=clf.predict(X_test)

# Import accuracy score

from sklearn.metrics import accuracy_score

# Calcuate accuracy
print(accuracy_score(y_test,ypred))

Responde con tus propias palabras.

¿Qué es el parámetro hidden_layer_sizes?
¡Muy bien! hidden_layer_sizes es una tupla donde cada elemento representa una capa y su valor representa el número de
neuronas en cada capa oculta.
¿Qué es el parámetro learning_rate_init?
¡Muy bien! learning_rate_init solía controlar el tamaño del paso en la actualización de los pesos.

Página 82 de 82