Ligdi González

2.ª edición
1
Ligdi González
2020

_______________________________

Machine Learning
con Python
Aprendizaje Supervisado

2
 INDICE

CAPÍTULO 1................................................................................................................................ 6
INTRODUCCIÓN .................................................................................................................................................. 6
MACHINE LEARNING CON PYTHON ........................................................................................................... 6
CAPÍTULO 2 ............................................................................................................................... 8
PREPARAR EL ENTORNO DE PYTHON .............................................................................................................8
PYTHON ...........................................................................................................................................................8
LIBRERÍAS PARA LA CIENCIA DE DATOS ................................................................................................... 9
LIBRERÍAS PARA LA VISUALIZACIÓN DE DATOS ................................................................................... 10
LIBRERÍAS PARA MACHINE LEARNING ................................................................................................... 10
INSTALAR EL ENTORNO DE PYTHON ........................................................................................................11
TRABAJANDO CON EL IDE SPYDER .......................................................................................................... 13
TRABAJANDO CON EL IDE JUPYTER NOTEBOOK ................................................................................... 14
CAPÍTULO 3 ............................................................................................................................. 16
CURSOS INTENSIVOS DE PYTHON Y SCIPY ................................................................................................... 16
CURSO INTENSIVO DE PYTHON ................................................................................................................ 16
CURSO INTENSIVO DE NUMPY .................................................................................................................. 17
CURSO INTENSIVO DE PANDAS ................................................................................................................. 21
CURSO INTENSIVO DE MATPLOTLIB ........................................................................................................23
CAPÍTULO 4 ............................................................................................................................. 25
CARGAR LOS DATOS ......................................................................................................................................... 25
CONSIDERACIONES DE LOS ARCHIVOS CSV ........................................................................................... 25
CONJUNTO DE DATOS: DIABETES DE LOS INDIOS PIMA .....................................................................26
CARGAR ARCHIVOS CSV UTILIZANDO PYTHON .....................................................................................26
CARGAR ARCHIVOS UTILIZANDO PYTHON ............................................................................................. 27
CAPÍTULO 5 ............................................................................................................................. 28
ENTENDIENDO LOS DATOS ........................................................................................................................... 28
VERIFICAR LOS DATOS .............................................................................................................................. 28
DIMENSIONANDO LOS DATOS ...................................................................................................................29
TIPOS DE DATOS.......................................................................................................................................... 30
DESCRIPCIÓN ESTADÍSTICA ..................................................................................................................... 30
DISTRIBUCIÓN DE CLASES (PROBLEMAS DE CLASIFICACIÓN) ........................................................... 31
CORRELACIÓN ENTRE CARACTERÍSTICAS..............................................................................................32
CONSIDERACIONES ADICIONALES ...........................................................................................................32
CAPÍTULO 6 ............................................................................................................................. 33
VISUALIZANDO LOS DATOS ............................................................................................................................ 33
GRÁFICAR CON UNA SOLA VARIABLES .................................................................................................... 33
GRÁFICAR CON VARIAS VARIABLES ......................................................................................................... 35
CAPÍTULO 7 ............................................................................................................................. 37
PROCESAMIENTO DE LOS DATOS .................................................................................................................. 37
SEPARACIÓN DE LOS DATOS ...................................................................................................................... 37
ESTANDARIZACIÓN DE LOS DATOS ......................................................................................................... 38
NORMALIZACIÓN DE LOS DATOS............................................................................................................. 40
ELIMINACIÓN DE COLUMNAS ................................................................................................................... 41
CAPÍTULO 8 ............................................................................................................................. 43
SELECCIONANDO CARACTERÍSTICAS ...........................................................................................................43
IMPORTANCIA DE LAS CARACTERÍSTICAS ..............................................................................................43

3
 MÉTODOS DE FILTRO ..................................................................................................................................44
MÉTODOS DE ENVOLTURA ........................................................................................................................46
MÉTODOS INTEGRADOS ............................................................................................................................ 48
CAPÍTULO 9 ............................................................................................................................. 49
ALGORITMOS DE CLASIFICACIÓN .................................................................................................................49
REGRESIÓN LOGÍSTICA ............................................................................................................................. 50
K - VECINOS MÁS CERCANOS ..................................................................................................................... 51
MÁQUINAS DE VECTORES DE SOPORTE .................................................................................................. 52
BAYESIANO INGENUO (NAIVE BAYES) ..................................................................................................... 53
ÁRBOLES DE DECISIÓN CLASIFICACIÓN ................................................................................................. 54
BOSQUES ALEATORIOS CLASIFICACIÓN.................................................................................................. 55
CAPÍTULO 10 ........................................................................................................................... 57
MÉTRICAS DE RENDIMIENTO ALGORITMOS DE CLASIFICACIÓN ........................................................... 57
MATRIZ DE CONFUSIÓN ............................................................................................................................. 57
REPORTE DE CLASIFICACIÓN ....................................................................................................................58
ÁREA BAJO LA CURVA ................................................................................................................................. 59
CAPÍTULO 11 ............................................................................................................................ 61
ALGORITMOS DE REGRESIÓN ........................................................................................................................ 61
REGRESIÓN LINEAL .................................................................................................................................... 61
REGRESIÓN POLINOMEAL .........................................................................................................................62
VECTORES DE SOPORTE REGRESIÓN ......................................................................................................63
ÁRBOLES DE DECISIÓN REGRESIÓN ........................................................................................................ 65
BOSQUES ALEATORIOS REGRESIÓN ........................................................................................................66
CAPÍTULO 12 ............................................................................................................................ 68
MÉTRICAS DE RENDIMIENTO ALGORITMOS DE REGRESIÓN ................................................................. 68
ERROR CUADRÁTICO MEDIO (RMSE)...................................................................................................... 68
ERROR ABSOLUTO MEDIO (MAE) .............................................................................................................69
CAPÍTULO 13 ............................................................................................................................. 71
PROYECTO DE MACHINE LEARNING - CLASIFICACIÓN ............................................................................. 71
DEFINICIÓN DEL PROBLEMA .................................................................................................................... 71
IMPORTAR LAS LIBRERÍAS......................................................................................................................... 72
CARGAR EL CONJUNTO DE DATOS ........................................................................................................... 72
ENTENDIENDO LOS DATOS ........................................................................................................................ 73
VISUALIZANDO LOS DATOS........................................................................................................................ 75
SEPARACIÓN DE LOS DATOS ...................................................................................................................... 78
SELECCIONANDO CARACTERÍSTICAS ...................................................................................................... 79
PROCESAMIENTO DE LOS DATOS ............................................................................................................ 80
SEPARACIÓN DE LOS DATOS ..................................................................................................................... 80
APLICACIÓN DE LOS ALGORITMOS DE CLASIFICACIÓN ....................................................................... 81
CAPÍTULO 14............................................................................................................................ 89
PROYECTO DE MACHINE LEARNING - REGRESIÓN ................................................................................... 89
DEFINICIÓN DEL PROBLEMA ................................................................................................................... 89
IMPORTAR LAS LIBRERÍAS........................................................................................................................ 90
CARGAR EL CONJUNTO DE DATOS .......................................................................................................... 90
ENTENDIENDO LOS DATOS ........................................................................................................................ 91
VISUALIZANDO LOS DATOS........................................................................................................................92
SEPARACIÓN DE LOS DATOS ......................................................................................................................94
SEPARACIÓN DE LOS DATOS ...................................................................................................................... 95
APLICACIÓN DE LOS ALGORITMOS DE REGRESIÓN .............................................................................96
CAPÍTULO 15 .......................................................................................................................... 102

4
 CONTINUAR APRENDIENDO MACHINE LEARNING ................................................................................. 102
CONSTRUIR PLANTILLAS PARA PROYECTOS ........................................................................................ 102
CONJUNTOS DE DATOS PARA PRÁCTICA ............................................................................................... 103
CAPÍTULO 16.......................................................................................................................... 105
OBTENER MÁS INFORMACIÓN ..................................................................................................................... 105
CONSEJO GENERAL ................................................................................................................................... 105
AYUDA CON PYTHON ................................................................................................................................. 106
AYUDA CON SCIPY Y NUMPY .................................................................................................................... 106
AYUDA CON MATPLOTLIB ........................................................................................................................ 106
AYUDA CON PANDAS ................................................................................................................................. 107
AYUDA CON SCIKIT-LEARN ...................................................................................................................... 107

5
Capítulo 1
INTRODUCCIÓN

Este libro es una guía para aprender Machine Learning aplicado con Python. Se
descubrirá, paso a paso, el proceso que se puede usar para comenzar en Machine
Learning con el ecosistema de Python.

MACHINE LEARNING CON PYTHON

Este libro se enfoca en proyectos de Machine Learning con el lenguaje de programación
de Python. Está escrito para explicar cada uno de los pasos para desarrollar un proyecto
de Machine Learning con algoritmos de clasificación y regresión. Se encuentra dividido
de la siguiente forma:

• Aprender cómo las subtareas de un proyecto de Machine Learning se asignan a

Python y la mejor forma de trabajar a través de cada tarea.
• Finalmente, se une todo el conocimiento explicado para desarrollar un problema
de clasificación y otro de regresión.

En los primeros capítulos se aprenderá a cómo completar las subtareas específicas de

un proyecto de Machine Learning utilizando Python. Una vez que se aprenda a cómo
completar una tarea utilizando la plataforma y obtener un resultado de manera
confiable se podrá utilizar una y otra vez en proyecto tras proyecto.

Un proyecto de Machine Learning, se puede dividir en 4 tareas:

6
 • Definir el problema: investigar y caracterizar el problema para comprender
mejor los objetivos del proyecto.
• Analizar los datos: usar estadísticas descriptivas y visualizarlas para
comprender mejor los datos que se tiene disponible.
• Preparar los datos: utilizar las transformaciones de datos para exponer mejor
la estructura del problema de predicción a los algoritmos de Machine Learning.
• Evaluar los algoritmos: diseñar pruebas para evaluar una serie de algoritmos
estándar en los datos y seleccionar los mejores para investigar más a fondo.

En la última parte del libro, unirá todo lo aprendido anteriormente, para el desarrollo
de un proyecto, uno con algoritmos de clasificación y otro con algoritmos de regresión.

Cada una de las lecciones están diseñadas para leerse de principio a fin en orden, y
mostrar exactamente cómo completar cada tarea en un proyecto de Machine Learning.
Por supuesto, se puede dedicar a capítulos específicos, posteriormente, para refrescar
los conocimientos. Los capítulos están estructurados para demostrar las librerías y
funciones y mostrar técnicas específicas para una tarea de Machine Learning.

Cada capítulo esta diseñado para completarse en menos de 30 minutos (dependiendo

de su nivel de habilidad y entusiasmo). Es posible trabajar con todo el libro en un fin
de semana. También funciona, si desea, sumergirse en capítulos específicos y utilizar
el libro como referencia.

7
Capítulo 2
PREPARAR EL ENTORNO DE
PYTHON

Python está creciendo y puede convertirse en la plataforma dominante para Machine

Learning, la razón principal para adoptar este lenguaje de programación es que es de
propósito general que puede ser usado tanto para investigación y desarrollo, como en
producción.

En este capítulo aprenderás todo lo relacionado al entorno de Python para Machine

Learning:

1. Python y su uso para Machine Learning.

2. Las librerías básicas para Machine Learning como lo son SciPy, NumPy y
Pandas.
3. La librería para la visualización de datos como lo es matplotlib.
4. La librería para implementar algoritmos de Machine Learning, scikit-learn.
5. Configurar el entorno de Python utilizando Anaconda.
6. Configurar el IDE Spyder.
7. Configurar el IDE Jupyter Notebook.

PYTHON
Python lidera en lenguajes de desarrollo de Machine Learning debido a su simplicidad
y facilidad de aprendizaje. Python es utilizado por más y más científicos de datos y

8
desarrolladores para la construcción y análisis de modelos. Además, es un éxito entre
los principiantes que son nuevos en Machine Learning.

A diferencia de otros lenguajes de programación para Machine Learning, como R o

MATLAB, el procesamiento de datos y las expresiones matemáticas científicas no están
integradas en el lenguaje en sí, pero las librerías como SciPy, NumPy y Pandas, ofrecen
una funcionalidad equivalente en una sintaxis posiblemente más accesible.

Las librerías especializadas de Machine Learning como scikit-learn, Theano,

TensorFlow, le brindan la capacidad de capacitar a una variedad de modelos de
Machine Learning, que potencialmente utilizan infraestructura de computación
distribuida.

LIBRERÍAS PARA LA CIENCIA DE DATOS

Estas son las librerías básicas que transforman Python de un lenguaje de programación
de propósito general en una poderosa y robusta herramienta para el análisis y la
visualización de datos, estas son las bases sobre las que se basan las herramientas más
especializadas.

SciPy

SciPy es una librería de software para ingeniería y ciencia, SciPy incluye funciones para
algebra lineal, optimización, integración y estadísticas. Proporciona rutinas numéricas
eficientes como integración numérica, optimización y muchas otras a través de sus
submódulos específicos. La funcionalidad principal de esta librería se basa en NumPy
y sus matrices y el agregar una colección de algoritmos y comandos de alto nivel para
manipular y visualizar datos.

NumPy

NumPy se refiere a Numerical Python y es una librería fundamental para la informática

científica en Python ya que proporciona la vectorización de operaciones matemáticas
en el tipo de matrices, mejorando el rendimiento y, en consecuencia, acelera la
ejecución.

Esta orientada en administrar y tratar los datos como matrices, su propósito es

proporcionar la capacidad de hacer operaciones complejas de matriz que son
requeridas por redes neuronales y estadísticas complejas de manera fácil.

En resumen, NumPy presenta objetos para matrices y matrices multidimensionales,

así como rutinas que permiten a los desarrolladores realizar funciones matemáticas y
estadísticas avanzadas en esas matrices con el menor número de código posible.

9
NumPy es una librería de administración de datos que normalmente está emparejado
con TensorFlow, SciPy, matplotlib y muchas otras librerías de Python orientadas hacia
Machine Learning y la ciencia de datos.

Pandas

Pandas es una librería de Python diseñada para trabajar con datos “etiquetados” y
“relacionales” de manera simple e intuitivos, está diseñado para una manipulación,
agregación y visualización de datos rápida y fácil. Pandas agrega estructura de datos y
herramientas que están diseñadas para el análisis de datos prácticos en finanzas,
estadísticas e ingeniería. Pandas funciona bien con datos incompletos, desordenados y
no etiquetados, es decir, el tipo de datos que es probable que se encuentre en el mundo
real, y proporciona herramientas para configurar, fusionar, remodelar y dividir
conjuntos de datos. Con esta librería se puede agregar y eliminar columnas fácilmente
desde el DataFrame, convertir estructuras de datos en objetos y manejar datos faltantes
(NaN).

LIBRERÍAS PARA LA VISUALIZACIÓN DE DATOS

El mejor y más sofisticado análisis no tiene sentido si no puedes comunicarlo a otras
personas. Estas librerías permiten crear fácilmente gráficos, tablas y mapas
visualmente más atractivos y sofisticados, sin importar qué tipo de análisis estés
tratando de hacer.

Matplotlib

Es una librería estándar de Python para crear diagramas y gráficos en 2D, es de muy
bajo nivel, lo que significa que requiere más comandos para generar gráficos y figuras
agradables que con algunas librerías más avanzadas, sin embargo, la otra cara de eso
es la flexibilidad, con suficientes comandos, puedes hacer casi cualquier tipo de
gráficos que desees con matplotlib.

LIBRERÍAS PARA MACHINE LEARNING

Machine Learning se encuentra en la intersección de la Inteligencia Artificial y el
análisis estadístico. Al entrenar computadoras con conjuntos de datos del mundo real,
se puede crear algoritmos que hacen predicciones más precisas y sofisticadas, ya sea
que se este hablando de obtener mejores direcciones para conducir o construir
computadores que puedan identificar hitos simplemente observando imágenes.

Scikit-learn

La librería de scikit-learn es definitivamente una de las más populares de Machine

Learning, tiene una gran cantidad de características para la minería de datos y el

10
análisis de datos, por lo que es una excelente opción tanto para investigadores como
para desarrolladores. Está construido sobre las populares librerías NumPy, SciPy y
matplotlib, por lo que tendrás una sensación familiar al utilizarla.

Scikit-learn expone una interfaz concisa y consistente para los algoritmos comunes de
Machine Learning, por lo que es sencillo llevar a los sistemas de producción. La librería
combina código de calidad y buena documentación, facilidad de uso y alto rendimiento,
y es un estándar de la industria de facto para Machine Learning con Python.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2Qmt2Zu

INSTALAR EL ENTORNO DE PYTHON

Existen múltiples formas de instalar el entorno de Python, IDEs y librerías para ser
utilizados en Machine Learning, pero la manera más fácil, sobretodo si apenas estas
aprendiendo y no conoces cómo trabajar muy bien en la terminal de comandos, es
utilizando el entorno de Anaconda.

Solamente tienes que dirigir a la página oficial, anaconda.com y presionar el botón de

“Downloads”.

Allí seleccionar el sistema operativo que utiliza el computador.

11
Luego seleccionar la versión de Python a utilizar, se recomienda seleccionar la versión
3,6 ya que la mayoría de las librerías de Machine Learning están desarrolladas para
esta versión, mientras que la otra esta quedando cada día más obsoleta para su uso.

Una vez que se haya descargado, proceder a instalarlo en el computador, se debe tener
un poco de paciencia porque en ocasiones todo este proceso lleva un tiempo.

Al finalizar todo esto ya estará instalado en el computador, Python, gran parte de las
librerías a implementar en Machine Learning e inclusive varios IDEs que se puede
utilizar para los desarrollos de proyectos.

12
TRABAJANDO CON EL IDE SPYDER
Spyder se puede encontrar en el navegador de Anaconda “Anaconda-Navigator”.

Para abrir Spyder solamente se tiene que presionar “Launch” sobre el recuadro de la
aplicación.

Una vez que inicie Spyder deberas ver una ventana de editor abierto en el lado
izquierdo y una ventana de consola de Python en el lado inferior derecho. Por su parte,
el panel ubicado en la parte superior derecha se usa un explorador de variables, un
explorador de archivos y un navegador de ayuda. Al igual que la mayoría de los IDE, se
puede cambiar qué paneles son visibles y su diseño dentro de la ventana.

13
Se puede comenzar a trabajar con Spyder inmediatamente en la ventana de la consola.
De manera predeterminada, Spyder proporciona una consola IPython que se puede
usar para interactuar directamente con el motor de Python. Funciona, esencialmente,
de la misma manera que funciona en la línea de comando, la gran diferencia es que
Spyder puede inspeccionar los contenidos del motor de Python y puede hacer otras
cosas como mostrar variables y sus contenidos dentro del explorador de variables.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2MxKDvb

TRABAJANDO CON EL IDE JUPYTER NOTEBOOK

Jupyter Notebook lo puedes encontrar en el navegador de Anaconda “Anaconda-
Navigator”, al igual que Spyder.

14
Una vez seleccionado para abrir Jupyter, se abre una pestaña en el navegador web
predeterminado del computador. Desde acá se puede navegar a través de las carpetas
del computador para determinar en donde se guardará el documento del proyecto. Se
debe crear un nuevo Notebook de Python 3, en este momento se abre una nueva
pestaña, acá es donde se debe empezar a desarrollar el proyecto.

Para efectos del libro todas las líneas de códigos y resultados de códigos se hará
utilizando como IDE, Jupyter Notebook, esto se debe que la presentación de los datos
es ideal para facilitar el entendimiento, pero puedes seleccionar cualquier IDE de tú
preferencia.

15
Capítulo 3
CURSOS INTENSIVOS DE
PYTHON Y SCIPY

Para desarrollar algoritmos de Machine Learning en Python no es necesario ser un

desarrollador experto en Python, con solo tener las bases de cómo programar en algún
lenguaje de programación se puede ser capaz de entender Python muy fácilmente,
solamente necesitas conocer algunas propiedades del lenguaje y transferir lo que ya
realmente sabe a Python.

En este capítulo aprenderás:

1. Sintaxis básica de Python.

2. Conocimientos básicos en la programación de las librerías NumPy, Pandas y
Matplotlib.
3. Las bases para construir las tareas en Python para Machine Learning.

Si ya conoces algo de Python, este capítulo será un refrescamiento en los

conocimientos.

CURSO INTENSIVO DE PYTHON

Python es una herramienta computacional poderosa que se puede utilizar para resolver
tareas complicadas en el área de finanzas, economía, ciencia de los datos y Machine
Learning.

16
Las ventajas técnicas que ofrece Python en comparación con otros lenguajes de
programación son las siguientes:

® Es gratis y actualizado constantemente.

® Puede ser utilizado en múltiples dominios.
® No requiere de mucho tiempo para procesar cálculos y posee una sintaxis
intuitiva que permite programar complejas líneas de código.

Con todas estas características hace que Python pueda ser implementando en un sin
fin de aplicaciones.

Por lo tanto, Python basa su popularidad en dos pilares, el primero es que es fácil de
aprender ya que contiene una sintaxis clara e intuitiva y la segunda razón es que es muy
poderoso ya que puede ejecutar una variedad de complejas líneas de código.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2JEOBnR

CURSO INTENSIVO DE NUMPY

NumPy es un paquete de Python que significa “Numerical Python”, es la librería
principal para la informática científica, proporciona una estructura de datos de matriz
que tiene algunos beneficios sobre las listas regulares de Python.

Por su parte, NumPy array o el

arreglo de marices de NumPy es un
potente objeto de matriz N-
dimensional que tiene forma de
filas y columnas, en la que se tiene
varios elementos que están
almacenados en sus respectivas
ubicaciones de memoria. En la
figura se puede observar esto más
claramente, esta es una matriz
bidimensional porque tiene filas y columnas. Como se puede ver tiene cuatro filas y tres
columnas, en el caso de que solo tuviera una hilera entonces habría sido una matriz
unidimensional.

17
Según lo explicado anteriormente, en la primera figura se tiene una matriz
unidimensional o 1D. En la segunda figura, se tiene una matriz bidimensional o 2D, en
donde las filas se indican como el eje 0, mientras que las columnas son el eje 1.

El número de ejes aumenta de acuerdo con el número de dimensiones, en matrices 3D,

se tendrá un eje 2, adicional. Estos ejes solo son válidos para matrices que tienen al
menos dos dimensiones, ya que no tiene sentido esto para matrices unidimensional.

Entre las diferencias que tiene NumPy y las

listas propias que ofrece Python para
manejar los datos se encuentran que,
NumPy ocupa menos memoria en
comparación a las listas de Python, a su vez
es bastante rápido en términos de ejecución
y no se requiere mucho esfuerzo en la
programación para ejecutar las rutinas. Por
estas razones NumPy es mucho más fácil y
conveniente su uso en el desarrollo de los
algoritmos de Machine Learning.

Sabiendo todo esto, se crea dos matrices una unidimensional y otra bidimensional, esto
utilizando por supuesto NumPy.

18
Con la primera instrucción se indica al programa de Python que de ahora en adelante
np será la referencia para todo lo referente a NumPy. De esta manera, muy simple, se
declara las matrices dentro de NumPy.

NumPy contiene varias instrucciones para obtener más información sobre las matrices
que se han creado utilizando esta librería, algunas de ellas son las siguientes:

Se puede encontrar el tipo de datos de los elementos que están almacenados en una
matriz, para ello se utiliza la función “dtype”, el cual arrojará el tipo de datos junto con
el tamaño.

Del mismo modo, se puede encontrar el tamaño y la forma de la matriz con la función
“size” y “shape”, respectivamente.

Otra de las operaciones que se puede realizar con NumPy es el cambio de tamaño y
forma de las matrices.

El cambio de la forma de las matrices es

cuando se cambia el número de filas y
columnas que le da una nueva vista a un
objeto.

En la imagen se tiene 3 columnas y 2 filas que

se han convertido en 2 columnas y 3 filas
utilizando la instrucción “reshape”.

19
Otra función que se puede utilizar con NumPy es seleccionar un solo elemento de la
matriz, para ello solamente se tiene que especificar el número de columna y fila en
donde está ubicado y devolverá el valor almacenado en dicha ubicación.

Con la librería de NumPy se puede realizar de manera muy fácil operaciones

aritméticas. Se puede encontrar el valor mínimo, máximo y la suma de la matriz con
NumPy, para ello utilizamos “min”, “max” y “sum”, respectivamente.

Se puede realizar más operaciones con las matrices de NumPy, como son la suma,
resta, multiplicación y división de las dos matrices.

Se ha cubierto gran parte de las funciones que se pueden utilizar al momento de

manipular los datos con NumPy, aún faltan muchas más instrucciones, pero a medida

20
que se vaya programando seguramente se irán aprendiendo, recuerda que la página
web propia de esta librería ofrece muy buena información sobre todas las funciones
que ofrece por lo que no está demás visitarla.

Para mayor información se puede ver revisar la siguiente información:

http://bit.ly/2MSJkqu
http://bit.ly/2QiAN2v

CURSO INTENSIVO DE PANDAS

Pandas es una librería de código abierto de Python que proporciona herramientas de
análisis y manipulación de datos de alto rendimiento utilizando sus potentes
estructuras de datos. El nombre de Pandas se deriva del término “Panel Data” y es la
librería de análisis de datos de Python.

Usando esta librería se puede lograr cinco pasos típicos en el procesamiento y análisis
de datos, independientemente del origen de los datos: cargar, preparar, manipular,
modelar y analizar.

Un DataFrame es la estructura fundamental de Pandas, estos son estructuras de datos

etiquetados bidimensionales con columnas de tipos potencialmente diferentes. Los
Pandas DataFrame constan de tres componentes principales: los datos, el índice y las
columnas.

Adicionalmente con la estructura Pandas DataFrame se

puede especificar los nombres de índice y columna. El
índice indica la diferencia en las filas, mientras que los
nombres de las columnas indican la diferencia en las
columnas. Estos componentes son muy útiles cuando se
requiera manipular los datos.

Las características principales de la librería Pandas son:

® Objeto DataFrame rápido y eficiente con indexación predeterminada y

personalizada.
® Herramientas para cargar datos en objetos de datos en memoria desde diferentes
formatos de archivo.
® Alineación de datos y manejo integrado de datos faltantes.

21
 ® Remodelación y giro de conjuntos de fechas.
® Etiquetado, corte, indexación y subconjunto de grandes conjuntos de datos.
® Las columnas de una estructura de datos se pueden eliminar o insertar.
® Agrupa por datos para agregación y transformaciones.
® Alto rendimiento de fusión y unión de datos.
® Funcionalidad de la serie de tiempo.

Como cualquier otra librería en Python, se debe importarla dentro del programa, en
este caso se suele usar el alias pd, mientras que para la librería NumPy se carga como
np.

Crear los DataFrames es el primer paso en cualquier proyecto de Machine Learning

con Python, por lo que para crear una trama de datos desde una matriz NumPy se debe
pasarla a la función DataFrame() en el argumento de datos.

Si se observa el resultado de este código, se fragmenta los elementos seleccionados de

la matriz NumPy para construir el DataFrame, primero se selecciona los valores que
figuran en las listas que comienza con Fila1 y Fila2, luego selecciona el índice o los
números de fila Fila1 y Fila2 y luego los nombres de las columnas Col1 y Col2.

La manera en que se crea este DataFrame será la misma para todas las estructuras.

Una vez creado el DataFrame se puede explorarlo con todas las instrucciones con las
que Pandas cuenta. Lo primero que se debe hacer es conocer la forma de los datos para
ello se utiliza la instrucción shape. Con esta instrucción se puede conocer las
dimensiones del DataFrame, es decir el ancho y altura.

22
Por otra parte, se puede utilizar la función len() en combinación con la instrucción
index para conocer la altura del DataFrame.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2yibciB
http://bit.ly/2NFsYCa

CURSO INTENSIVO DE MATPLOTLIB

Matplotlib es una librería de trazado utilizada para gráficos 2D en lenguaje de
programación Python, es muy flexible y tiene muchos valores predeterminados
incorporados que ayudan muchísimo en el trabajo. Como tal, no se necesita mucho
para comenzar, solamente se tiene que hacer las importaciones necesarias, preparar
algunos datos y con esto se puede comenzar a trazar la función con la ayuda de la
instrucción plot().

23
Al momento de graficar se debe tener en cuenta las siguientes consideraciones:

® La figura es la ventana o página general en la que se dibuja todo, es el

componente de nivel superior de todo lo que se considerará en los siguientes
puntos. Se puede crear múltiples figuras independientes. Una figura puede tener
otras cosas como por ejemplo un subtítulo, que es un título centrado de la figura,
una leyenda, una barra de color, entre otros.
® A la figura se le agrega los ejes. Los ejes es el área en la que se grafican los datos
con funciones tales como plot() y scatter() y que pueden tener etiquetas
asociadas. Las figuras pueden contener múltiples ejes.
® Cada eje tiene un eje x y otro eje y, y cada uno de ellos contiene una numeración.
También existen las etiquetas de los ejes, el título y la leyenda que se deben tener
en cuenta cuando se quiere personalizar los ejes, pero también teniendo en
cuenta que las escalas de los ejes y las líneas de la cuadrícula pueden ser útiles.
® Las líneas vertebrales son líneas que conectan las marcas de eje y que designan
los límites del área de datos, en otras palabras, son el simple cuadrado que
puedes ver cuando has inicializado los ejes, como en la siguiente imagen:

Como se puede observar los extremos derecho y superior están configurados

como invisibles.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2CwmX99
http://bit.ly/2AuS57z

24
Capítulo 4
CARGAR LOS DATOS

El primer paso al comenzar un proyecto de Machine Learning es el de cargar los datos.

Existe muchas formas para hacer esto, pero lo primero que se debe ver es el formato
en que se encuentran estos datos, por lo general se encuentran en archivos CSV, por lo
que acá se explicará cómo cargar un archivo CSV en Python, aunque también se
mostrará como hacerlo en caso de que tengas otro formato.

En este capítulo aprenderás:

1. Cargar archivos CSV utilizando Python.

2. Cargar archivos utilizando Python.

CONSIDERACIONES DE LOS ARCHIVOS CSV

Varias son las consideraciones que se deben tomar en cuenta al momento de cargar los
datos desde un archivo CSV, a continuación, se explican algunas de ellas.

Encabezado de archivo

En ocasiones los datos cuentan con un encabezado, esto ayuda en la asignación

automática de nombres a cada columna de datos. En caso de que no se cuente con este
encabezado, se puede nombrar sus atributos de manera manual. De igual manera,
debes especificar explícitamente si el archivo a utilizar cuenta o no con un encabezado.

25
Delimitador

El delimitador que se usa de manera estándar para separar los valores en los campos
es la coma (,). El archivo a utilizar podría utilizar un delimitador diferente como un
espacio en blanco o punto y coma (;), en estos casos se debe especificar explícitamente.

CONJUNTO DE DATOS: DIABETES DE LOS INDIOS

PIMA
El conjunto de datos o dataset de los indios Pima se utilizará para demostrar la carga
de datos en este capítulo. También será utilizado en muchos de los próximos capítulos.

El objetivo de este conjunto de datos es predecir si un paciente tiene diabetes o no,

según ciertas mediciones de diagnóstico incluidas en el conjunto de datos. En
particular, todos los pacientes aquí son mujeres de al menos 21 años de la herencia
india Pima.

Los datos están disponibles gratuitamente en la página de Kaggle bajo el nombre de

“Pima Indians Diabetes Database”. Para descargar el archivo se debe estar suscrito
a Kaggle.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2wqG0g6

CARGAR ARCHIVOS CSV UTILIZANDO PYTHON

Para cargar los datos CSV se utilizará la librería de Pandas y la función
“pandas.read_csv()”. Esta función es muy flexible y es la manera más rápida y fácil
para cargar los datos en Machine Learning. La función devuelve un DataFrame de
Pandas que se puede comenzar a utilizar de manera inmediata.

En el siguiente ejemplo se asume que el archivo diabetes.csv se encuentra guardado

en el directorio de trabajo actual.

26
También se puede cargar los datos directamente desde una dirección web, para esto
solamente se tiene que incluir la dirección web dentro del paréntesis donde en estos
momentos se tiene el nombre del archivo.

CARGAR ARCHIVOS UTILIZANDO PYTHON

En caso de que los archivos de Machine Learning no se encuentren en formato CSV, la
librería Pandas ofrece la opción de cargar datos en distintos formatos. A continuación,
una lista y las instrucciones que se debe utilizar:

Descripción Comando
HTML read_html
MS EXCEL read_excel
JSON read_json
SQL read_sql

27
Capítulo 5
ENTENDIENDO LOS DATOS

Una vez cargados los datos deben ser comprendidos para obtener los mejores
resultados. En este capítulo se explicará varias formas en que se puede usar Python
para comprender mejor los datos de Machine Learning.

En este capítulo se aprenderás:

1. Verificar los datos en bruto.

2. Revisar las dimensiones del conjunto de datos.
3. Revisar los tipos de datos de las características.
4. Verificar la distribución de características entre las clases en el conjunto de
datos.
5. Verificar los datos utilizando estadísticas descriptivas.
6. Comprender las relaciones en los datos utilizando correlaciones.
7. Revisar el sesgo de las distribuciones de cada característica.

Para implementar cada uno de estos ítems se utilizará el conjunto de datos con el que
se trabajo en el anterior capítulo correspondiente a la diabetes de los indios Pima.

VERIFICAR LOS DATOS

Mirar los datos en bruto puede revelar información que no se puede obtener de otra
manera. También puede mostrar formas que luego pueden convertirse en ideas sobre
cómo procesar mejor y manejar los datos para tareas de Machine Learning.

28
Para visualizar las primeras 5 filas de los datos se utiliza la función head() de Pandas
DataFrame.

Resultado una vez ejecutado el código anterior:

DIMENSIONANDO LOS DATOS

Para trabajar en Machine Learning se debe tener un buen control sobre la cantidad de
datos que se tiene, conociendo la cantidad de filas y de columnas.

® Si se tiene demasiadas filas, algunos algoritmos pueden tardar demasiado en

entrenar. En cambio, si se tiene muy pocos, de repente no sean suficientes datos
para entrenar los algoritmos.
® Si se tiene demasiadas características, algunos algoritmos pueden distraerse o
sufrir un rendimiento deficiente debido a la dimesionalidad.

Para conocer la forma y el tamaño del conjunto de datos utilizamos la propiedad shape
de Pandas.

Resultado una vez ejecutado el código anterior:

El resultado de este código representa el número de filas y luego las columnas. Por lo
tanto, el conjunto de datos cuenta con 768 filas y 9 columnas.

29
TIPOS DE DATOS
Conocer el tipo de dato de cada característica es importante. Conociendo esta
información se puede hacer una idea si se deban convertir los datos originales en otros
formatos para que sean más fácil su implementación junto a los algoritmos de Machine
Learning.

Para conocer los tipos de datos se puede implementar la función dtypes de Pandas, de
esta forma se puede conocer el tipo de datos de cada característica que forma parte del
conjunto de datos.

Resultado una vez ejecutado el código anterior:

El resultado es una lista con cada una de las columnas del conjunto de datos, en donde
se específica el tipo de datos que se maneja.

DESCRIPCIÓN ESTADÍSTICA
La descripción estadística se refiere a la información que se puede obtener de los datos
referentes a propiedades estadísticas de cada característica. Para implementarlo
solamente se debe utilizar la función describe() de Pandas, y las propiedades que
devuelve son las siguientes:

® Conteo
® Media
® Desviación estándar
® Valor mínimo
® 25%
® 50%
® 75%
® Valor máximo

30
Resultado una vez ejecutado el código anterior:

Como se puede observar devuelve mucha información del conjunto de datos, pero lo
importante de acá es verificar si todas las cantidades de datos coinciden, de esta forma
se puede saber si hay o no datos perdidos.

DISTRIBUCIÓN DE CLASES (PROBLEMAS DE

CLASIFICACIÓN)
En caso de que se este trabajando con un problema de clasificación, como es el caso
actual, se debe conocer qué tan equilibrados están los valores de clases. Cuando los
problemas se encuentran altamente desequilibrados (muchas más observaciones para
una clase que para otra) se requieren un tratamiento especial al momento de realizar
el procesamiento de los datos. Para conocer esta información se puede implementar
una función de Pandas, groupby junto con la columna Class del conjunto de datos con
el que se esta trabajando.

Resultado una vez ejecutado el código anterior:

La clase 0 corresponde a las personas no diabéticas mientras que la clase 1

corresponden a las mujeres que tienen la enfermedad.

31
CORRELACIÓN ENTRE CARACTERÍSTICAS
La correlación se refiere a la relación entre dos variables y cómo pueden o no cambiar
juntas. Para implementar esto se debe indicar el método a utilizar, el más común es el
coeficiente de correlación de Pearson, que asume una distribución normal de los
atributos involucrados. Si la correlación se encuentra entre -1 o 1 muestra una
correlación negativa o positiva completa, respectivamente. Mientras que un valor de 0
no muestra ninguna correlación en absoluto. Para calcular una matriz de correlación
se utiliza la función corr().

Resultado una vez ejecutado el código anterior:

Algunos algoritmos de Machine Learning, como regresión lineal y logística, pueden

sufrir un rendimiento deficiente si existen atributos altamente correlacionados en el
conjunto de datos.

CONSIDERACIONES ADICIONALES
Los puntos acá tratados son solamente algunos consejos que se deben considerar al
momento de revisar los datos, adicionalmente a estos, se debe tomar en consideración
lo siguiente:

® Repasar los números. Generar la descripción estadística no es suficiente. Se debe

tomar un tiempo para leer y entender muy bien los números que se está viendo.
® Al ver los números se debe entender muy bien cómo y por qué se están viendo
estos números específicos, cómo se relacionan con el dominio del problema en
general, lo importante acá es hacerse pregunta y conocer muy bien de qué se
trata la información que nos presenta el conjunto de datos.
® Es aconsejable escribir todas las observaciones que se obtengan o ideas que
surjan al momento de analizar los datos. En ocasiones esta información será muy
importante cuando se este tratando de idear nuevas cosas para probar.

32
Capítulo 6
VISUALIZANDO LOS DATOS

Como se explico en el anterior capítulo se debe entender los datos para obtener buenos
resultados al momento de implementar los algoritmos de Machine Learning. Otra
forma de aprender de los datos es implementando la visualización de los mismos.

En este capítulo aprenderás:

1. Graficar con una sola variable

2. Graficar con múltiples variables

GRÁFICAR CON UNA SOLA VARIABLES

Las gráficas con una sola variable son útiles para comprender cada característica del
conjunto de datos de forma independiente. Acá se explicarán las siguientes:

® Histogramas
® Diagrama de cajas o Box Plot

Histograma

Una forma rápida de tener una idea de la distribución de cada atributo es observar los
histogramas. Estos son utilizados para presentar la distribución y las relaciones de una
sola variable en un conjunto de características. Los histogramas agrupan los datos en

33
contenedores y de la forma de los mismos, se puede obtener rápidamente una idea de
si un atributo es gaussiano, sesgado o inclusive tiene una distribución exponencial.
Inclusive puede ayudar a determinar si hay posibles valores atípicos.

Resultado una vez ejecutado el código anterior:

Diagramas de cajas o Box Plot

Otra forma de revisar la distribución de cada atributo es usar los diagramas de cajas.
Esto resume la distribución de cada atributo, trazando una línea para la mediana o
valor medio y un cuadro alrededor de los percentiles 25 y 75.

Resultado una vez ejecutado el código anterior:

34
 Para mayor información se puede revisar la siguiente información:

http://bit.ly/2XgTTOg

GRÁFICAR CON VARIAS VARIABLES

Esta sección proporciona ejemplo de un gráfico que muestra las interacciones entre
múltiples variables en el conjunto de datos:

® Matriz de correlación

Matriz de correlación

La correlación presenta una indicación de qué tan relacionados están los cambios entre
dos variables. La correlación positiva se refiere a cuando dos variables cambian en la
misma dirección. En cambio, la correlación es negativa cuando cambian en direcciones
opuestas, una sube y la otra baja. La matriz de correlación se refiere a la correlación
entre cada par de atributos, de esta forma se puede verificar qué variables tienen una
alta correlación.

35
Resultado una vez ejecutado el código anterior:

Si se analiza la matriz, ésta es simétrica, es decir, la parte inferior izquierda de la matriz

es la misma que la superior derecha. Esto es útil ya que podemos ver dos vistas
diferentes en los mismos datos en una gráfica.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2XgTTOg

36
Capítulo 7
PROCESAMIENTO DE LOS
DATOS

El procesamiento de los datos es un paso fundamental en cualquier problema de

Machine Learning, debido a que los algoritmos hacen suposiciones sobre los datos, por
lo que los mismos deben estar presentados de manera correcta.

En este capítulo aprenderás a cómo preparar los datos para Machine Learning en
Python utilizando scikit-learn:

1. Estandarizar los datos

2. Normalizar los datos
3. Eliminación de columnas

SEPARACIÓN DE LOS DATOS

En este capítulo se explicará varias formas para el procesamiento de datos para
Machine Learning. El conjunto de datos que se utilizará será el de la diabetes de los
indios Pima.

Antes de empezar el procesamiento de los datos es recomendable separar el conjunto

de datos con las variables de entrada y salida o, como también se le conoce, las variables
independientes y dependientes.

37
Observando el conjunto de datos con el que se ha venido trabajando, la variable de
salida o dependiente vendría siendo la columna “Outcome”, debido a que en esta se
refleja si la persona tiene diabetes o no.

Definido esto se procede a realizar la separación de los datos, creando la variable “X”
para los datos de entrada o independientes y la variable “y” para la columna
correspondiente a “Outcome”.

Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

Para el procesamiento de datos se hará solamente para el conjunto correspondiente a

la variable “X”, los datos de entrada o independientes. Los datos de la variable “y” no
se le hará ningún procedimiento.

ESTANDARIZACIÓN DE LOS DATOS

La estandarización de los datos es un requisito común para muchos estimadores de
Machine Learning, esto se debe a que los algoritmos se pueden comportar mal si las
características individuales no se parecen más o menos a los datos estándar
normalmente distribuidos.

38
Para cumplir con este procedimiento se utiliza la función StandardScaler de la librería
scikit-learn y se aplica, en este caso a todos los datos del conjunto de datos “X”.

Resultado una vez ejecutado el código anterior:

Nota: al ejecutar este código probablemente salga un error, el mensaje lo que indica
es que todos los datos del tipo entero y flotante han sido convertidos en flotante para
poder implementar la instrucción StandardScaler.

Como se puede observar al ejecutar el código genera una matriz del tipo NumPy con
los datos estandarizados, en caso de que se quieran convertir los datos en DataFrame
de Pandas se debe ejecutar las siguientes líneas de código adicionales.

Resultado una vez ejecutado el código anterior:

39
 Para mayor información se puede revisar la siguiente información:

http://bit.ly/2Hjq2f4
http://bit.ly/2H63A9R

NORMALIZACIÓN DE LOS DATOS

Normalizar los datos se refiere a cambiar la escala de los datos de la característica para
que tengan una longitud de 1. Este método de procesamiento puede ser útil para
conjuntos de datos dispersos (muchos ceros) con atributos de diferentes escalas.

Para implementar este método se utiliza la clase Normalizer de la librería scikit-learn.

Resultado una vez ejecutado el código anterior:

Igual que en el caso anterior, al ejecutar el código genera una matriz del tipo NumPy
con los datos normalizados, en caso de que se quieran convertir los datos en DataFrame
de Pandas se debe ejecutar las siguientes líneas de código adicionales.

Resultado una vez ejecutado el código anterior:

40
 Para mayor información se puede revisar la siguiente información:

http://bit.ly/2Hjq2f4
http://bit.ly/2H63A9R

ELIMINACIÓN DE COLUMNAS
Otra forma de procesar los datos es eliminando columnas con datos que no son
necesarios para el análisis. La función a utilizar para cumplir con esta forma es drop,
junto con el nombre de la columna a eliminar.

Para realizar la respectiva prueba se eliminará la columna “BloodPressure” del

conjunto de datos con el que se está trabajando.

Resultado una vez ejecutado el código anterior:

41
Para mayor información se puede revisar la siguiente información:

http://bit.ly/2Hjq2f4
http://bit.ly/2H63A9R

42
Capítulo 8
SELECCIONANDO
CARACTERÍSTICAS

Las características de datos que se utiliza para entrenar los modelos de Machine
Learning tienen una gran influencia en el rendimiento que puede lograr. Las
características irrelevantes o parcialmente relevantes pueden afectar negativamente el
rendimiento del modelo. En este capítulo, se describirán las técnicas de selección
automática de características que pueden ser utilizadas para preparar los datos.

En este capítulo aprenderás:

1. Método de filtro
2. Método de envoltura
3. Métodos integrados

IMPORTANCIA DE LAS CARACTERÍSTICAS

Los conjuntos de datos en ocasiones pueden ser pequeños mientras que otros son
extremadamente grandes en tamaño, en especial cuando cuentan con un gran número
de características, ocasionando que sean muy difícil de procesar.

Cuando se tiene este tipo de conjuntos de datos de alta dimensión y se utilizan todas
para la creación de modelos de Machine Learning puede ocasionar:

43
 ® Las características adicionales actúan como un ruido para el cual el modelo de
Machine Learning puede tener un rendimiento extremadamente bajo.
® El modelo tarda más tiempo en entrenarse.
® Asignación de recursos innecesarios para estas características.

Por todo esto, se debe implementar la selección de características en los proyectos de

Machine Learning.

MÉTODOS DE FILTRO
La siguiente imagen describe mejor los métodos de selección de características basados
en filtros:

Los métodos de filtro se utilizan generalmente como un paso de procesamiento de

datos, la selección de características es independiente de cualquier algoritmo de
Machine Learning.

Las características se clasifican según los puntajes estadísticos que tienden a

determinar la correlación de las características con la variable de resultado, la
correlación es un término muy contextual y varía de un trabajo a otro.

En la siguiente tabla se puede utilizar para definir los coeficientes de correlación para
diferentes tipos de datos, en este caso, continuo y categórico.

Correlación de Pearson: se usa como una medida para cuantificar la dependencia

lineal entre dos variables continuas X e Y, su valor varía de -1 a +1.

LDA: el análisis discriminante lineal se usa para encontrar una combinación lineal de
características que caracteriza o separa dos o más clases, o niveles, de una variable
categórica.

44
ANOVA: significa análisis de la varianza y es similar a LDA, excepto por el hecho de
que opera mediante una o más funciones independientes categóricas y una función
dependiente continua. Proporciona una prueba estadística de si las medias de varios
grupos son iguales o no.

Chi-cuadrado: es una prueba estadística que se aplica a los grupos de características

categóricas para evaluar la probabilidad de correlación o asociación entre ellos
utilizando su distribución de frecuencia.

Los métodos de filtro no eliminan la multicolinealidad, por lo tanto, se debe lidiar con
ellos también antes de entrenar modelos para tus datos.

De manera practica lo explicado anteriormente, se implementará una prueba

estadística de Chi-cuadrado para características no negativas, para seleccionar 5 de las
mejoras características del conjunto de datos con el que se ha venido trabando
correspondientes a la diabetes de los indios Pima.

La librería scikit-learn proporciona la clase SelectKBest que se puede usar con un

conjunto de diferentes pruebas estadísticas para seleccionar un número específico de
funciones, en este caso, es Chi-cuadrado.

Resultado una vez ejecutado el código anterior:

El resultado obtenido en esta parte del programa es el puntaje que tiene cada una de
las características una vez aplicado el método Chi-cuadrado. De acuerdo a esto ya se
puede definir las más importantes características que pueden afectar el análisis con
Machine Learning.

Resultado una vez ejecutado el código anterior:

45
Resumiendo, los resultados obtenidos, se puede observar las 5 características elegidas,
tomadas con los puntajes más altos: “Pregnancies” (embarazos), “Glucose” (glucosa),
“Insulin” (insulina), “BMI” (índice de masa corporal), “Age” (años).

Estos puntajes ayudan a determinar las mejores características para entrenar el

modelo.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2C0BojO

MÉTODOS DE ENVOLTURA
Al igual que los métodos de filtro, se muestra una gráfica en donde se explica mejor
este método:

Como se puede observar, un método de envoltura necesita un algoritmo de Machine

Learning y utiliza su rendimiento como criterio de evaluación. Este método busca una
característica que sea más adecuada para el algoritmo y tiene como objetivo mejorar el
rendimiento.

Por lo tanto, se trata de usar un subconjunto de características y se entrena un modelo

usándolo, basándose en las inferencias que se extrae del modelo anterior, se decide
agregar o eliminar características de su subconjunto. El problema se reduce
esencialmente a un problema de búsqueda. Estos métodos suelen ser
computacionalmente muy caros.

Algunos ejemplos comunes de Métodos de Envoltura son los siguientes:

46
Selección hacia delante (Forward Selection): es un método iterativo en el que
se comienza sin tener ninguna característica en el modelo. En cada iteración, se sigue
agregando la función que mejor mejora nuestro modelo hasta que la adición de una
nueva variable no mejore el rendimiento del modelo.

Eliminación hacia atrás (Backward Selection): se comienza con todas las

características y se elimina la característica menos significativa en cada iteración, lo
que mejora el rendimiento del modelo. Se repite esto hasta que no se observe ninguna
mejora en la eliminación de características.

Eliminación de características recursivas (Recursive Feature

Elimination): es un algoritmo de optimización que busca encontrar el subconjunto
de funciones con mejor rendimiento. Crea repetidamente modelos y deja de lado la
mejor o la peor característica de rendimiento en cada iteración. Construye el siguiente
modelo con las características de la izquierda hasta que se agotan todas las
características, luego clasifica las características según el orden de su eliminación.

Aplicando esta teoría al conjunto de datos que se ha trabajado hasta los momentos, se
aplicará el método de la eliminación de características recursivas junto con el algoritmo
de regresión logística.

Resultado una vez ejecutado el código anterior:

Para este método se eligió las 4 funciones principales y el resultado fue el siguiente:
“Pregnancies” (embarazos), “Glucose” (glucosa), “BMI” (índice de masa corporal) y
“DiabetesPedigreeFunction” (función pedigrí de la diabetes).

Como se puede observar estos datos se encuentran marcadas como Verdaderos (True)
en la matriz de características seleccionadas y como 1 en la matriz de clasificación de
características.

47
 Para mayor información se puede revisar la siguiente información:

http://bit.ly/2C0BojO

MÉTODOS INTEGRADOS
Combina las cualidades de los métodos de filtro y envoltura. Se implementa mediante
algoritmos que tienes sus propios métodos de selección de características
incorporados.

Algunos de los ejemplos más populares de estos métodos son la regresión LASSO y
RIDGE, que tienen funciones de penalización incorporadas para reducir el sobreajuste.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2C0BojO

48
Capítulo 9
ALGORITMOS DE
CLASIFICACIÓN

Al desarrollar un proyecto de Machine Learning no se puede saber de antemano qué

algoritmos son los más adecuados para el problema, se debe probar varios métodos y
centrar la atención en aquellos que demuestran ser los más prometedores. En este
capítulo, se explicará cómo implementar los algoritmos de Machine Learning que
puede utilizarse para resolver problemas de clasificación en Python con scikit-learn.

En este capítulo aprenderás cómo implementar los siguientes algoritmos:

1. Regresión logística
2. K Vecinos más cercanos
3. Máquinas de vectores de soporte
4. Naive bayes
5. Árboles de decisión clasificación
6. Bosques aleatorios clasificación

Para este análisis se tomará el conjunto de datos de diabetes de los indios Pima. De
igual forma, se asume que se conoce la parte teórica de cada algoritmo de Machine
Learning y cómo usarlos, no se explicará la base ni la parametrización de cada
algoritmo.

49
REGRESIÓN LOGÍSTICA
La Regresión Logística es un método estadístico para predecir clases binarias. El
resultado o variable objetivo es de naturaleza dicotómica. Dicotómica significa que solo
hay dos clases posibles. Por ejemplo, se puede utilizar para problemas de detección de
cáncer o calcular la probabilidad de que ocurra un evento.

La Regresión Logística es uno de los algoritmos de Machine Learning más simples y

más utilizados para la clasificación de dos clases. Es fácil de implementar y se puede
usar como línea de base para cualquier problema de clasificación binaria. La Regresión
Logística describe y estima la relación entre una variable binaria dependiente y las
variables independientes.

Resultado una vez ejecutado el código anterior:

Para implementar este algoritmo solamente se debe definirlo, realizar su respectivo

entrenamiento junto a los datos de entrenamiento y se realiza una predicción.

50
 Para mayor información se puede revisar la siguiente información:

http://bit.ly/2LotXZX

K - VECINOS MÁS CERCANOS

K vecinos más cercanos es un algoritmo de aprendizaje no paramétrico, esto significa
que no hace suposiciones para la distribución de datos subyacentes. En otras palabras,
la estructura del modelo es determinada a partir del conjunto de datos. Esto es muy
útil en la práctica donde la mayoría de los conjuntos de datos del mundo real no siguen
suposiciones teóricas matemáticas.

El algoritmo necesita todos los datos de entrenamiento y son utilizados en la fase de

prueba. Esto hace que la capacitación sea más rápida y la fase de prueba más lenta y
costosa. Lo costoso se refiere a que se requiere tiempo y memoria. En el peor de los
casos, K vecinos más cercanos necesita más tiempo para escanear todos los puntos de
datos y escanear todos los puntos de datos requerirá más memoria para almacenar
datos de entrenamiento.

Resultado una vez ejecutado el código anterior:

51
Como se puede observar acá simplemente se debe definir el algoritmo, entrenar el
modelo con los datos de entrenamiento y realizar una predicción.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2SswHqL
http://bit.ly/2JTXZDR

MÁQUINAS DE VECTORES DE SOPORTE

Las máquinas de vectores de soporte buscan la línea que mejor separa dos clases. Las
características de datos que están más cerca de la línea que mejor separa las clases se
denominan vectores de soporte e influyen en la ubicación de la línea. De particular
importancia es el uso de diferentes funciones del kernel a través del parámetro del
kernel.

Resultado una vez ejecutado el código anterior:

52
Para este algoritmo, de igual forma, se debe definir el modelo, entrenarlo y realizar una
predicción.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2P0F8LY
http://bit.ly/2Ufeaz9

BAYESIANO INGENUO (NAIVE BAYES)

Naive Bayes es una técnica de clasificación estadística basada en el teorema de Bayes.
Es uno de los algoritmos de Machine Learning más simple. Es un algoritmo rápido,
preciso y fiable, inclusive tiene una alta precisión y velocidad en grandes conjuntos de
datos.

Resultado una vez ejecutado el código anterior:

53
Igual que los casos anteriores, para este algoritmo se define el algoritmo a
implementar, seguidamente se entrena utilizando los datos de entrenamiento y
finalmente se realiza una predicción, bien sea con los datos de prueba o con nueva data.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2kpp6ws
http://bit.ly/2lAagUr

ÁRBOLES DE DECISIÓN CLASIFICACIÓN

Árbol de decisión es un tipo de algoritmo de aprendizaje supervisado que se utiliza
principalmente en problemas de clasificación, aunque funciona para variables de
entrada y salida categóricas como continuas.

En esta técnica, se divide la data en dos o más conjuntos homogéneos basados en el

diferenciador más significativos en las variables de entrada. El árbol de decisión
identifica la variable más significativa y su valor que proporciona los mejores conjuntos
homogéneos de población. Todas las variables de entrada y todos los puntos de división
posibles se evalúan y se elige la que tenga mejor resultado.

Los algoritmos de aprendizaje basados en árbol se consideran uno de los mejores y más
utilizados métodos de aprendizaje supervisado. Los métodos basados en árboles
potencian modelos predictivos con alta precisión, estabilidad y facilidad de
interpretación. A diferencia de los modelos lineales, mapean bastante bien las
relaciones no lineales.

54
Resultado una vez ejecutado el código anterior:

Para implementar este algoritmo solamente se debe definirlo, realizar su respectivo

entrenamiento junto a los datos de entrenamiento y realizamos una predicción.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/35McqTm
http://bit.ly/2p3vSuo

BOSQUES ALEATORIOS CLASIFICACIÓN

Bosques aleatorios clasificación es un método versátil de Machine Learning. Lleva a
cabo métodos de reducción dimensional, trata valores perdidos, valores atípicos y otros
pasos esenciales de exploración de datos, y hace un trabajo bastante bueno. Es un tipo
de método de aprendizaje por conjuntos, donde un grupo de modelos débiles se
combinan para formar un modelo poderoso.

55
En los boques aleatorios se cultivan varios árboles en lugar de un solo árbol. Para
clasificar un nuevo objeto basado en atributos, cada árbol da una clasificación y se dice
que el árbol “vota” por esa clase. El bosque elige la clasificación con más votos, sobre
todos los árboles en el bosque.

Resultado una vez ejecutado el código anterior:

Este algoritmo no es distinto a los anteriores, acá se define el algoritmo, se entrena el

modelo y se realiza la predicción respectiva.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/37bxAuD
http://bit.ly/2smgZ7F

Todos los algoritmos se pueden configurar definiendo ciertos parámetros para

mejorar el rendimiento del modelo. Todos estos parámetros se encuentran definidos
en la librería scikit-learn.

56
Capítulo 10
MÉTRICAS DE RENDIMIENTO
ALGORITMOS DE
CLASIFICACIÓN

Para los problemas de clasificación de Machine Learning se cuentan con una gran
cantidad de métricas que se pueden usar para evaluar las predicciones de estos
problemas. En esta sección se explicará cómo implementar varias de estas métricas.

En este capítulo aprenderás:

1. Matriz de confusión
2. Reporte de clasificación
3. Área bajo la curva

MATRIZ DE CONFUSIÓN
La matriz de confusión es una de las métricas más intuitivas y sencillas que se utiliza
para encontrar la precisión y exactitud del modelo. Se utiliza para el problema de
clasificación donde la salida puede ser de dos o más tipos de clases.

Identificado el problema la matriz de confusión, es una tabla con dos dimensiones,

“actual” y “predicción” y conjuntos de clases en ambas dimensiones. Las filas de la
matriz indican la clase observada o real y las columnas indican las clases predicha.

57
Se debe aclarar que la matriz de confusión en sí misma no es una medida de
rendimiento como tal, pero casi todas las métricas de rendimiento se basan en ella y en
los números que contiene.

A continuación, se muestra un ejemplo del cálculo de una matriz de confusión para el

conjunto de datos correspondiente a la diabetes de los indios Pima utilizando como
algoritmo Regresión Logística.

Resultado una vez ejecutado el código anterior:

La matriz de confusión nos arroja como resultado que la mayoría de las predicciones
caen en la línea diagonal principal de la matriz, siendo estas predicciones correctas.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2LQkSet

REPORTE DE CLASIFICACIÓN
La librería scikit-learn proporciona un informe muy conveniente cuando se trabaja en
problemas de clasificación, este da una idea rápida de la precisión de un modelo
utilizando una serie de medidas. La función classification_report() muestra la
precisión, la sensibilidad, la puntuación F1 y el soporte para cada clase.

En el siguiente ejemplo se muestra la implementación de la función en un problema.

58
Resultado una vez ejecutado el código anterior:

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2MfsS8J
http://bit.ly/2ETCL60

ÁREA BAJO LA CURVA

Cuando se trata de un problema de clasificación, se puede contar con una curva AUC-
ROC, para medir el rendimiento. Esta es una de las métricas de evaluación más
importante para verificar el rendimiento de cualquier modelo de clasificación. ROC
viene de las características de funcionamiento del receptor y AUC del área bajo la curva.

59
Resultado una vez ejecutado el código anterior:

El valor obtenido es relativamente cercano a 1 y mayor a 0.5, lo que sugiere que gran
parte de las predicciones realizadas han sido correctas.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2MfsS8J
http://bit.ly/2ETCL60

60
Capítulo 11
ALGORITMOS DE REGRESIÓN

La comprobación de puntos es una forma de descubrir qué algoritmos funcionan bien

en los problemas de Machine Learning. Es difícil saber con anterioridad qué algoritmo
es el más adecuado a utilizar, por lo que se debe comprobar varios métodos y centrar
la atención en aquellos que demuestran ser los más prometedores. En este capítulo se
explicará cómo implementar los algoritmos de regresión utilizando Python y scikit-
learn a los problemas de regresión.

En este capítulo aprenderás cómo implementar los siguientes algoritmos:

1. Regresión lineal
2. Regresión polinomeal
3. Vectores de soporte regresión
4. Árboles de decisión regresión
5. Bosques aleatorios regresión

Para este análisis se tomará el conjunto de datos de publicidad que puedes encontrar
en la página de Kaggle como “Advertising Data”. De igual forma, se asume que se
conoce la parte teórica de cada algoritmo de Machine Learning y cómo usarlos, no se
explicará la base ni la parametrización de cada algoritmo.

REGRESIÓN LINEAL
La regresión lineal es una técnica paramétrica utilizada para predecir variables
continuas, dependientes, dado un conjunto de variables independientes. Es de

61
naturaleza paramétrica porque hace ciertas suposiciones basadas en el conjunto de
datos. Si el conjunto de datos sigue esas suposiciones, la regresión arroja resultados
increíbles, de lo contrario, tiene dificultades para proporcionar una precisión
convincente.

Resultado una vez ejecutado el código anterior:

Como se puede observar acá simplemente se debe definir el algoritmo, entrenar el

modelo con los datos de entrenamiento y realizar una predicción.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2RpwDGK
http://bit.ly/2Su2aHM

REGRESIÓN POLINOMEAL
La regresión polinomial es un caso especial de la regresión lineal, extiende el modelo
lineal al agregar predictores adicionales, obtenidos al elevar cada uno de los predictores
originales a una potencia. El método estándar para extender la regresión lineal a una

62
relación no lineal entre las variables dependientes e independientes, ha sido
reemplazar el modelo lineal con una función polinomial.

Resultado una vez ejecutado el código anterior:

Para este algoritmo se debe realizar un paso adicional, antes de definir el modelo,
primeramente, se debe definir el grado del polinomio y transformar los datos
correspondientes a X. Realizado todo esto ahora si se puede definir el modelo,
entrenarlos y finalmente realizar una predicción.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2H889RX

VECTORES DE SOPORTE REGRESIÓN

Los vectores de soporte regresión utiliza los mismos principios que los de clasificación,
con solo algunas diferencias menores. En primer lugar, dado que la salida es un número

63
real, se vuelve muy difícil predecir la información disponible, que tiene infinitas
posibilidades, sin embargo, la idea principal es siempre la misma: minimizar el error,
individualizar el hiperplano que maximiza el margen, teniendo en cuenta que se tolera
parte del error.

Resultado una vez ejecutado el código anterior:

Para este algoritmo, de igual forma, se debe definir el modelo, entrenarlo y realizar una
predicción. Para este conjunto de datos se realiza, previamente, un escalamiento en los
datos ya que el modelo no era del todo efectivo con los datos originales.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2CY3xbH
http://bit.ly/2TEDkG2

64
ÁRBOLES DE DECISIÓN REGRESIÓN
Los árboles de decisión son una técnica de aprendizaje supervisado que predice valores
de respuestas mediante el aprendizaje de reglas de decisión derivadas de
características.

Los árboles de decisión funcionan al dividir el espacio de la característica en varias

regiones rectangulares simples, divididas por divisiones paralelas de ejes. Para obtener
una predicción para una observación particular, se utiliza la media o el modo de las
respuestas de las observaciones de entrenamiento, dentro de la partición a la que
pertenece la nueva observación.

Resultado una vez ejecutado el código anterior:

Igual que los casos anteriores, para este algoritmo se define el algoritmo a
implementar, seguidamente se entrena utilizando los datos de entrenamiento y
finalmente se realiza una predicción, bien sea con los datos de prueba o con nueva data.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2tHfP3U
http://bit.ly/2tStiGi

65
BOSQUES ALEATORIOS REGRESIÓN
Los bosques aleatorios es un algoritmo de aprendizaje supervisado que, como ya se
puede ver en su nombre, crea un bosque y lo hace de alguna manera aleatorio. Para
decirlo en palabras simples: el bosque aleatorio crea múltiples árboles de decisión y los
combina para obtener una predicción más precisa y estable. En general, mientras más
árboles en el bosque se vea, más robusto es el bosque.

En este algoritmo se agrega aleatoriedad adicional al modelo, mientras crece los

árboles, en lugar de buscar la característica más importante al dividir un nodo, busca
la mejor característica entre un subconjunto aleatorio de características. Esto da como
resultado una amplia diversidad que generalmente resulta en un mejor modelo.

Resultado una vez ejecutado el código anterior:

Este algoritmo no es distinto a los anteriores, acá se define el algoritmo, se entrena el

modelo y se realiza la predicción respectiva.

66
 Para mayor información se puede revisar la siguiente información:

http://bit.ly/2FTuYoA
http://bit.ly/2PhGwpT

Recuerda que este algoritmo, al igual que los anteriores, se puede configurar
definiendo ciertos parámetros para mejorar el rendimiento del modelo. Todos estos
parámetros se encuentran definidos en la librería scikit-learn.

67
Capítulo 12
MÉTRICAS DE RENDIMIENTO
ALGORITMOS DE REGRESIÓN

En este capítulo se revisará las métricas más comunes para evaluar las predicciones
sobre problemas de Machine Learning de regresión.

En este capítulo aprenderás:

1. Error cuadrático medio

2. Error absoluto medio
3. 𝑅 "

ERROR CUADRÁTICO MEDIO (RMSE)

La métrica más comúnmente utilizada para las tareas de regresión es el error
cuadrático medio y representa a la raíz cuadrada de la distancia cuadrada promedio
entre el valor real y el valor pronosticado.

Indica el ajuste absoluto del modelo a los datos, cuán cerca están los puntos de datos
observados de los valores predichos del modelo. El error cuadrático medio o RMSE es
una medida absoluta de ajuste.

68
Resultado una vez ejecutado el código anterior:

El mejor valor para este parámetro es de 0.0.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2TzzKNY

ERROR ABSOLUTO MEDIO (MAE)

El error absoluto medio es el promedio de la diferencia absoluta entre los valores
predichos y el valor observado. Es un puntaje lineal, lo que significa que todas las
diferencias individuales se ponderan por igual en el promedio.

Resultado una vez ejecutado el código anterior:

69
Para este parámetro un valor de 0.0 indica que no hay error, es decir las predicciones
son perfectas.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2TzzKNY

𝑹𝟐

𝑅 " indica la bondad o la aptitud del modelo, a menudo se utiliza con fines descriptivos
y muestra que también las variables independientes seleccionadas explican la
variabilidad en sus variables dependiente.

Resultado una vez ejecutado el código anterior:

La mejor puntuación posible es 1.0 y puede ser negativa, porque el modelo puede ser
arbitrariamente peor. Un modelo constante que siempre predice el valor esperado de
“y”, sin tener en cuenta las características de entrada, obtendrá una puntuación de 0.0.

Para mayor información se puede revisar la siguiente información:

http://bit.ly/2TzzKNY

70
Capítulo 13
PROYECTO DE MACHINE
LEARNING - CLASIFICACIÓN

En este capítulo se desarrollará un proyecto de clasificación utilizando Python, se

incluye cada paso del proceso de Machine Learning aplicado al problema.

En este capítulo aprenderás:

1. Cómo trabajar a través de un problema de clasificación

2. Cómo utilizar transformaciones de datos para mejorar el rendimiento del
modelo
3. Cómo implementar algoritmos de Machine Learning y comparar sus resultados

DEFINICIÓN DEL PROBLEMA

Para el proyecto se utilizará el mismo conjunto de datos que se ha venido trabajando
durante cada uno de los capítulos, pero esta vez se desarrollará de manera completa.
El conjunto de datos es el correspondiente a los indios Pima.

Este conjunto describe los registros médicos de los indios Pima y si cada paciente
tendrá un inicio de diabetes dentro de los cinco años. Como tal es un problema de
clasificación.

71
El conjunto de datos se puede encontrar en la página de Kaggle como “Pima Indians
Diabetes Database”.

IMPORTAR LAS LIBRERÍAS

El primer paso en cualquier proyecto de Machine Learning es el de importar las
librerías a utilizar. Es normal que al principio no se conozca todas las librerías a utilizar
y que se vayan agregando poco a poco, pero por lo menos se debe comenzar con las
básicas que normalmente se utilizan al implementar cualquier proyecto de Machine
Learning.

Importar las librerías se puede realizar a medida que se vaya programando, lo que
recomiendo es que se coloquen todas estas líneas de códigos al principio del programa
para que sea fácil conocer los módulos que se están utilizando dentro del programa,
así como también mantener un orden en la programación.

Por los momentos se importarán las librerías de Pandas, NumPy y matplotlib.

CARGAR EL CONJUNTO DE DATOS

Una vez que se hayan importado las librerías ya se pueden utilizar dentro del programa,
para esto se procede a cargar el conjunto de datos.

El conjunto de datos se debe descargar directamente de la página de Kaggle y guardarlo

en el computador en una carpeta específica en donde estará el archivo del conjunto de
datos junto con el archivo del programa de Python que se está desarrollando, de esta
forma se hará más fácil la programación.

Recuerda que para descargar los archivos de Kaggle deberás estar suscrito en la
página, esto es completamente gratis y tendrás a tu disposición un gran número de
conjuntos de datos con los que podrás practicar más adelante.

Se debe colocar el nombre exacto del archivo en donde se encuentra el conjunto de

datos. Se recomienda guardar los datos en la misma carpeta en donde se encuentra
el archivo del programa de esta forma se mantiene un orden.

72
ENTENDIENDO LOS DATOS
El siguiente paso en el desarrollo de un proyecto de Machine Learning es el de entender
los datos con lo se cuenta. Para este paso se utilizan varias funciones que se tiene
disponible en la librería de Pandas.

Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

73
Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

74
El conjunto de datos cuentas con 9 columnas, de las cuales 8 son las variables
independientes y la última columna corresponde a la variable dependiente.
Adicionalmente todos los datos son numéricos, entre enteros y flotantes.

Adicionalmente, los datos se encuentran balanceados por lo que no es necesario

realizar ningún paso adicional.

VISUALIZANDO LOS DATOS

Una vez que se haya entendido los datos de manera numérica ahora se analizará de
manera visual utilizando la librería matplotlib. Esta librería fue importada al inicio del
programa por lo que no es necesario hacerlo nuevamente.

Resultado una vez ejecutado el código anterior:

75
Resultado una vez ejecutado el código anterior:

76
Resultado una vez ejecutado el código anterior:

Como podemos observar en las gráficas obtenidas los resultados son muy similares a
los obtenidos en el punto anterior.

77
SEPARACIÓN DE LOS DATOS
Conociendo el conjunto de datos que se está trabajando dentro del proyecto, se procede
a realizar la separación de los datos en dos conjuntos, el primero de variables
independientes, X, y un segundo conjunto de variable dependientes, y.

Se comienza separando los datos correspondientes a las variables independientes, que

vendrían siendo todas las columnas menos la última.

Resultado una vez ejecutado el código anterior:

Seguidamente se define los variables correspondientes a y, o variable dependiente, que

vendría siendo la última columna del conjunto de datos.

Resultado una vez ejecutado el código anterior:

78
SELECCIONANDO CARACTERÍSTICAS
Como se observo la variable X cuenta con 8 columnas, para este caso se aplicará el
procedimiento para seleccionar las 5 características que tengan mayor influencia en la
variable dependiente. Para este ejemplo se utilizará el método de filtro.

Para implementar las funciones respectivas se deben importar las librerías

correspondientes. Se recomienda colocar estas líneas de código al principio del
programa junto al resto de librerías con la que se esta trabajando. Esto hace que el
programa sea mucho más limpio y fácil de entender para otras personas.

Realizado esto ya se puede implementar el código respectivo.

Resultado una vez ejecutado el código anterior:

Las 5 características que tienen mayor impacto para la variable dependiente son las
siguientes:

Columna 0 – pregnancies
Columna 1 – glucose
Columna 4 – insulin
Columna 5 – bmi
Columna 7 – age

Por lo tanto, se convierte ahora las variables X con solo estas 5 columnas.

79
Resultado una vez ejecutado el código anterior:

PROCESAMIENTO DE LOS DATOS

Definido los valores de X que se utilizaran en los algoritmos, ahora se procede a realizar
el respectivo procesamiento de los datos.

Para este caso solamente se estandarizarán los datos, ya que los mismos se encuentran
en distintas escalas y esto puede ocasionar errores en el análisis.

Antes de aplicar la función se debe importar la respectiva librería. Recuerda colocar

esta línea de código al principio del programa.

Ahora se realiza la estandarización de los datos, es importante mencionar que este

procedimiento solamente se realiza a los datos correspondientes a X solamente.

Resultado una vez ejecutado el código anterior:

SEPARACIÓN DE LOS DATOS

Se llega al último paso antes de implementar los algoritmos de Machine Learning, este
es el correspondiente al de separar los datos en entrenamiento y prueba, para esto se
utiliza la función train_test_split de la librería scikit-learn, recuerda que se debe
importar antes de usarla.

80
Se utilizará solamente un 25% del conjunto de datos como datos de prueba, por lo que
se coloca en el tamaño de la prueba 0.25.

APLICACIÓN DE LOS ALGORITMOS DE

CLASIFICACIÓN
Se implementarán los algoritmos explicados con anterioridad y se evaluará los
resultados con respecto al error de cada uno de ellos.

Regresión Logística

El primer algoritmo a evaluar es el más básico de todos y es el de Regresión Logística.

Resultado una vez ejecutado el código anterior:

Los anteriores datos es la representación de los datos de pruebas, originales, con los
datos obtenidos por el modelo. A continuación, se realiza el análisis respectivo con las
métricas correspondientes a los algoritmos de clasificación.

81
La primera métrica a evaluar será la de la matriz de confusión, para ello primero se
importará la librería y posteriormente la función.

Resultado una vez ejecutado el código anterior:

Los resultados obtenidos acá son bastante satisfactorios, ya que el modelo pudo
obtener unos buenos resultados.

Ahora se evalúa los resultados, pero esta vez utilizando el reporte de clasificación
disponible en la librería scikit-learn.

Resultado una vez ejecutado el código anterior:

En este reporte se puede evidenciar que el porcentaje de precisión, sensibilidad y

puntaje F1 del modelo rondan alrededor de 0.8, número que es muy bueno.

K Vecinos más Cercanos

El siguiente algoritmo a evaluar será el de K vecinos más cercanos, acá se realizará el

mismo procedimiento que se realizó anteriormente.

82
Resultado una vez ejecutado el código anterior:

Realizado todo este procedimiento se continúa evaluando el modelo, para ello se aplica
las dos métricas que se utilizo con el anterior, primeramente, la matriz de confusión.

Resultado una vez ejecutado el código anterior:

Y posteriormente se obtiene el reporte de clasificación.

Resultado una vez ejecutado el código anterior:

83
Como se puede observar los resultados obtenidos acá son un poco mejores que los
obtenidos con el anterior algoritmo.

Máquinas de Vectores de Soporte

Ahora se evaluará el algoritmo de máquinas de vectores de soporte, el procedimiento

es muy similar a los otros algoritmos evaluados anteriormente.

Resultado una vez ejecutado el código anterior:

Igual que en los casos anteriores, se evalúa el modelo obtenido por medio de la matriz
de confusión y el reporte de clasificación.

Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

84
Naive Bayes

El siguiente algoritmo a evaluar será el de naive bayes o como se le conoce en español,

el bayesiano ingenuo.

Resultado una vez ejecutado el código anterior:

Definido el modelo, se verifica el error del mismo, para ello se utiliza la función de la
matriz de confusión y el reporte de clasificación.

Resultado una vez ejecutado el código anterior:

85
Resultado una vez ejecutado el código anterior:

Árboles de Decisión Clasificación

Para evaluar el problema implementando el algoritmo de árboles de decisión

clasificación se realiza el siguiente procedimiento.

Resultado una vez ejecutado el código anterior:

Se evalúa el error implementando la matriz de confusión y obteniendo el reporte de

clasificación.

Resultado una vez ejecutado el código anterior:

86
Resultado una vez ejecutado el código anterior:

Bosques Aleatorios Clasificación

Finalmente, se evalúa el último algoritmo explicado, bosques aleatorios clasificación.

Resultado una vez ejecutado el código anterior:

Se implementa, a continuación, las funciones para evaluar el algoritmo, igual que

anteriormente se utiliza la matriz de confusión y el reporte de clasificación.

Resultado una vez ejecutado el código anterior:

87
Resultado una vez ejecutado el código anterior:

Como se puede observar, los algoritmos evaluados obtuvieron unos resultados muy
parecidos unos con otros.

En estos casos se selecciona el algoritmo que sea mucho más rápido y fácil de
implementar, que sería Regresión Logística.

No todos los casos son así, en ocasiones cuando se está trabajando con un problema de
clasificación, los resultados, después de implementar varios algoritmos, son distintos
entre ellos, por lo que acá se selecciona el algoritmo con el que se obtengan los mejores
resultados.

88
Capítulo 14
PROYECTO DE MACHINE
LEARNING - REGRESIÓN

En este capítulo se desarrollará un proyecto de regresión utilizando Python, se incluye

cada paso del proceso de Machine Learning aplicado al problema.

En este capítulo aprenderás:

1. Cómo trabajar a través de un problema de regresión

2. Cómo utilizar transformaciones de datos para mejorar el rendimiento del
modelo
3. Cómo implementar algoritmos de Machine Learning y comparar sus resultados

DEFINICIÓN DEL PROBLEMA

Para el proyecto se utilizará el mismo conjunto de datos que se utilizó para explicar los
algoritmos de regresión, pero esta vez se desarrollará de manera completa. El conjunto
de datos es el correspondiente a los anuncios de publicidad.

El conjunto de datos se puede encontrar en la página de Kaggle como “Advertising

Data”.

89
IMPORTAR LAS LIBRERÍAS
El primer paso en cualquier proyecto de Machine Learning es el de importar las
librerías a utilizar. Es normal que al principio no se conozca todas las librerías a utilizar
y que se vayan agregando poco a poco, pero por lo menos se debe comenzar con las
básicas que normalmente se utilizan al implementar cualquier proyecto de Machine
Learning.

Importar las librerías se puede realizar a medida que se vaya programando, lo que
recomiendo es que se coloquen todas estas líneas de códigos al principio del programa
para que sea fácil conocer los módulos que se están utilizando dentro del programa,
así como también mantener un orden en la programación.

Por los momentos se importarán las librerías de Pandas y matplotlib.

CARGAR EL CONJUNTO DE DATOS

Una vez que se hayan importado las librerías ya se pueden utilizar dentro del programa,
para esto se procede a cargar el conjunto de datos.

El conjunto de datos se debe descargar directamente de la página de Kaggle y guardarlo

en el computador en una carpeta específica en donde estará el archivo del conjunto de
datos junto con el archivo del programa de Python que se está desarrollando, de esta
forma se hará más fácil la programación.

Recuerda que para descargar los archivos de Kaggle deberás estar suscrito en la
página, esto es completamente gratis y tendrás a tu disposición un gran número de
conjuntos de datos con los que podrás practicar más adelante.

Se debe colocar el nombre exacto del archivo en donde se encuentra el conjunto de

datos. Se recomienda guardar los datos en la misma carpeta en donde se encuentra
el archivo del programa de esta forma se mantiene un orden.

90
ENTENDIENDO LOS DATOS
El siguiente paso en el desarrollo de un proyecto de Machine Learning es el de entender
los datos con lo se cuenta. Para este paso se utilizan varias funciones que se tiene
disponible en la librería scikit-learn.

Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

91
Resultado una vez ejecutado el código anterior:

El conjunto de datos cuentas con 5 columnas, de las cuales 4 son las variables
independientes y la última columna corresponde a la variable dependiente.

Detallando los datos se puede observar que la primera columna es de numeración por
lo que se puede descartar cuando se haga la separación de los datos.

Se puede observar que todo el código de programación utilizado hasta acá es

exactamente igual al del problema de clasificación desarrollado en el anterior
capítulo.

VISUALIZANDO LOS DATOS

Una vez que se haya entendido los datos de manera numérica ahora se analizará de
manera visual utilizando la librería matplotlib. Esta librería fue importada al inicio del
programa por lo que no es necesario hacerlo nuevamente.

Resultado una vez ejecutado el código anterior:

92
Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

93
Como podemos observar en las gráficas obtenidas los resultados son muy similares a
los obtenidos en el punto anterior.

Se puede observar que todo el código de programación utilizado hasta acá es

exactamente igual al del problema de clasificación desarrollado en el anterior
capítulo.

SEPARACIÓN DE LOS DATOS

Conociendo el conjunto de datos que se está trabajando dentro del proyecto, se procede
a realizar la separación de los datos en dos conjuntos, el primero de variables
independientes, X, y un segundo conjunto de variable dependientes, y.

Se comienza separando los datos correspondientes a las variables independientes, que

vendrían siendo todas las columnas menos la primera y la última.

La primera columna se elimina porque contiene la numeración de los filas,

información que no influye para el análisis de Machine Learning.

Resultado una vez ejecutado el código anterior:

94
Seguidamente se define los variables correspondientes a y, o variable dependiente, que
vendría siendo la última columna del conjunto de datos.

Resultado una vez ejecutado el código anterior:

Para este problema no es necesario la selección de características ya que cuenta con

muy pocas, por lo que este paso se va a obviar.

De igual forma los datos se encuentran adecuados para ser utilizados dentro de los
algoritmos de Machine Learning, por lo que no es necesario realizar un
procesamiento a los mismos.

SEPARACIÓN DE LOS DATOS

Se llega al último paso antes de implementar los algoritmos de Machine Learning, este
es el correspondiente al de separar los datos en entrenamiento y prueba, para esto se
utiliza la función train_test_split de la librería scikit-learn, recuerda que se debe
importar antes de usarla.

Se utilizará solamente un 25% del conjunto de datos como datos de prueba, por lo que
se coloca en el tamaño de la prueba 0.25.

95
APLICACIÓN DE LOS ALGORITMOS DE REGRESIÓN
Se implementarán los algoritmos explicados con anterioridad y se evaluará los resultados con
respecto al error de cada uno de ellos.

Regresión Lineal

El primer algoritmo a evaluar es el más básico de todos y es el de Regresión Lineal.

Resultado una vez ejecutado el código anterior:

Los anteriores datos es la representación de los datos de pruebas, originales, con los
datos obtenidos por el modelo. A continuación, se realiza el análisis respectivo con las
métricas correspondientes a los algoritmos de regresión.

La primera métrica a evaluar será el error cuadrático medio, para ello primero se
importará la librería y posteriormente la función.

Resultado una vez ejecutado el código anterior:

96
Los resultados obtenidos acá son bastante satisfactorios, recuerdo que si el valor está
más cercano a 0 quiere indicar que el modelo es bueno.

Ahora se evalúa los resultados, pero esta vez utilizando la métrica 𝑅" , importando
primero la función en scikit-learn para luego implementarla.

Resultado una vez ejecutado el código anterior:

Esta métrica, a diferencia a la anterior, entre más cerca este el resultado a 1 es un muy
buen modelo, por lo que el resultado obtenido indica que el modelo desarrollado es
bueno.

Regresión Polinomial

El siguiente algoritmo a evaluar será el de regresión polinomial, acá se realizará el

mismo procedimiento que se realizó anteriormente.

Resultado una vez ejecutado el código anterior:

97
Realizado todo este procedimiento se continúa evaluando el modelo, para ello se aplica
las dos métricas que se utilizo con el anterior, primeramente, el error cuadrático medio.

Resultado una vez ejecutado el código anterior:

Y posteriormente se obtiene la métrica 𝑅" .

Resultado una vez ejecutado el código anterior:

Como se puede observar los resultados obtenidos acá son muy parecidos al anterior
modelo.

Vectores de Soporte Regresión

Ahora se evalúa el algoritmo de vectores de soporte regresión, el procedimiento es muy

similar a los otros algoritmos evaluados anteriormente.

98
Resultado una vez ejecutado el código anterior:

Igual que en los casos anteriores, se evalúa el modelo obtenido por medio del error
cuadrático medio y la métrica 𝑅" .

Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

Si se observa los resultados de las métricas de evaluación no son para nada buenos, por
lo que se puede deducir que este no es el mejor algoritmo para este conjunto de datos.

Árboles de Decisión Regresión

El siguiente algoritmo a evaluar será el de árboles de decisión regresión.

99
Resultado una vez ejecutado el código anterior:

Definido el modelo, se verifica el error del mismo, para ello se utiliza la función del
error cuadrático medio y la métrica 𝑅" .

Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

Bosques Aleatorios Regresión

Para evaluar el problema implementando el algoritmo de bosques aleatorios regresión

se realiza el siguiente procedimiento.

100
Resultado una vez ejecutado el código anterior:

Se evalúa el error implementando el error cuadrático medio y la métrica 𝑅" .

Resultado una vez ejecutado el código anterior:

Resultado una vez ejecutado el código anterior:

Como se puede observar, los algoritmos evaluados obtuvieron unos resultados muy
parecidos unos con otros, exceptuando el de vectores de soporte regresión. Esto no
quiere decir que este algoritmo sea malo, sino que simplemente no es el más adecuado
para este conjunto de datos.

Se puede elegir cualquier algoritmo con el que se obtuvieron buenos resultado, en caso
de que se requiera un algoritmo que sea rápido y fácil de implementar se puede elegir
el de Regresión Lineal o el de Regresión Polinomial.

101
Capítulo 15
CONTINUAR APRENDIENDO
MACHINE LEARNING

En este capítulo encontrarás áreas en las que podrás practicar las nuevas habilidades
adquiridas de Machine Learning con Python.

En este capítulo aprenderás:

1. Encontrar conjuntos de datos para trabajar en nuevos proyectos

CONSTRUIR PLANTILLAS PARA PROYECTOS

A lo largo del libro, se ha explico cómo desarrollar proyectos de Machine Learning
utilizando Python. Lo explicado acá es la base que puede ser usada para iniciar nuevos
proyectos de Machine Learning. Esto es solamente un inicio, y puedes ir mejorando a
medida que desarrolles proyectos más grandes y complicados.

A medida que se aplique lo explicado acá y implementes las habilidades adquiridas en

Machine Learning utilizando la plataforma de Python, desarrollarás experiencia y
habilidades con nuevas y diferentes técnicas con Python, haciendo más fácil el
desarrollo de proyectos dentro de esta área.

102
CONJUNTOS DE DATOS PARA PRÁCTICA
Lo importante para mejorar las habilidades aprendidas dentro del libro es seguir
practicando. En la web puedes encontrar varios conjuntos de datos que puedes utilizar
para practicar los conocimientos y, a su vez para crear un portafolio de proyectos para
mostrar dentro de la hoja de vida.

El primer lugar donde puedes encontrar conjuntos de datos que puedes utilizar en
proyectos de Machine Learning es en el repositorio de Machine Learning de UCI
(Universidad de California en Irvine). Los conjuntos de datos de este repositorio son
estandarizados, relativamente limpios, bien entendidos y excelentes para que se use
como conjuntos de datos de práctica.

Con este repositorio se puede construir y desarrollar aún más las habilidades en el área
de Machine Learning. También es útil para empezar a crear un portafolio que puede
ser mostrado a futuros empleadores demostrando que puede ser capaz de entregar
resultados en proyectos de Machine Learning utilizando Python.

El link para este repositorio es el siguiente: http://archive.ics.uci.edu/ml/index.php.

Otra página que cuenta con muy buenos conjuntos de datos para practicar es Kaggle.
Acá, puedes descargar y practicar las habilidades aprendidas, pero también puedes
participar en competencias. En una competencia, el organizador te proporciona un
conjunto de datos de entrenamiento, un conjunto de datos de prueba en el que debes
hacer predicciones, una medida de rendimiento y un límite de tiempo. Luego, los
competidores trabajan para crear el modelo más preciso posible. Los ganadores a
menudo reciben premios en efectivo.

Estas competencias a menudo duran semanas o meses y pueden ser muy divertidas.
También ofrecen una gran oportunidad para probar tus habilidades con herramientas
de Machine Learning con conjuntos de datos que a menudo requieren mucha limpieza
y preparación. Un buen sitio para comenzar serían las competencias para
principiantes, ya que a menudo son menos desafiantes y tienen mucha ayuda en forma
de tutoriales para comenzar.

El sitio web principal para encontrar los conjuntos de datos es el siguiente:

https://www.kaggle.com/datasets.

No importa la página que se utilice para obtener los conjuntos de datos, los pasos que
se deben seguir para mejorar las habilidades de Machine Learning son los siguientes:

1. Navegar por la lista de conjuntos de datos gratuitos en el repositorio y descargar

algunos que parezcan interesantes.

103
 2. Usar las librerías y funciones aprendidas en este libro para trabajar a través del
conjunto de datos y desarrollar un modelo preciso.

3. Escribir el flujo de trabajo y las conclusiones obtenidas para que puedan ser
consultados más adelante e inclusive si es posible compartir esta información en
algún sitio web, un lugar recomendado es en Github.

Trabajar en pequeños proyectos es una buena manera de practicar los fundamentos.

En ocasiones algunos problemas se volverán fáciles por lo cual se debe buscar nuevos
retos para salir de la zona de confort para ayudar a aumentar las habilidades en
Machine Learning.

104
Capítulo 16
OBTENER MÁS
INFORMACIÓN

Este libro es solo el comienzo de tu camino para aprender Machine Learning con
Python. A medida que se desarrolle nuevos proyectos, es posible que necesites ayude.
En este capítulo se indica algunas de las mejores fuentes de ayuda de Python y Machine
Learning que puede encontrar.

En este capítulo aprenderás:

1. Sitios web útiles para aclarar dudas.

CONSEJO GENERAL
En general, en la página LigdiGonzalez podrás encontrar mucha más información
sobre Machine Learning. Desde información teórica como ejercicios prácticos, de esta
forma podrás aumentar tus habilidades dentro de este tema. Toda la información
contenida acá es en español.

105
 Para mayor información se puede revisar la siguiente información:

http://bit.ly/2JbWcaX

De igual forma, la documentación oficial de Python y SciPy es excelente. Tanto las guías
de usuario como la documentación de API son una excelente ayuda para aclarar dudas.
Acá podrás tener una comprensión más completa de la configuración más profunda
que puedes explorar. La información publicada es en inglés.

Otro recurso muy útil son los sitios de preguntas y respuestas, como StackOverflow. Se
puede buscar mensajes de error y problemas que se tenga y encontrar ejemplos de
códigos e ideas que pueden ayudar en los proyectos. Esta página se encuentra tanto en
español como en inglés, aunque en está ultima se encuentra la mayor cantidad de
información.

AYUDA CON PYTHON

Python es un lenguaje de programación con todas las funciones. Como tal, cuanto más
aprendas sobre él, mejor podrás usarlo. Si es relativamente nuevo en la plataforma
Python, aquí hay algunos recursos valiosos para ir un paso más profundo:

Documentación oficial Python 3:

https://docs.python.org/3/

AYUDA CON SCIPY Y NUMPY

Es una buena idea familiarizarse con el ecosistema SciPy más amplio, por lo que es
recomendable revisar las notas de SciPy y la documentación de NumPy, sobretodo
cuando se tenga problemas con estas librerías.

Notas de SciPy:
http://scipy-lectures.org/

Documentación oficial NumPy:

https://docs.scipy.org/doc/numpy/user/

AYUDA CON MATPLOTLIB

Mostrar gráficamente los datos es algo muy importante en Machine Learning, por lo
que se puede revisar la información oficial de matplotlib, en donde se encuentran

106
muchos ejemplos, con sus respectivos códigos, que pueden ser bastante útil para
implementar en los proyectos propios.

Documentación oficial matplotlib:

https://matplotlib.org/gallery.html

AYUDA CON PANDAS

Pandas cuenta con una gran cantidad de documentación. Los ejemplos presentados en
la documentación oficial son muy útiles ya que darán ideas sobre diferentes maneras
de dividir y cortar los datos.

Documentación oficial Pandas:

http://pandas.pydata.org/pandas-docs/stable/

AYUDA CON SCIKIT-LEARN

La documentación publicada en la página web de scikit-learn es de gran ayuda al
momento de desarrollar proyectos de Machine Learning, revisar la configuración de
cada función puede ayudar a mejorar los proyectos y obtener mejores resultados.

Documentación oficial scikit-learn:

https://scikit-learn.org/stable/documentation.html

107
Ligdi González
2020

_______________________________

Machine Learning
con Python
Aprendizaje Supervisado

108