UNIVERSIDAD CUAUHTÉMOC

PLANTEL AGUASCALIENTES
EDUCACIÓN A DISTANCIA



Materia
Programación en Python

Docente
Dr. Iván Castillo Zúñiga.
[email protected]




“EXCELENTES PROFESIONISTAS, MEJORES SERES HUMANOS”
Introducción.
Para un viaje exitoso de aprendizaje de máquina del inglés Machine Learning, es necesario elegir el
lenguaje de codificación adecuado desde el principio, ya que su elección determinará su futuro. En
este paso, debe pensar estratégicamente y organizar correctamente las prioridades y no perder tiempo
en cosas innecesarias.

Python es una opción perfecta para que los programadores se centren para saltar al campo del
aprendizaje de máquina y la ciencia de datos. Es un lenguaje minimalista e intuitivo con una línea de
biblioteca completa (llamada frameworks) que reduce significativamente el tiempo requerido para
obtener sus primeros resultados.

El aprendizaje de máquina, es el aprendizaje basado en la experiencia. Como ejemplo, es como una

persona que aprende a jugar ajedrez a través de la observación mientras otros juegan. De esta forma,
las computadoras pueden programarse mediante la provisión de información para la cual están
capacitados, adquiriendo la capacidad de identificar elementos o sus características con alta
probabilidad.

En primer lugar, debe saber que hay varias etapas de aprendizaje de máquina:

• Recopilación de datos.
• Clasificación de datos.
• Análisis de los datos.
• Desarrollo de algoritmos.
• Algoritmo de comprobación generado.
• El uso de un algoritmo para sacar conclusiones.

Para buscar patrones, se utilizan varios algoritmos, que se dividen en dos grupos:

1. Aprendizaje automático.
2. Aprendizaje supervisado.

Con el aprendizaje automático, su máquina recibe sólo un conjunto de datos de entrada.

Posteriormente, la máquina está preparada para determinar la relación entre los datos ingresados y
cualquier otro dato hipotético. A diferencia del aprendizaje supervisado, donde la máquina cuenta
con algunos datos de verificación para el aprendizaje, el aprendizaje independiente sin supervisión
implica que la computadora misma encontrará patrones y relaciones entre diferentes conjuntos de
datos. El aprendizaje no supervisado se puede dividir en agrupación y asociación.

El aprendizaje supervisado implica la capacidad de la computadora para reconocer elementos

basados en las muestras proporcionadas. La computadora lo estudia y desarrolla la capacidad de
reconocer nuevos datos basados en estos datos. Por ejemplo, puede entrenar a su computadora para
filtrar mensajes de spam basados en información recibida previamente.

Algunos algoritmos de aprendizaje supervisados incluyen:

a. Árboles de decisión.
b. Máquinas de Soporte Vectorial (MSV).
c. Clasificador de Bayes.
d. K-vecinos más cercanos.
e. Regresión lineal.
f. Redes neuronales.

Dr. Iván Castillo Zúñiga 1

Programación en el lenguaje Python.
Unidad 4.
Machine learning con Python.
6.1 Conjuntos de datos y aprendizaje de máquina.
6.1.1 Conjunto de datos (dataset).
6.1.2 Relación de los dataset en el machine learning.
6.2 Aprendizaje de máquina (aprendizaje supervisado).
6.2.1 Red Neuronal Perceptron Multicapa.
6.2.2 Máquinas de Soporte Vectorial (MSV).
6.2.3 Arboles de decisión.
6.2.4.Bosques aleatorios.
6.2.5 Potenciación AdaBoost (Boosting).
6.2.6 Knn – vecino más cercano.
6.2.7 Bayes.

4.1 Conjuntos de datos y aprendizaje de máquina.

4.1.1 Conjunto de datos (dataset).

Dataset.

El término dataset en sí es un término extranjero, un anglicismo, que hemos incorporado a

nuestra lengua como un término más en los países hispanohablantes. Su traducción a nuestra
lengua sería conjunto de datos y es una colección de datos habitualmente tabulada.

Un conjunto de datos o dataset corresponde a los contenidos de una única tabla de base de
datos o una única matriz de datos de estadística, donde cada columna de la tabla representa
una variable en particular, y cada fila representa a un miembro determinado del conjunto de
datos que estamos tratando. En un conjunto de datos o dataset tenemos todos los valores que
puede tener cada una de las variables, como por ejemplo la altura y el peso de un objeto, que
corresponden a cada miembro del conjunto de datos. Cada uno de estos valores se conoce
con el nombre de dato. El conjunto de datos puede incluir datos para uno o más miembros
en función de su número de filas.

El dataset incluye también las relaciones entre las tablas que contienen los datos. Si nos
movemos en el contexto de Big Data, entendemos por dataset aquellos conjuntos de datos
tan grandes que las aplicaciones de procesamiento de datos tradicionales no los pueden
procesar debido a la gran cantidad de datos contenidos en la tabla o matriz.

Podríamos definir un dataset como una colección o representación de datos residentes en

memoria con un modelo de programación relacional coherente e independientemente sea
cual sea el origen de los datos que contiene.

Una de las principales características de los datasets es que ya tienen una estructura.

Dr. Iván Castillo Zúñiga 2

Programación en el lenguaje Python.
Dataframe.

Este tipo de organización de datos se utiliza normalmente cuando se realiza un estudio

estadístico sobre los objetos de una muestra, la información y los datos de la muestra se
organizan en un dataframe. Se organizan en una hoja de datos, en los que cada fila
corresponde a un objeto de la muestra y cada columna a una variable. Esta característica de
organización de datos es la misma que en los datasets.

Si hablamos de la estructura de un dataframe es muy similar a la de una matriz. Pero en una

matriz solamente se admiten valores numéricos, a diferencia de la matriz, en un dataframe
se puede incluir también datos alfanuméricos en su contenido.

Un DataFrame es una estructura de datos con dos dimensiones en la cual se puede guardar
datos de distintos tipos (como caracteres, enteros, valores de punto flotante, factores y más)
en columnas. Un DataFrame siempre tiene un índice (con inicio en 0). El índice refiere a la
posición de un elemento en la estructura de datos.

4.1.2 Relación de los datasets con el machine learning.

Uno de los problemas más difíciles de resolver en el aprendizaje de máquina (machine

learning) no tiene nada que ver con los algoritmos de aprendizaje (redes neuronales, arboles
de decisión, máquinas de soporte vectorial, Bayes, k-nn vecino más cercano), es el problema
de obtener los datos correctos en el formato correcto (dataset).

Obtener los datos correctos significa reunir o identificar los datos que se correlacionan con
los resultados que desea predecir; es decir, datos que contienen una señal sobre los eventos
que le interesan. Los datos deben estar alineados con el problema que está tratando de
resolver. Las imágenes de gatitos no son muy útiles cuando construyes un sistema de
identificación facial. Un científico de datos debe verificar que los datos estén alineados con el
problema que busca resolver. Si no tiene los datos correctos, sus esfuerzos para construir una
solución de Inteligencia Artificial (IA) deben volver a la etapa de recopilación de datos.

El formato final correcto para el aprendizaje de máquina o aprendizaje profundo es

generalmente un tensor o una matriz multidimensional. Por lo tanto, los canales de datos
creados para el aprendizaje generalmente convertirán todos los datos, ya sean imágenes,
video, sonido, voz, texto o series de tiempo, en vectores y tensores a los que se pueden aplicar
las operaciones de álgebra lineal. Esos datos con frecuencia deben normalizarse,
estandarizarse y limpiarse para aumentar su utilidad, y esos son todos los pasos en el
aprendizaje automático de máquinas donde se aplican procesos de Extracción,
Transformación y Carga del inglés Extraction, Transformation and Load (ETL).
Deeplearning4j ofrece la herramienta DataVec ETL para realizar esas tareas de
preprocesamiento de datos.

El aprendizaje profundo y el aprendizaje de máquina en general, necesita un buen conjunto

de capacitación para funcionar correctamente. Recopilar y construir el conjunto de
capacitación, un cuerpo considerable de datos conocidos, requiere tiempo y conocimiento

Dr. Iván Castillo Zúñiga 3

Programación en el lenguaje Python.
específico del dominio de dónde y cómo recopilar información relevante. El conjunto de
entrenamiento actúa como el punto de referencia contra el cual se entrenan las redes de
aprendizaje. Eso es lo que aprenden a reconstruir antes de que se desaten los datos que no
han visto antes.

En esta etapa, los humanos con conocimientos necesitan encontrar los datos brutos correctos
y transformarlos en una representación numérica que el algoritmo de aprendizaje pueda
entender, un dataset (matriz) para aprendizaje supervisado (Supervised learning) o un tensor
(matriz multidimensional) para aprendizaje profundo (Deep learning). Construir un conjunto
de entrenamiento es, en cierto sentido, pre-pre-entrenamiento.

Los conjuntos de entrenamiento que requieren mucho tiempo o experiencia pueden servir
como una ventaja patentada en el mundo de la ciencia de datos y la resolución de problemas.
La naturaleza de la experiencia radica principalmente en decirle a su algoritmo lo que le
importa seleccionando lo que se incluye en el conjunto de entrenamiento.

Se trata de contar una historia, a través de los datos iniciales que seleccione, que guiará sus
redes de aprendizaje profundo a medida que extraen las características importantes, tanto en
el conjunto de entrenamiento como en los datos sin procesar que han sido creados para
estudiar.

Para crear un conjunto de entrenamiento útil, debe comprender el problema que está
resolviendo; es decir, a qué quiere que presten atención sus algoritmos de aprendizaje
supervisado o redes de aprendizaje profundo, a qué resultados desea predecir.

Conjuntos de datos para entrenamiento y prueba.

El aprendizaje de máquina generalmente funciona con dos conjuntos de datos:

entrenamiento y prueba. Donde se deberían muestrear aleatoriamente un cuerpo de datos
más grande.

El primer conjunto que usa es el conjunto de entrenamiento, el más grande de los conjuntos.
Ejecutar un conjunto de entrenamiento a través de un algoritmo de aprendizaje supervisado
o una red neuronal en aprendizaje profundo le enseña a la red cómo sopesar diferentes
características, ajustando los coeficientes de acuerdo con su probabilidad de minimizar los
errores en sus resultados.

Esos coeficientes, también conocidos como parámetros, estarán contenidos en matrices

unidimensionales o tensores (matrices multidimensionales) y juntos se denominan modelo,
porque codifican un modelo de los datos sobre los que se entrenan. Son las conclusiones más
importantes que obtendrá al entrenar algoritmo de aprendizaje supervisado o una red
neuronal en aprendizaje profundo.

El segundo conjunto es su conjunto de prueba. Funciona como un sello de aprobación y no

lo usa hasta el final. Después de entrenar y optimizar sus datos, prueba su algoritmo
supervisado o red neuronal (aprendizaje profundo) contra este muestreo aleatorio final. Los

Dr. Iván Castillo Zúñiga 4

Programación en el lenguaje Python.
resultados que produce deben validar que su algoritmo reconoce con precisión la solución
del problema, o reconoce al menos un porcentaje de ellas.

Si no obtiene predicciones precisas, vuelva al conjunto de entrenamiento, mire los

hiperparámetros que utilizó para ajustar la red o los algoritmos de aprendizaje de máquina,
así como la calidad de sus datos y sus técnicas de preprocesamiento.

4.1.3 Dataset en Python.

Podemos automatizar el proceso de manipular datos con Python. Vale la pena pasar tiempo
escribiendo el código que haga estas tareas ya que una vez que se escribió, lo podemos usar
una y otra vez en distintos conjuntos de datos que usen un formato similar. Esto hace a
nuestros métodos fácilmente reproducibles. También resulta fácil compartir nuestro código
con nuestros colegas y ellos pueden replicar el mismo análisis.

Es recomendable que el dataset se encuentre en el mismo directorio en

donde se encuentra el programa.

Pandas en Python.

Una de las mejores opciones para trabajar con datos tabulares en Python es usar la Python
Data Analysis Library (alias Pandas). La biblioteca Pandas provee estructuras de datos, que
generan gráficos de alta calidad con matplotlib y se integra de buena forma con otras
bibliotecas que usan arrays de NumPy (la cual es otra biblioteca de Python).

Python no carga todas las bibliotecas disponibles por default. Se tiene que usar el
enunciado import en nuestro código para usar las funciones de la biblioteca. Para importar
una biblioteca se usa la sintaxis import nombreDeLaBiblioteca. Si además le queremos poner
un sobrenombre para acortar los comandos, se puede agregar as sobrenombreAUsar. Un
ejemplo es importar la biblioteca panda usando su sobrenombre común pd como en el
siguiente ejemplo:

import pandas as pd

Leyendo datos en CSV usando Pandas

CSV son las siglas para Comma-Separated Values, valores separados por coma, y es una
manera común de guardar datos. Otros símbolos pueden ser usados, te puedes encontrar
valores separados por tabuladores, por punto y coma o por espacios en blanco. Es fácil
remplazar un separador por otro, para usar tu aplicación. La primera línea del archivo
generalmente contiene los encabezados que dicen que hay en cada columna. CSV (y otros
separadores) hacen fácil compartir los datos y pueden ser importados y exportados desde
distintos programas, incluyendo Microsoft Excel.

Dr. Iván Castillo Zúñiga 5

Programación en el lenguaje Python.
Instrucción para leer un dataset
En el siguiente ejemplo utilizaremos el dataset de cibercrimen. El cual fue obtenido a tráves
de técnicas de Extracción, Transformación y Carga (ETL) con la arquitectura ADVI para el
preprocesamiento de datos, usando 1326 páginas descargadas de la Web, con un vocabulario
de 107 vocablos. Se importa la librería pandas, y se asigna al objeto pd, posteriormente se
define la variable datos que será usada para cargar el dataframe y manipular las instrucciones
sobre el. En la Fig. 1, se muestra el dataframe del cibercrimen.

Figura 1. Carga de un dataframe en Python.

El archivo del dataset, se encuentra en el área de recursos, con el nombre

“cibercrimen.csv”, el cual podrá descargar de la plataforma de la UCA. Este dataset será
utilizado en los algoritmos de red neuronal y máquinas de soporte vectorial.

Explorando los datos

La función type es usada para ver que tipo de variable u objeto es datos. Y efectivamente
como se muestra a continuación, es un objeto tipo DataFrame.

La función size es usada para mostrar el tamaño total del Dataframe, como se muestra a
continuación:

La función shape es usada para mostrar cuantas filas y columnas tiene el Dataframe, como
se muestra a continuación:

El dataset contiene 1326 renglones y 107 columnas.

Dr. Iván Castillo Zúñiga 6

Programación en el lenguaje Python.
La función ndim es usada para mostrar las dimensiones que tiene el Dataframe, como se
muestra a continuación:

La función columns es usada para mostrar las columnas o atributos que tiene el Dataframe,
como se muestra a continuación:

La función axes es usada para mostrar los renglones y columnas que tiene el Dataframe,
como se muestra a continuación

La Tabla 1, describe las funciones usadas para obtener datos estadísticos de como esta
conformado un Dataframe, y la Tabla 2, describe los métodos para manipular un Dataframe.

Tabla 1. Funciones para obtener estadísticos del Dataframe.

Dr. Iván Castillo Zúñiga 7

Programación en el lenguaje Python.
4.2 Aprendizaje de máquina (aprendizaje supervisado).

En el campo de aprendizaje de máquina se establece en dos pilares principales,

llamados aprendizaje supervisado y aprendizaje no supervisado. Algunas personas también
consideran un nuevo campo de estudio, “el aprendizaje profundo”, que sea separado de la
pregunta común de aprendizaje supervisado o no supervisado.

El aprendizaje supervisado se da cuando una computadora es presentada con ejemplos de

entradas y sus salidas deseadas. La meta es aprender sobre fórmulas generales que mapea
entradas a salidas.

En contraste, el aprendizaje no supervisado se da cuando no se otorgan etiquetas y queda de

parte del algoritmo encontrar la estructura en su entrada. El aprendizaje no supervisado
puede ser una meta en sí misma cuando sólo necesitamos descubrir patrones escondidos.

El aprendizaje profundo es un nuevo campo de estudio el cual está inspirado por la estructura
y función del cerebro humano, de igual manera está basado en redes neuronales artificiales
en vez de sólo conceptos estadísticos. El aprendizaje profundo se puede usar en ambos
acercamientos, supervisado y no supervisado.

En los siguientes objetivos, analizaremos algunos de los algoritmos de aprendizaje de

máquina supervisados (Redes neuronales, Máquinas de Soporte Vectorial (MSV), Bayes,
Knn – Vecino más cercano, Arboles de decisión, Bosques aleatorios y AdaBoost), los cuales
serán usados para calcular el porcentaje de precisión para detectar vocabulario de
Cibercrimen en páginas Web.

4.2.1 Red neuronal.

Las Redes neuronales (denominadas habitualmente como RNA) son un paradigma de

aprendizaje y procesamiento automático inspirado en la forma en que funciona el sistema
nervioso de los humanos. Se trata de un sistema de interconexión de neuronas que colaboran
entre sí para producir un estímulo de salida.

Los primeros modelos de redes neuronales datan de 1943 por los neurólogos Warren
McCulloch y Walter Pitts. Años más tarde, en 1949, Donald Hebb desarrolló sus ideas sobre
el aprendizaje neuronal, quedando reflejado en la "regla de Hebb". En 1958, Rosenblatt
desarrolló el Perceptron simple, y en 1960, Widrow y Hoff desarrollaron el Adaline, que fue
la primera aplicación industrial real.

En los años siguientes, se redujo la investigación, debido a la falta de modelos de aprendizaje

y el estudio de Minsky y Papert sobre las limitaciones del Perceptron. Sin embargo, en los
años 80, volvieron a resurgir las RNA gracias al desarrollo de la red de Hopfield, y en especial,
al algoritmo de aprendizaje de retro-propagación (BackPropagation) ideado por Rumelhart
y McClelland en 1986 que fue aplicado en el desarrollo de los perceptrones multicapa
(Hernández, Ramírez & Ferri, 2004).

Dr. Iván Castillo Zúñiga 8

Programación en el lenguaje Python.
Funcionamiento de una Red neuronal.

Una Red neuronal se compone de unidades llamadas neuronas. Cada neurona recibe una
serie de entradas a través de interconexiones y emite una salida. Esta salida viene dada por
tres funciones:

1. Una función de propagación (también conocida como función de excitación), que por
lo general consiste en el sumatorio de cada entrada multiplicada por el peso de su
interconexión (valor neto). Si el peso es positivo, la conexión se denomina excitatoria;
si es negativo, se denomina inhibitoria.
2. Una función de activación, que modifica a la anterior. Puede no existir, siendo en este
caso la salida la misma función de propagación.
3. Una función de transferencia, que se aplica al valor devuelto por la función de
activación. Se utiliza para acotar la salida de la neurona y generalmente viene dada
por la interpretación que queramos darles a dichas salidas. Algunas de las más
utilizadas son la función sigmoidea (para obtener valores en el intervalo (0,1)) y la
tangente hiperbólica (para obtener valores en el intervalo (-1,1)).

La Fig. 2, muestra la estructura de una Red

neuronal (Perceptron simple). Compuesta
por los valores de entrada, los pesos
sinápticos (dendritas), el sumador, la
función de activación y la salida. Entrenar
una Red neuronal significa descubrir los
pesos de las neuronas.

Figura 2. Red neuronal (Perceptron simple).

Perceptron simple.

El Perceptron simple, es el algoritmo empleado en la investigación, el cual, se aplica a casos

linealmente separables. La característica principal del Perceptron simple, es que la suma
ponderada de las señales de entrada, es comparada con un valor promedio de los blancos
(Perceptron simple) o umbral (Adaline) para determinar la salida de la neurona. Cuando la
suma es igual o mayor al blanco o umbral, la salida es 1, en caso contrario es 0.

Proceso de la Red neuronal (Perceptron simple).

1. La red comienza en un estado aleatorio. Los pesos entre neuronas poseen valores
pequeños y aleatorios (entre -1 y 1).
2. Seleccionar un vector de entrada, x, a partir del conjunto de ejemplos de
entrenamiento.
3. Se propaga la activación hacia delante a través de los pesos en la red para calcular la
salida O =w.x.
4. Si O = t (Es decir, si la salida de la red es correcta) volver al paso 2.
5. En caso contrario el cambio de los pesos se realiza atendiendo a la siguiente expresión:
wi = n xi ( t o ) donde n es un número pequeño positivo conocido como coeficiente
de aprendizaje. Volver al paso 2.

Dr. Iván Castillo Zúñiga 9

Programación en el lenguaje Python.
Perceptron multicapa en Python.
El algoritmo de Red Neuronal utilizado en Python es el Perceptron Multicapa del inglés
Multi-Layer Perceptron (MLP) (Scikit-learn.org, 2019), es un algoritmo supervisado que
aprende una función entrenando en un conjunto de datos, donde m, es el número
de dimensiones para entrada, y o es el número de dimensiones para la salida. Dado un
conjunto de características y un objetivo y, este puede aprender un aproximador
de función no lineal para clasificación o regresión. Es diferente de la regresión logística, ya
que entre la capa de entrada y la de salida, puede haber una o más capas no lineales, llamadas
capas ocultas. La Fig. 4 muestra un MLP de una capa oculta con salida escalar, la Fig. 5
muestra el programa.

Figura 4. Perceptron multicapa con una capa oculta con salida escalar.
Algoritmo de Red Neuronal en Python.
# Librerias
# ********************************************************
# Libreria para el tiempo
import time
# Libreria para algoritmos de machine learning
import sklearn
# Especificaciones para usar una Red Neuronal
# Importamos el train_test_split para dividir los datos de entrenamiento y prueba
from sklearn.model_selection import train_test_split
# Especificaciones para usar la Red Neuronal Perceptron Muticapa
from sklearn.neural_network import MLPClassifier
# Libreria para construir la matriz de confusión
from sklearn.metrics import confusion_matrix
# Libreria para ignorar los warnings
import warnings
warnings.filterwarnings("ignore", category=FutureWarning)
# Libreria para cargar el dataset o dataframe
import pandas as pd
import seaborn as sns
# Libreria para usar graficación de la matríz de confusión
import matplotlib.pyplot as plt
# Especificación del algoritmo a utilizar
print("\n")
print ("----------------------------------------------------------------------------------------------------------------------------------------------------------")
print (" MODELO DE CLASIFICACIÓN DE UNA RED NEURONAL (para detección de vocabulario de Cibercrimen)")
print ("----------------------------------------------------------------------------------------------------------------------------------------------------------")

Dr. Iván Castillo Zúñiga 10

Programación en el lenguaje Python.
 # Proceso del algoritmo de Red Neuronal Perceptron Multicapa
# ************************************************************
# Inicia del contador de tiempo
inicio_tiempo=time.time()
# Carga el dataset
dataset = 'cibercrimen.csv'
df = pd.read_csv(dataset)
# Muestra la dimensión del dataset
print("\n")
print ("Dimensión del Dataset: ")
print ("Registros: ", df.shape[0])
print ("Columnas: ", df.shape[1])
print("\n")
print ("Variables predictoras")
arreglox = df[df.columns[:-1]].as_matrix() # Específica tomar variables predictoras
print (arreglox)
print("\n")
print ("Variable a predecir")
arregloy= df[df.columns[-1]].as_matrix() # Específica tomar variable a predecir (última posición)
print (arregloy)
# Especificación del modelo de datos para entrenamiento
X_train, X_test, y_train, y_test = train_test_split(arreglox , arregloy,test_size = 0.3)
print("\n")
print ("Entrenamiento: ",len(X_train), "registros (70%)")
print ("Pruebas: ",len(X_test), "registros (30%)")
# Variable red carga el modelo de Red Neuronal, parametros (iteraciones y capas ocultas en la red)
# El modelo se ajusta hasta que se llegue a una solucion óptima
red=MLPClassifier(max_iter=10000, hidden_layer_sizes=(4))
# Establece en el modelo número de registros para entrenamiento y para pruebas
red.fit(X_train,y_train)
# Verifica el porcentaje de aprendizaje del algoritmo
print ("Aprendizaje del algoritmo en el entrenamiento: {0:.2f}"
.format (red.score(X_test,y_test)),"%")
print("\n")
# Especificación del modelo de datos para clasificar (pruebas)
model = MLPClassifier()
# Ajusta el modelo a los datos de entrenamiento
print ("Ajusta el modelo de datos al proceso de entrenamiento")
print (model.fit(X_train, y_train))
#Matríz de confusión de entrenamiento
y_predicted = model.predict(X_test)
cm = confusion_matrix(y_test, y_predicted)
#Matríz de confusión de pruebas
y_pred = red.fit(X_train, y_train).predict(X_test)
cnf_matrix = confusion_matrix(y_test, y_pred)
#Finaliza el tiempo del proceso
tiempo=(time.time()-inicio_tiempo)
# Matriz de confusión de pruebas
print("\n")
print ("MATRIZ DE CONFUSIÓN")
sns.heatmap(cnf_matrix.T, square=True, annot=True, fmt='d', cbar=True)
plt.xlabel('Clase verdadera')
plt.ylabel('Clase predecida')
plt.title('Matriz de Confusión')
plt.show()
print ("Descripción")
print ("Verdaderos Negativos: ",cnf_matrix[0,0])
print ("Verdaderos Positivos: ",cnf_matrix[1,1])
print ("Falsos Positivos: ",cnf_matrix[1,0])
print ("Falsos Negativos: ",cnf_matrix[0,1])
# Visualizando los resultados
print("\n\n")
print ("RESULTADOS DE CLASIFICACIÓN")
print ("------------------------------------------------------------------")
porcentaje=(1-(y_test != y_pred).sum()/y_test.shape[0])

Dr. Iván Castillo Zúñiga 11

Programación en el lenguaje Python.
 print("Porcentaje de precisión: {0:.1f}"
.format(porcentaje * 100),"%")
print("Errores de clasificación: {1} errores, sobre un total de {0} casos"
.format(y_test.shape[0],(y_test != y_pred).sum()))
print("Tiempo de ejecución es de: {0:.2f}"
.format(tiempo),"seg")
print ("------------------------------------------------------------------")

Figura 5. Resultados del algoritmo Red neuronal en Python.

Dr. Iván Castillo Zúñiga 12

Programación en el lenguaje Python.
4.2.2 Máquina de Soporte Vectorial.

Las Máquinas de Soporte Vectorial son un conjunto de algoritmos de aprendizaje

supervisado desarrollados por Vladimir Vapnik y su equipo en los laboratorios AT&T.

Estos métodos están propiamente relacionados con problemas de clasificación y regresión.

Dado un conjunto de ejemplos de entrenamiento (de muestras) podemos etiquetar las clases
y entrenar una MSV para construir un modelo que prediga la clase de una nueva muestra.
Intuitivamente, una MSV es un modelo que representa a los puntos de muestra en el espacio,
separando las clases por un espacio lo más amplio posible. Cuando las nuevas muestras se
ponen en correspondencia con dicho modelo, en función de su proximidad pueden ser
clasificadas a una u otra clase.

La MSV con separación lineal, tiene el

propósito de separar una clase de otra clase,
localizando una línea entre ellas llamada
Vector, buscando la máxima separación
formando grupos, donde los ejemplos usados
para definir la línea son conocidos como
vectores de soporte, de ahí su nombre de
“Máquinas de Soporte Vectorial”. La Fig. 6,
muestra un ejemplo de MSV con separación
lineal.

Figura 6. Máquina de Soporte Vectorial con separación lineal.

La técnica lineal, utiliza un clasificador lineal con el margen más amplio, como se aprecia en
el gráfico (B) de la Fig. 7, (donde el máximo margen es la mejor solución), reduciendo al
mínimo, el error en donde podrían existir una cantidad infinita de posibles hiperplanos, como
se aprecia en el gráfico (A) de la misma Figura. El margen se define como el ancho que limita
los datos, de esta manera se separa la clase positiva de la clase negativa.

Figura 7. Técnica lineal con el margen más amplio (MSV).

Dr. Iván Castillo Zúñiga 13

Programación en el lenguaje Python.
Cuando no es linealmente separable el problema, los datos de entrada se trasladan a otra
dimensión donde la tabla de entrenamiento sea separable, mediante la definición de un kernel
(núcleo). Las distancias entre dimensiones son más allá de las líneas.

Técnicas no linealmente separables.

• Polinómica.
• Gaussiana.
• Sigmoidal.
• Multicuadrática inversa.

Máquinas de Soporte Vectorial en Python

Las Máquinas de Soporte Vectorial en Python, son un conjunto de métodos de aprendizaje

supervisados utilizados para la clasificación, regresión y detección de valores atípicos.

El programa se basa en en el algoritmo libsvm (sklearn.svm.SVC). El tiempo de ajuste se

escala al menos cuadráticamente con el número de muestras y puede ser poco práctico más
allá de decenas de miles de muestras. Para conjuntos de datos demasiado grandes, considerar
usar los algoritmos sklearn.linear_model.LinearSVC o sklearn.linear_model.SGDClassifier
en su lugar, posiblemente después de un transformador
sklearn.kernel_approximation.Nystroem (Scikit-learn.org, 2019).

El soporte multiclase se maneja de acuerdo con un esquema uno contra uno. Para obtener
detalles sobre la formulación matemática precisa de las funciones del núcleo proporcionadas
y cómo gamma, coef0 y grado se afectan entre sí, consulte la sección correspondiente en la
documentación narrativa: Funciones del núcleo.
Algoritmo de Máquinas de Soporte Vectorial.
# Librerias
# ********************************************************
# Libreria para el tiempo
import time
# Libreria para algoritmos de machine learning
import sklearn
# Libreria para generar modelos con Máquinas de Soporte Vectorial
from sklearn.svm import SVC
# Importamos el train_test_split para dividir los datos de entrenamiento y prueba
from sklearn.model_selection import train_test_split
# Libreria para construir la matriz de confusión
from sklearn.metrics import confusion_matrix
# Libreria para ignorar los warnings
import warnings
warnings.filterwarnings("ignore", category=FutureWarning)
# Libreria para cargar el dataset o dataframe
import pandas as pd
import seaborn as sns
# Libreria para usar graficación de la matríz de confusión
import matplotlib.pyplot as plt
# Especificación del algoritmo a utilizar
print("\n")
print ("----------------------------------------------------------------------------------------")
print (" MODELO DE CLASIFICACIÓN CON MÁQUINAS DE SOPOERTE VECTORIAL")

Dr. Iván Castillo Zúñiga 14

Programación en el lenguaje Python.
 print ("----------------------------------------------------------------------------------------")
print("\n")
print (" DETECCIÓN DE VOCABULARIO DE CIBERCRIMEN")
# Proceso del algoritmo de Máquinas de Soporte Vectorial
# ********************************************************
# Inicia del contador de tiempo
inicio_tiempo=time.time()
# Carga el dataset
dataset = 'cibercrimen.csv'
df = pd.read_csv(dataset)
print("\n")
print ("Dimensión del Dataset: ")
print ("Registros: ", df.shape[0])
print ("Columnas: ", df.shape[1])
print("\n")
print ("Variables predictoras")
arreglox = df[df.columns[:-1]].as_matrix() # Específica tomar variables predictoras
print (arreglox)
print("\n")
print ("Variable a predecir")
arregloy= df[df.columns[-1]].as_matrix() # Específica tomar variable a predecir (última posición)
print (arregloy)
# Especificación del modelo de datos para entrenamiento
X_train, X_test, y_train, y_test = train_test_split(arreglox , arregloy,test_size = 0.3)
print("\n")
print ("Entrenamiento: ",len(X_train), "registros (70%)")
print ("Pruebas: ",len(X_test), "registros (30%)")
# Variable model carga el modelo de la Máquina de Soporte Vectorial
model = SVC()
# Establece en el modelo número de registros para entrenamiento y para pruebas
model.fit(X_train, y_train)
# Verifica el porcentaje de aprendizaje del algoritmo
print ("Aprendizaje del algoritmo en el entrenamiento: {0:.2f}"
.format(model.score(X_test,y_test)),"%")
print("\n")
# Matriz de confusión de entrenamiento
y_pred = model.fit(X_train, y_train).predict(X_test)
# Matriz de confusión de pruebas
cnf_matrix = confusion_matrix(y_test, y_pred)
#Finaliza el tiempo del proceso
tiempo=(time.time()-inicio_tiempo)
# Matriz de confusión de pruebas
print("\n")
print ("MATRIZ DE CONFUSIÓN")
sns.heatmap(cnf_matrix.T, square=True, annot=True, fmt='d', cbar=True)
plt.xlabel('Clase verdadera')
plt.ylabel('Clase predecida')
plt.title('Matriz de Confusión')
plt.show()
print ("Descripción")
print ("Verdaderos Negativos: ",cnf_matrix[0,0])
print ("Verdaderos Positivos: ",cnf_matrix[1,1])
print ("Falsos Positivos: ",cnf_matrix[1,0])
print ("Falsos Negativos: ",cnf_matrix[0,1])
# Optimización (Parametro de C, le indica cuanto desea evitar clasificar mal un dato)
# Cuando el valor de C es más pequeño, elige un hiperplano de separación de mayor margen
# haciendo un mejor trabajo de clasificación
model_C = SVC(C=1)
model_C.fit(X_train, y_train)
model_C.score(X_test, y_test)
# Cuando el valor de C es más grande, elige un hiperplano de separación de menor margen
# generando un número mayor de errores de clasificación
model_C = SVC(C=10)
model_C.fit(X_train, y_train)
model_C.score(X_test, y_test)

Dr. Iván Castillo Zúñiga 15

Programación en el lenguaje Python.
 # Visualizando los resultados
print("\n\n")
print ("RESULTADOS DE CLASIFICACIÓN")
print ("-------------------------------------------------------------------------------------------")
porcentaje=(1-(y_test != y_pred).sum()/y_test.shape[0])
print("Precisión: {0:.1f}".format(porcentaje * 100),"%")
print("Precisión optimizada (C=10): {0:.1f}".format(model_C.score(X_test, y_test) * 100),"% **Optimiza la clasificación generando ")
print (" un hiperplano de separación de menor margen")
print("Errores de clasificación: {1} errores, sobre un total de {0} casos".format(y_test.shape[0],(y_test != y_pred).sum()))
print("Tiempo de ejecución es de: {0:.2f}" .format(tiempo),"seg")
print ("-------------------------------------------------------------------------------------------")

La Fig. 8, muestra el programa de Máquinas de Soporte Vectorial funcionando en lenguaje

Python, específicamente en Jupyter de Anaconda.

Figura 8. Resultados del algoritmo Máquina de Soporte Vectorial en Python.

Dr. Iván Castillo Zúñiga 16

Programación en el lenguaje Python.
Caso de estudio del objetivo 4.2 Aprendizaje de máquina (aprendizaje supervisado).

Implementar un caso de estudio real o ficticio usando aprendizaje supervisado con red
neuronal y máquinas de soporte vectorial. Los puntos que debe considerar en su solución y
en la escritura de su reporte, son los siguientes:

1. Definir el problema.
• Describir el problema.
• Que se pretende predecir.
• De que datos se dispone.
• Que datos es necesario conseguir.

2. Definir variables predictoras y variable a definir.

• Explorar y entender los datos.
• Explicar cada una de las variables predictoras, porque fue seleccionada.
• Explicar la variable a predecir, en que se basa para asignar el valor Si y No.

3. Métrica de éxito.
• Definir una forma apropiada de cuantificar como de buenos son los resultados
obtenidos.

4. Machine Learning.
• Proceso de carga de datos.
• Implementar y adecuar el algoritmo Red neuronal.
• Implementar y adecuar el algoritmo de Máquinas de Soporte Vectorial.
• Especificar el porcentaje de clasificación o predicción obtenido.

5. Explicar los resultados obtenidos y como aplicarlos a la solución.

Nota: Es importante mencionar que, para desarrollar la presente

actividad, primero debe comprender el material y realizar los
ejemplos proporcionados en esta unidad, de la página 1 a la 16. En
donde debe analizar el dataset proporcionado de Cibercrimen, el
código de red neuronal y máquina de soporte vectorial
proporcionados, asimismo entender los resultados que arrojan
dichos algoritmos.

Dr. Iván Castillo Zúñiga 17

Programación en el lenguaje Python.
Bibliografía

1. Adnan, A., Lee, T. & Prakash, Amit. (2016). “Elements of Programming Interviews in
Python. The insider Guide”. Ed. Amazon Services. 458 pág. ISBN: 978-1537713946.
2. Barry, P. (2016). “Head First Python”. 2nd Edition. Boston: O ́Reilly. 429 pág. ISBN: 978-
1491919538.
3. Bennett, J. (2019). “Supercharged Python: Take Your Code to the Next Level”. Ed. Addison-
Wesley. 672 pág. ISBN: 978-0135159941.
4. Blog Tecnología para el Desarrollo (2018). “Es Python el lenguaje del futuro”. Descargado el
9 de septiembre del sitio de Internet:
https://www.paradigmadigital.com/dev/es-python-el-lenguaje-del-futuro/
5. Buttu, M. (2016). “El Gran libro de Python”. Ed. Marcocombo. 662 pág. ISBN: 978-
8426722904.
6. Danjou, J. (2019). “Serious Python: Black-Belt Advice on Deployment, Scalability, Testing,
and More”. Ed. Amazon Digital, version Kindle. 225 pág. ISBN: 1593278780.
7. Deitel, P. (2019). “Python for Programmers: with Big Data and Artificial Intelligence Case
Studies”. Ed. Amazon Services. Version kindle. 640 pág. ASIN: B07PP9Q8MC.
8. DK. (2017). “Coding Projects in Python”. Editorial: DK Publishing (Dorling Kindersley). 224
pág. ISBN: 978-1465461889.
9. Garcia, A. (2017). “Numerical Methods for Physics (Python)”. CreateSpace Independent
Publishing Platform; 2da. Ed. Editorial: CreateSpace Independent Publishing Platform. 350
Pág. ISBN: 978-1548865498.
10. Hinojosa, Á. (2016). “Python paso a paso”. Ed. Ra-Ma. 230 pág. ISBN: 978-8499646114.
11. Kopec, D. (2019). “Classic Computer Science Problems in Python”. Editorial: Manning
Publications. 224 pág. ISBN: 978-1617295980.
12. Librosweb (2018). “Bases de Datos en Python con MySQL”. Descargado el 14 de septiembre
del sitio de Internet: https://librosweb.es/libro/python/capitulo-12.html
13. Lutz, L. (2018). “Guía paso a paso para aprender programación Python). Ed. Amazon
Services. 246 pág. ASIN: B07CSGFB43.
14. Mueller, J. (2018). “Beginning Programming with Python for Dummies”. Editorial: For
Dummies series. 408 pág. ISBN: 978-1118891452.
15. Nunez-Iglesias, J., Van Der Walt, S. W., & Dashnow, H. (2017). “Elegant Scipy: The Art of
Scientific Python”. Editorial: O'Reilly Media. 282 pág. ASIN: B074RB2FT2.
16. Pérez, A. (2016). “Python fácil”. Editorial: Alfaomega. 284 pág. ISBN: 978-6076226612
17. Rossum (2017). “El tutorial de Python”. Descargado el 13 de septiembre del sitio de Internet:
http://www.pyrhon.org.ar
18. Scikit-learn.org (2019). “Arboles de decisión (sklearn.tree)”. Descargado el 20 de
septiembre de 2019, de la página:
https://scikit-
learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html
19. Scikit-learn.org (2019). “Bosques Aleatorios
(sklearn.ensemble.RandomForestClassifier)”. Descargado el 20 de septiembre de
2019, de la página:
https://scikit-
learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html
20. Scikit-learn.org (2019). “K-nn Vecinos más cercanos”. Descargado el 20 de
septiembre de 2019, de la página:
https://scikit-
learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html

Dr. Iván Castillo Zúñiga 18

Programación en el lenguaje Python.
 21. Scikit-learn.org (2019). “Perceptron (MPL)”. Descargado el 20 de septiembre de
2019, de la página:
https://scikit-learn.org/stable/modules/neural_networks_supervised.html
22. Scikit-learn.org (2019). “sklearn.svm.SVC”. Descargado el 20 de septiembre de 2019,
de la página:
https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html
23. Urban, M., & Murach, J. (2016). “Murach's Python Programming”. Editorial: Mike Murach
& Associates. 590 pág. ISBN: 978-1890774974.
24. Zelle, J. (2016). “Python Programming: An Introduction to Computer Science”. Editorial:
Franklin Beedle & Associates; 3rd ed. 552 pág. ISBN: 978-1590282755.

Dr. Iván Castillo Zúñiga 19

Programación en el lenguaje Python.