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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 3
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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 4
𝑓′. 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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 5
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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 6
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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 7
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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 8
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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 9
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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 10
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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 11
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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 12
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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 13
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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 14
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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 15
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
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 16
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
Computación II
Unidad 2. Minería de datos
UnADM | DCEIT | MT | MCOM2 17
• 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.
Top Related