6º Semestre - Universidad Abierta y a Distancia de México

Matemáticas

Computación II

6º Semestre

Unidad 2: Minería de datos

Clave

05142423/06142423

Universidad Abierta y a Distancia de México

Computación II

Unidad 2. Minería de datos

UnADM | DCEIT | MT | MCOM2 2

Índice

Presentación .......................................................................................................................... 3

Competencia específica .......................................................................................................... 3

Logros ................................................................................................................................... 3

Desarrollo de temas ............................................................................................................... 3

K-Medios ............................................................................................................................... 5

PCA (Análisis por componentes principales)........................................................................... 10

SVM (Maquinas de soporte vectorial).................................................................................... 12

Cierre de la unidad ................................................................................................................ 16

Fuentes de consulta .............................................................................................................. 16

Computación II



Presentación En la unidad pasada revisamos los temas introductorios en lo que respecta a la minería de datos, particularmente en la revisión de técnicas de análisis exploratorios de datos. Uno de los usos de estas técnicas es la de establecer de alguna manera objetiva que atributos son los más prometedores para dar una explicación de los mismos. En esta unidad revisaremos algunos algoritmos muy populares para el análisis de datos como lo son PCA, k-Medios y SVM. Estos algoritmos son algunos de los más usados y más entendibles pero el área de la inteligencia computacional ha desarrollado muchos otros, un ejemplo cualitativamente distinto son los algoritmos no supervisados, en contraste de los antes mencionados que pertenecen a la clase de algoritmos llamados supervisados, estos conceptos los desarrollaremos dentro de la unidad.

Competencia específica Elegir los diferentes algoritmos y sus particularidades para conformar un modelo que explique lo mejor posible los datos estudiados a partir de diferentes criterios.

Logros

• Conocer distintos algoritmos de aprendizaje computacional y minería de datos

• Identificar las características de los diferentes algoritmos planteados

• Aplicar algún modelo para modelar lo mejor posible a los datos examinados.

Desarrollo de temas Una vez establecido los atributos que sean más prometedores para explicar la naturaleza de los datos debemos usar algún algoritmo para determinar alguna relación en estos datos. Bajo el supuesto de que nuestro conjunto de datos sigue una relación causal, requerimos de algún algoritmo 𝒜 que pueda inferir esta relación causal. Es importante tener en consideración siempre que estos datos pueden estar afectados por una lectura ruidosa por lo que el uso de aspectos probabilísticos es fundamental. En aprendizaje computacional existen dos tipos de algoritmos principalmente, los que son supervisados y los no supervisados. Los supervisados requieren un conjunto de entrenamiento en el que le pasemos un par ordenado (𝑥𝑖 , 𝑦𝑖) de tal forma que 𝑓(𝑥𝑖) = 𝑦𝑖 donde 𝑓 es la relación funcional que describen a nuestros datos. Nuestro algoritmo debe inferir una relación

Computación II



𝑓′. La filosofía de los algoritmos supervisados es que a partir de los ejemplos recabados el algoritmo incorpore esta información para formar 𝑓′. Los algoritmos no supervisados no hacen uso de esta información y su uso suele ser el de encontrar grupos o distribuciones de los datos.

Aprendizaje Supervisado

Aprendizaje No Supervisado

En este tipo de entrenamiento construyen las reglas

para clasificar a partir de una serie de ejemplos

correctos previamente provistos por el usuario.

Esta forma de aprendizaje es fácil ejemplificarla con la

forma que aprendemos diariamente: Cuando le

queremos enseñar algo a un niño usualmente le

ofrecemos alguna serie de ejemplos con los cuales

puede abstraer y generalizar reglas.

Dentro de los algoritmos más populares que son

supervisados está el perceptrón multicapa, el

algoritmo de agrupamiento K-Medios (K-Means), las

máquinas de soporte vectorial (SVM), etcétera.

En este paradigma el algoritmo aprende de un

conjunto de entrenamiento pero no le

especificamos cuáles son los ejemplos válidos,

simplemente dejamos que el algoritmo

deduzca el concepto por sí solo.

Este proceso de aprendizaje usualmente se

basa en otro denominado auto-organización

El algoritmo más popular que hace uso de la

auto-organización para extraer estructura a

partir del conjunto de datos es una red

neuronal llamada Mapeo Autoorganizado

(SOM por sus siglas en inglés).

Otra clasificación importante es la que divide a los algoritmos en las siguientes categorías

Algoritmos de Regresión

Algoritmos de Clasificación

Dentro del aprendizaje computacional es muy común

el tener que hacer regresiones numéricas. Estas son

particularmente útiles para hacer predicciones, el

mejor ejemplo de un algoritmo de regresión numérica

es el Método de los Mínimos Cuadrados.

Otra de las tareas fundamentales en el

aprendizaje computacional es clasificar

conjuntos de datos, para esto se han

desarrollado algoritmos de clasificación muy

sofisticados que toman una serie de datos bajo

algún conjunto de parámetros los dividen en

diferentes conjuntos.

Los algoritmos de aprendizaje computacional tienen una filosofía y funcionamiento general que

va de la siguiente manera.

Computación II



Sea 𝒜 un algoritmo y 𝐸 el conjunto de entrenamiento. Queremos que 𝒜 generalice el concepto

plasmado en las instancias de 𝐸. Para esto debemos entrenar nuestro algoritmo 𝒜 en dos fases,

la de entrenamiento y la de prueba. En caso de que la fase de prueba sea aprobada (por alguna

métrica definida) entonces podemos usar formalmente la generalización hecha por el algoritmo.

Si el algoritmo 𝒜 es de tipo supervisado entonces las instancias de 𝐸 constan de una etiqueta

que marca el resultado que se debería obtener.

No es muy distinto a lo que sucede con el aprendizaje en un humano, primero nos entrenamos

con un conjunto de ejemplos que ejemplifiquen todos los aspectos de la teoría o concepto que

queramos aprender, luego, usualmente, lo ponemos a prueba y finalmente lo usamos de forma

cotidiana siempre y cuando apliquen las premisas de uso.

Es muy importante anotar que hay que ser muy críticos con las características del algoritmo y

que tan generalizable es su utilización dependiendo de las premisas para ser usado, y lo que se

puede interpretar de estos.

En esta sección revisarás algunos de los algoritmos más populares y sencillos para analizar

datos. Uno te permite detectar agrupamientos de datos, otro detectar variables importantes en

un conjunto de datos y el último te permite encontrar reglas que determinan un conjunto de

datos.

K-Medios

Una de las necesidad, sino una de las más principales de la minería de datos, para poder

describir conjuntos de datos es la de agruparlos en clases de equivalencia, esto es, determinar

cuando estamos viendo simplemente diferentes instancias de una clase dada. Por ejemplo

dentro del grupo de K-Means (K-Medios es la traducción más directa pero no es usual

encontrarla en textos técnicos) es un algoritmo supervisado de agrupamiento en el que

requerimos dividir nuestro conjunto de datos en k grupos separados. Este es un algoritmo

extremadamente popular debido a su simpleza y su idea en extremo intuitiva. Es importante

que cuando decimos que es un algoritmo supervisado es por qué cada instancia que pasemos

en el conjunto de entrenamiento ya tiene una clasificación hecha.

Su funcionamiento es de la siguiente forma:

Computación II



Algoritmo

1. Sea 𝑋 un conjunto de 𝑛 datos de dimensión 𝑚 Es decir, 𝑋 son los datos con los que vas a

trabajar y de los cuales se quiere determinar los diferentes grupos que pueden estar

contenidos y 𝑚 es la cantidad de atributos que describe a cada dato.

2. Se construye 𝐶 como un conjunto de números enteros, con una distribución aleatoria

que representa la cantidad de clusters en los que se desea dividir dicho conjunto y cada

elemento 𝑐 ∈ 𝐶 se denomina centroide y va a funcionar como el representante de clase

de cada cluster.

𝐶 = {𝜇|𝜇 ∈ 𝑅𝑚} ; #𝐶 = 𝑘

3. Se construye 𝑘 listas vacías, cada una representante de los k centroides. En estas listas

se almacenan los datos representados por cada centroide.

𝑆1, 𝑆2, … , 𝑆𝑘 𝑡. 𝑞. 𝑆𝑖 ← []

4. Para cada elemento 𝑥𝑗 ∈ 𝑋 (es decir para cada dato) mides su distancia euclidiana a cada

centroide 𝜇𝑖 y nos queda c la distancia ganadora (el que tenga distancia mínima) para

determinar el centroide que mejor lo representa. Una vez hecho esto se guarda a 𝑥𝑗 en

el conjunto asignado a dicho centroide.

5. Una vez que se haya hecho esto para todos los datos vuelves a calcular los centroides

de cada conjunto 𝑆𝑖 promediando sobre todos los datos guardados en el conjunto 𝑆𝑖

𝜇𝑖 =1

|𝑆𝑖| ∑ 𝑥𝑗

𝑥𝑗∈𝑆𝑖

6. Se repite el paso 4 hasta que lleguemos a una solución estable. Es decir que los

centroides no cambien.

7. Regresamos como resultado el conjunto de diferentes centroides.

En las siguientes figuras puedes ver una representación gráfica de este algoritmo. En la figura 1

puedes ver una serie de puntos ya clasificados por su color, estos fueron generados con una

distribución normal con media 0 y desviación estándar 1, después fueron reubicados en

diferentes posiciones en el plano dependiendo de su color. Los rojos están dispersados

alrededor del punto (-0.5,-2.0), los puntos azules están dispersados alrededor del (-1,0.5) y los

puntos verdes están dispersados alrededor del (0.5, -4.0). Esperamos entonces que el algoritmo

Computación II



encuentre como centroides estos puntos. En la figura 2 puedes ver 4 iteraciones de cómo

evoluciona el algoritmo, los triángulos representan a los centroides de cada conjunto de puntos

conforme se van encontrando y actualizando.

Figura 1. Datos aleatorios coloreados artificialmente para mostrar los tres grupos representados.

Figura 2. K-Medios aplicado a nuestro ejemplo sintético, los centroides se pueden ver como los triángulos.

El ejemplo recién visto sólo es una aplicación ilustrativa de lo que haría k-Means sobre un conjunto de datos aleatorio, es decir, encontraría los centros de cada categoría en el conjunto de datos, en este caso, los rojos, azules y verdes.

Un ejemplo más representativo es aplicarlo a un conjunto de datos muy común para probar algoritmos distintos, este es el conjunto de datos de Iris que puedes consultar en (Iris, 2015). Lo que vamos a hacer es detectar los grupos que puede tener este conjunto de datos. Brevemente, este conjunto de datos clasifica 150 instancias de tres variedades de una planta llamada iris y lo que vamos a hacer con k-Medios es detectar esos tres grupos, contrastándolo con 8 grupos. La filosofía de k-Medios es proponer una cantidad de centroides en nuestros datos para luego iterar el algoritmo hasta que el centroide converja a lo que esperamos sea el centro de la clase.

Computación II



Figura 3. Iris con 3 centroides propuestos

Figura 4. Iris con 8 centroides propuestos.

En las figuras 3 y 4 puedes observar este conjunto de datos con 3 y 8 centroides propuestos. Esta implementación está hecha con Python y Scikit y la puedes ver a continuación.

# -*- coding:utf8 -*-

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

from sklearn.cluster import KMeans

from sklearn import datasets

np.random.seed(5)

centroides = [[1, 1], [-1, -1], [1, -1]]

iris = datasets.load_iris()

X = iris.data

y = iris.target

estimadores = {'k_means_iris_3': KMeans(n_clusters=3),

'k_means_iris_8': KMeans(n_clusters=8),

'k_means_iris_bad_init': KMeans(n_clusters=3, n_init=1,

init='random')}

num = 1

for nombre_estimador, est in estimatores.items():

fig = plt.figure(num, figsize=(4, 3))

plt.clf()

ax = Axes3D(fig, rect=[0, 0, .95, 1], elev=48, azim=134)

plt.cla()

est.fit(X) #Scikit entrena en este paso el algoritmo.

Computación II



centroides=str(est.n_clusters)

labels = est.labels_

ax.scatter(X[:, 3], X[:, 0], X[:, 2], c=labels.astype(np.float))

ax.w_xaxis.set_ticklabels([])

ax.w_yaxis.set_ticklabels([])

ax.w_zaxis.set_ticklabels([])

ax.set_xlabel(u'Ancho de pétalo')

ax.set_ylabel(u'Ancho de sépalo')

ax.set_zlabel(u'Largo de pétalo')

ax.set_title('Centroides :'+centroides)

num = num + 1

plt.show()

La forma en que utilizamos este algoritmo es entrenándolo con las instancias del conjunto de entrenamiento y después, una vez que el algoritmo converge a centroides definidos lo que hacemos es preguntar, para algún punto nuevo 𝑥, qué centroide tiene más cercano, aquel que resulte más cerca de nuestro dato será la clase a la que 𝑥 pertenece.

Pero bajo qué criterio se acepta un agrupamiento u otro, es decir, si este particular algoritmo

únicamente requiere de que se defina la cantidad de clusters en los que vas a dividir el grupo

entonces ¿cómo podemos determinar si el agrupamiento fue bueno o no?

Para determinar si un agrupamiento es bueno, existen varias métricas, de entre ellas se usará la

pureza del agrupamiento como medida. Esta medida requiere hacer uso de la clase en la que

están clasificados los elementos del conjunto de entrenamiento por la cual se contarán la

mayoría de las clases

𝑝𝑢𝑟𝑒𝑧𝑎(Ω, 𝐶) =1

𝑁∑ max

𝑗|𝜔𝑘⋂𝑐𝑗|

𝑘

Esta medida lo que hace es contar las clases correctamente asignadas en cada grupo de datos

arrojando un índice que indica que tan bueno fue el agrupamiento. Si el índice de pureza está

muy cercano a 0 entonces el agrupamiento no fue tan bueno, y si está cercano a 1 entonces fue

bastante bueno.

Existen heurísticas para determinar cuántos grupos se pueden formar considerando 𝑁 puntos,

la regla usual que se sigue es la de

𝑘 ≈ √𝑁

2

Computación II



Otro método es ir generando los grupos iterativamente e ir generando el índice de pureza

mientras vaya aumentando este índice, el punto de inflexión en esa curva determinará la

cantidad de grupos a generar.

Existen otros algoritmos usados para generar agrupamientos, uno que resuelve estos aspectos

de forma automática es el Mapeo Auto-organizado, qué es una red neuronal no supervisada en

la que los elementos se agrupan automáticamente.

La forma en la que se usan este algoritmo una vez entrenado es que el estímulo de entrada se

mide con cada centroide y se le asigna la etiqueta de cuyo centroide haya quedado más cercano

según la métrica ocupada para generar los grupos.

PCA (Análisis por componentes principales)

Un método extremadamente popular en el análisis de datos es el análisis en componentes principales. Este, junto con SVD (que veremos muy brevemente) son numéricos sobre matrices que lo que hacen ofrecer una rotación de los datos en componente linealmente independientes.

PCA así como SVD también son métodos estadísticos y lo que hacen es obtener una rotación de los datos en componente linealmente independientes donde la varianza de los datos vaya disminuyendo. Es decir, presentaremos la variable que mayor varianza tenga de nuestros datos, seguido de la segunda componente con mayor varianza y así hasta la última y todas estas varianzas estarán multiplicadas por los eigenvectores en los que se encuentren descritos nuestros datos.

La forma en la que se calculan ambos métodos es ligeramente diferente, de hecho, en muchas implementaciones primero se calcula SVD y a partir de lo que se obtiene con este resultado se computa PCA. La forma canónica de calcular PCA es la siguiente.

1. Nuestra entrada será una matríz de datos 𝐷𝑚×𝑛. Es decir tiene 𝑚 instancias que son vectores en ℝ𝑛.

2. Centramos nuestros datos quitándole la media a cada atributo, obteniendo 𝐷′

3. Calculamos la matriz de covarianza de 𝐷′ de tal forma que obtenemos la matriz de covarianza

Σ = 𝑐𝑜𝑣(𝐷′)

Computación II



4. Calculamos los eigenvectores de Σ de tal forma que 𝑒𝑖𝑔(Σ) = {Σ1, Σ2, … , Σ𝑛} para agruparlos de mayor a menor, este orden estará dado por el i-ésimo eigenvalor de cada eigenvector.

𝑈 = {𝑢1, 𝑢2, … , 𝑢𝑛}

Esta matriz es ortogonal, entonces satisface

𝑈𝑇𝑈 = 𝑈𝑈𝑇 = 𝐼

Por lo que nuestros vectores originales 𝑥 ∈ 𝐷 los podemos obtener de vuelta con la siguiente operación

𝑥 = 𝑈𝑥′

Uno de los usos más comunes de PCA es la reducción de dimensiones ya que se puede determinar cuantos eigenvectores son necesarios para calcular cierto porcentaje de la varianza y de esa manera, cuando el umbral de varianza sea rebasado entonces usamos la cantidad de eigenvectores que conforman esa varianza. A continuación podemos ver esto en nuestro ejemplo de iris.

El código en Python para implementar PCA es el siguiente

from numpy import dot, cov

import numpy.linalg as la

def pca(datos, dimens=2):

m, n = datos.shape

D = datos[:]; D -= datos.mean(axis=0)

R = cov(D, rowvar=False)

evals, evecs = la.eigh(R)

idx = argsort(evals)[::-1]

evecs = evecs[:,idx]

evals = evals[idx]

evecs = evecs[:, :dimens]

return dot(evecs.T, D.T).T, evals, evecs

Este código hace uso de las funciones cov, argsort y dot, así como el paquete lingal que viene dentro de numpy. Lo que regresa son los vectores de datos rotados así como los

eigenvectores y los eigenvalores. Usándolo para reexpresar el conjunto de datos iris tenemos que hacer lo siguiente.

M = loadtxt('iris.data',delimiter=',')

N,_,_ = pca(M, 2)

plt.scatter(N[:,0],N[:,1], c=M[:,4])

plt.title('PCA para Iris con dos componentes')

plt.xlabel('Componente 1')

plt.ylabel('Componente 2')

Computación II



plt.show()

La figura que obtenemos es la siguiente

Figura 5. Datos rotados con iris

En la figura 5 podemos ver que sólo se requieren dos variables para poder separar nuestro

conjunto de datos de iris y no cuatro que son los atributos originales de los datos.

SVM (Maquinas de soporte vectorial)

Una de los algoritmos más populares para hacer clasificación supervisada son las máquinas de

soporte vectorial. Lo que este algoritmo va a buscar es la separación óptima entre dos conjuntos

de datos (en el caso más sencillo).

Este algoritmo lo que va a hacer es buscar dentro de todo el conjunto de puntos la separación

óptima de forma tal que encontremos el margen que mejor separa nuestras instancias del

conjunto de entrenamiento. La búsqueda de este margen es el núcleo del algoritmo como se

puede ver en la figura 6.

Considerando que nuestros ejemplos están descritos en el mapeo

𝒳 ↦ 𝒴

Donde 𝑥𝑖 ∈ 𝒳 y 𝑦𝑖 ∈ 𝒴 el margen que buscamos es

𝛾𝑖 = 𝑦𝑖(𝑤𝑇𝑥 + 𝑏)

Computación II



Como 𝑦𝑖 ∈ {−1,1} (usualmente) entonces deseamos que nuestro clasificador 𝑦𝑖(𝑤𝑇𝑥 + 𝑏) > 0

en caso de que el ejemplo haya sido clasificado correctamente. Como nuestro clasificador es

lineal podemos sustituir 𝑤 → 2𝑤 y 𝑏 → 2𝑏. Esto resulta particularmente útil y es la base de la

eficiencia de SVM ya que sólo buscamos que la clasificación sea positiva o negativa entonces

aumentar el margen entre los datos puede ayudar para clasificarlos más fácilmente. Entonces lo

que buscamos es

𝛾 = min𝑖=1…𝑚

𝛾𝑖

La distancia de un punto a una de estas recta se representa por 𝑥𝑖 − 𝛾𝑖 ∙𝑤

‖𝑤‖, como un punto

que cumpla esto está sobre nuestro margen de decisión entonces se cumple que

𝑤𝑇 (𝑥𝑖 − 𝑦𝑖 ∙𝑤

‖𝑤‖) + 𝑏 = 0

Al resolver para 𝛾𝑖

𝛾𝑖 =𝑤𝑇𝑥𝑖 + 𝑏

‖𝑤‖= (

𝑤

‖𝑤‖)

𝑇

𝑥𝑖 +𝑏

‖𝑤‖

Como este caso sólo es para los puntos sobre el margen de decisión podemos extender nuestra

definición de margen funcional al siguiente caso

𝛾𝑖 = 𝑦𝑖 ((𝑤

‖𝑤‖)

𝑇

𝑥𝑖 +𝑏

‖𝑤‖)

Todo esto pasa después a un proceso de optimización para poder encontrar el mejor de estos

márgenes. Un desarrollo más claro lo puedes encontrar en

Computación II



Figura 6. Máquinas de soporte vectorial.

Para nuestro conjunto de datos podemos usar scikit para hacer la clasificación dentro del

conjunto iris.

Figura 7. Separación de iris usando SVM

Computación II



Nuestro código usando Scikit es

# -*- coding: cp1252 -*-

import numpy as np

import matplotlib.pyplot as plt

from sklearn import svm, datasets

iris = datasets.load_iris()

X = iris.data[:, :2]

y = iris.target

#parámetro de regularización

C = 1.0

svc = svm.SVC(kernel='linear', C=C).fit(X, y)

rbf_svc = svm.SVC(kernel='rbf', gamma=0.7, C=C).fit(X, y)

poly_svc = svm.SVC(kernel='poly', degree=3, C=C).fit(X, y)

lin_svc = svm.LinearSVC(C=C).fit(X, y)

#graficado

h = .02

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1

y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1

xx, yy = np.meshgrid(np.arange(x_min, x_max, h),

np.arange(y_min, y_max, h))

titulos = ['SVC - kernel lineal',

'LinearSVC lineal',

'SVC kernel RBF',

u'SVC kernel cúbico']

for i, clf in enumerate((svc, lin_svc, rbf_svc, poly_svc)):

plt.subplot(2, 2, i + 1)

plt.subplots_adjust(wspace=0.4, hspace=0.4)

Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])

Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, cmap=plt.cm.Paired, alpha=0.8)

plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired)

plt.xlabel('Sepal length')

plt.ylabel('Sepal width')

Computación II



plt.xlim(xx.min(), xx.max())

plt.ylim(yy.min(), yy.max())

plt.xticks(())

plt.yticks(())

plt.title(titulos[i])

plt.show()

Cierre de la unidad

En esta unidad hemos revisado la minería de datos más popular para almacenar, manejar y

consultar datos y conformar bases de datos óptimas. Revisaste una introducción al lenguaje de

programación más popular actualmente para dicho fin, el lenguaje SQL bajo su implementación

MySQL.

Fuentes de consulta

• Witten, I. H. (2005). Data Mining: Practical machine learning tools and techniques.

Morgan Kaufmann.

• Iris flor conjunto de datos. (2015, 28 de noviembre). Wikipedia, La enciclopedia libre.

Desde:

https://es.wikipedia.org/w/index.php?title=Iris_flor_conjunto_de_datos&oldid=873662

78.

• K Means (2013). Stanford. Stanford CS221. Desde http://stanford.edu/~cpiech/cs221/handouts/kmeans.html



http://stanford.edu/~cpiech/cs221/handouts/kmeans.html

Computación II



• UFLDL Tutorial. Desde http://ufldl.stanford.edu/wiki/index.php/UFLDL_Tutorial

• MIT OpenCourseWare. 16. Learning: Support Vector Machines. . Desde https://www.youtube.com/watch?v=_PwhiWxHK8o

• Ng, A., Support Vector Machines en CS229 Lecture Notes.

http://ufldl.stanford.edu/wiki/index.php/UFLDL_Tutorial

https://www.youtube.com/watch?v=_PwhiWxHK8o

6º Semestre - Universidad Abierta y a Distancia de México

Documents

Transcript of 6º Semestre - Universidad Abierta y a Distancia de México