# data[].attributes.headline
Ejemplo de Aplicacion de Algoritmos No Supervisados

# data[].attributes.subject
Ejemplo de Aplicacion de Algoritmos No Supervisados

# data[].attributes.body
Un ejemplo es la construccion de Sistemas de Recomendacion. Son esos sitemas que le recomiendan cosas al Usuario segun sus preferencias.

Los sistemas de recomendacion pueden ser:
*Por contenido: Recomienda segun productos similares que le gustan al usuario
*Colaborativo: Recomienda en base a loque otros usuarios similares les gusta

https://www.kaggle.com/code/basu369victor/recommender-system-using-un-supervised-learning/notebook

# data[].attributes.headline
Isolation Forest o Detección de Anomalías // Sala 4

# data[].attributes.subject
Isolation Forest o Detección de Anomalías // Sala 4

# data[].attributes.body
Isolation Forest es un método utilizado para la detección de anomalías fuero de los valores normales del dataset o dataframe.
Dicho método presenta una manera diferente para  aislar explícitamente las anomalías utilizando árboles binarios, lo que demuestra una nueva posibilidad de un detector de anomalías más rápido que apunta directamente a las anomalías sin perfilar todas las instancias normales.

En cuanto a las ventajas y aplicaciones, lo mismo habilita la posibilidad de detectar anomalías dentro de dataset de gran tamaño, lo cual resulta dificultoso de manera visual, consumiendo así, menor cantidad de memoria.

Por ejemplo, en el siguiente enlace es posible encontrar un modelo diseña para la detección de anomalías dentro de valores aleatorias. Si bien el mismo se basa en un dataset pequeño, este presenta de manera gráfica y simple los casos en los que se podría utilizar este tipo de métodología.

Link al Dataset:
https://scikit-learn.org/stable/auto_examples/ensemble/plot_isolation_forest.html

# data[].attributes.attachment_link.readable_text
Isolation forest is an anomaly detection algorithm. It detects anomalies using isolation (how far a data point is to the rest of the data), rather than modelling the normal points. In 2007, it was initially developed by Fei Tony Liu as one of the original ideas in his PhD study. The significance of this research lies in its deviation from the mainstream philosophy underpinning most existing anomaly detectors at the time, where all the normal instances are profiled before anomalies are identified as instances that do not conform to the distribution of the normal instances. Isolation forest introduces a different method that explicitly isolates anomalies using binary trees, demonstrating a new possibility of a faster anomaly detector that directly targets anomalies without profiling all the normal instances. The algorithm has a linear time complexity with a low constant and a low memory requirement, which works well with high volume data.

In statistics, an anomaly (a.k.a. outlier) is an observation or event that deviates so much from other events to arouse suspicion it was generated by a different means. For example, the graph in Fig.1 represents ingress traffic to a web server, expressed as the number of requests in 3-hour intervals, for a period of one month. It is quite evident by simply looking at the picture that some points (marked with a red circle) are unusually high, to the point of inducing suspect that the web server might have been under attack at that time. On the other hand, the flat segment indicated by the red arrow also seems unusual and might possibly be a sign that the server was down during that time period.

Anomalies in a big dataset may follow very complicated patterns, which are difficult to detect visually in the great majority of cases. This is the reason why the field of anomaly detection is well suited for the application of Machine Learning techniques.

The most common techniques employed for anomaly detection are based on the construction of a profile of what is "normal": anomalies are reported as those instances in the dataset that do not conform to the normal profile. Isolation Forest uses a different approach: instead of trying to build a model of normal instances, it explicitly isolates anomalous points in the dataset. The main advantage of this approach is the possibility of exploiting sampling techniques to an extent that is not allowed to the profile-based methods, creating a very fast algorithm with a low memory demand.

The Isolation Forest (iForest) algorithm was initially proposed by Fei Tony Liu, Kai Ming Ting and Zhi-Hua Zhou in 2008. The authors took advantage of two quantitative properties of anomalous data points in a sample:

1. Few - they are the minority consisting of fewer instances and

2. Different - they have attribute-values that are very different from those of normal instances

Since anomalies are "few and different", they are easier to "isolate" compared to normal points. Isolation Forest builds an ensemble of "Isolation Trees" (iTrees) for the data set, and anomalies are the points that have shorter average path lengths on the iTrees.

In 2010, an extension of the algorithm - SCiforest was published to address the issues of clustered anomalies and utilize random hyperplanes to enhance the algorithm ability to detect axis-paralleled anomalies. These abilities are lacking in the original implementation.

In a later paper, published in 2012 the same authors described a set of experiments to prove that iForest:

has a low linear time complexity and a small memory requirement

is able to deal with high dimensional data with irrelevant attributes

can be trained with or without anomalies in the training set

can provide detection results with different levels of granularity without re-training

In 2013 Zhiguo Ding and Minrui Fei proposed a framework based on iForest to resolve the problem of detecting anomalies in streaming data. More application of iForest to streaming data are described in papers by Tan et al., Susto et al. and Weng et al.

One of the main problems of the application of iForest to anomaly detection was not with the model itself, but rather in the way the "anomaly score" was computed. This problem was highlighted in a 2018 paper, wherein an improved iForest model named Extended Isolation Forest (EIF) was proposed. The paper describes the improvements made to the original model iForest and how they are able to enhance the consistency and reliability of the anomaly score produced for a given data point. It is not sure if the random slope enhancement proposed in EIF is novel, as a similar construct "random hyperplane" was proposed in SCiForest in 2010, which mitigates the same axis-parallel bias in iForest.

At the basis of the Isolation Forest algorithm, there is the tendency of anomalous instances in a dataset to be easier to separate from the rest of the sample (isolate), compared to normal points. In order to isolate a data point, the algorithm recursively generates partitions on the sample by randomly selecting an attribute and then randomly selecting a split value for the attribute, between the minimum and maximum values allowed for that attribute.

An example of random partitioning in a 2D dataset of normally distributed points is given in Fig. 2 for a non-anomalous point and Fig. 3 for a point that's more likely to be an anomaly. It is apparent from the pictures how anomalies require fewer random partitions to be isolated, compared to normal points.

From a mathematical point of view, recursive partitioning can be represented by a tree structure named Isolation Tree, while the number of partitions required to isolate a point can be interpreted as the length of the path, within the tree, to reach a terminating node starting from the root. For example, the path length of point in Fig. 2 is greater than the path length of in Fig. 3.

More formally, let be a set of d-dimensional points and . An Isolation Tree (iTree) is defined as a data structure with the following properties:

1. for each node in the Tree, is either an external-node with no child, or an internal-node with one "test" and exactly two daughter nodes ( and )

2. a test at node consists of an attribute and a split value such that the test determines the traversal of a data point to either or .

In order to build an iTree, the algorithm recursively divides by randomly selecting an attribute and a split value , until either

1. the node has only one instance, or

2. all data at the node have the same values.

When the iTree is fully grown, each point in is isolated at one of the external nodes. Intuitively, the anomalous points are those (easier to isolate, hence) with the smaller path length in the tree, where the path length of point is defined as the number of edges traverses from the root node to get to an external node.

A probabilistic explanation of iTree is provided in the iForest original paper.

Sub-sampling: since iForest does not need to isolate all of normal instances, it can frequently ignore the big majority of the training sample. As a consequence, iForest works very well when the sampling size is kept small, a property that is in contrast with the great majority of existing methods, where large sampling size is usually desirable.[1][2]

Swamping: when normal instances are too close to anomalies, the number of partitions required to separate anomalies increases, a phenomenon known as swamping, which makes it more difficult for iForest to discriminate between anomalies and normal points. One of the main reasons for swamping is the presence of too much data for the purpose of anomaly detection, which implies one possible solution to the problem is sub-sampling. Since iForest respond very well to sub-sampling in terms of performance, the reduction of the number of points in the sample is also a good way to reduce the effect of swamping.[1]

Masking: when the number of anomalies is high it is possible that some of those aggregate in a dense and large cluster, making it more difficult to separate the single anomalies and, in turn, to detect such points as anomalous. Similarly to swamping, this phenomenon (known as "masking") is also more likely when the number of points in the sample is big, and can be alleviated through sub-sampling.[1]

High Dimensional Data: one of the main limitation to standard, distance-based methods is their inefficiency in dealing with high dimensional datasets:.[10] The main reason for that is, in a high dimensional space every point is equally sparse, so using a distance-based measure of separation is pretty ineffective. Unfortunately, high-dimensional data also affects the detection performance of iForest, but the performance can be vastly improved by adding a features selection test like Kurtosis to reduce the dimensionality of the sample space.[1][5]

Normal Instances Only: iForest performs well even if the training set does not contain any anomalous point,[5] the reason being that iForest describes data distributions in such a way that high values of the path length correspond to the presence of data points. As a consequence, the presence of anomalies is pretty irrelevant to iForest's detection performance.

Anomaly detection with Isolation Forest is a process composed of two main stages:

1. in the first stage, a training dataset is used to build iTrees as described in previous sections.

2. in the second stage, each instance in the test set is passed through the iTrees build in the previous stage, and a proper "anomaly score" is assigned to the instance using the algorithm described below

Once all the instances in the test set have been assigned an anomaly score, it is possible to mark as "anomaly" any point whose score is greater than a predefined threshold, which depends on the domain the analysis is being applied to.

Anomaly score

The algorithm for computing the anomaly score of a data point is based on the observation that the structure of iTrees is equivalent to that of Binary Search Trees (BST): a termination to an external node of the iTree corresponds to an unsuccessful search in the BST.[5] As a consequence, the estimation of average for external node terminations is the same as that of the unsuccessful searches in BST, that is[11]

where is the testing data size, is the size of the sample set and is the harmonic number, which can be estimated by , where is the Euler-Mascheroni constant.

The value of c(m) above represents the average of given , so we can use it to normalise and get an estimation of the anomaly score for a given instance x:

where is the average value of from a collection of iTrees. It is interesting to note that for any given instance :

if is close to then is very likely to be an anomaly

if is smaller than then is likely to be a normal value

if for a given sample all instances are assigned an anomaly score of around , then it is safe to assume that the sample doesn't have any anomaly

Original implementation:

Isolation Forest, an algorithm that detects data-anomalies using binary trees written in R. Released by the paper's first author Liu, Fei Tony in 2009.

Other implementations (in alphabetical order):

# data[].attributes.attachment_link.description
Isolation forest is an anomaly detection algorithm. It detects anomalies using isolation (how far a data point is to the rest of the data), rather than modelling the normal points. In 2007, it was initially developed by Fei Tony Liu as one of the original ideas in his PhD study.

# data[].attributes.body
El clustering consiste en la agrupación automática de datos. Es un tipo de aprendizaje automático no-supervisado. En castellano se denomina agrupamiento. Vamos a ver en más detalle en qué consiste el clustering, el algoritmo de agrupamiento más popular: K-Means y algunos ejemplos en python.

Por ejemplo, se puede utilizar para detectar las posiciones de ciertos jugadores dentro de la cancha.
La idea de este ejercicio es agrupar (clustering) en cuatro grupos (cluster) a los jugadores en función de sus características de juego (portero, defensa, central, delantero). El objetivo será ver si las diferentes agrupaciones que el algoritmo detecta son coherentes con las dinámicas del fútbol.

K-means es un algoritmo de clasificación no supervisada (clusterización) que agrupa objetos en k grupos basándose en sus características. El agrupamiento se realiza minimizando la suma de distancias entre cada objeto y el centroide de su grupo o cluster. Se suele usar la distancia cuadrática.

Lo importante en este caso es detectar la cantidad de K o grupos. Para ello existen dos métodos. Elbow o Sulhuette.

Método del codo (Elbow Method)

Este método utiliza los valores de la inercia obtenidos tras aplicar el K-means a diferente número de Clusters (desde 1 a N Clusters), siendo la inercia la suma de las distancias al cuadrado de cada objeto del Cluster a su centroide:

# data[].attributes.body
K-Means con Python paso a paso | Aprende Machine Learning

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sb

from sklearn.cluster import KMeans

from sklearn.metrics import pairwise_distances_argmin_min

%matplotlib inline

from mpl_toolkits.mplot3d import Axes3D

plt.rcParams['figure.figsize'] = (16, 9)

plt.style.use('ggplot')

dataframe = pd.read_csv(r"analisis.csv")

dataframe.head()

dataframe.describe()

print(dataframe.groupby('categoria').size())

dataframe.drop(['categoria'],1).hist()

sb.pairplot(dataframe.dropna(), hue='categoria',size=4,vars=["op","ex","ag"],kind='scatter')

plt.show()

23 | X = np.array(dataframe[["op","ex","ag"]])y = np.array(dataframe['categoria'])X.shape

fig = plt.figure()

ax = Axes3D(fig)

colores=['blue','red','green','blue','cyan','yellow','orange','black','pink','brown','purple']

asignar=[]

for row in y:

asignar.append(colores[row])

ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=asignar,s=60)

Nc = range(1, 20)

kmeans = [KMeans(n_clusters=i) for i in Nc]

kmeans

score = [kmeans[i].fit(X).score(X) for i in range(len(kmeans))]

score

plt.plot(Nc,score)

plt.xlabel('Number of Clusters')

plt.ylabel('Score')

plt.title('Elbow Curve')

plt.show()

kmeans = KMeans(n_clusters=5).fit(X)

centroids = kmeans.cluster_centers_

print(centroids)

# Getting the values and plotting it

Python

1234567 | # Getting the values and plotting itf1 = dataframe['op'].valuesf2 = dataframe['ag'].values plt.scatter(f1, f2, c=asignar, s=70)plt.scatter(C[:, 0], C[:, 2], marker='*', c=colores, s=1000)plt.show()

f1 = dataframe['op'].values

f2 = dataframe['ex'].values

plt.scatter(f1, f2, c=asignar, s=70)

plt.scatter(C[:, 0], C[:, 1], marker='*', c=colores, s=1000)

plt.show()

Python

12345678910111213 | # Predicting the clusterslabels = kmeans.predict(X)# Getting the cluster centersC = kmeans.cluster_centers_colores=['red','green','blue','cyan','yellow']asignar=[]for row in labels:    asignar.append(colores[row]) fig = plt.figure()ax = Axes3D(fig)ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=asignar,s=60)ax.scatter(C[:, 0], C[:, 1], C[:, 2], marker='*', c=colores, s=1000)

23456 | f1 = dataframe['ex'].valuesf2 = dataframe['ag'].values plt.scatter(f1, f2, c=asignar, s=70)plt.scatter(C[:, 1], C[:, 2], marker='*', c=colores, s=1000)plt.show()

Python

12345678 | copy =  pd.DataFrame()copy['usuario']=dataframe['usuario'].valuescopy['categoria']=dataframe['categoria'].valuescopy['label'] = labels;cantidadGrupo =  pd.DataFrame()cantidadGrupo['color']=colorescantidadGrupo['cantidad']=copy.groupby('label').size()cantidadGrupo

Python

1234567 | group_referrer_index = copy['label'] ==0group_referrals = copy[group_referrer_index] diversidadGrupo =  pd.DataFrame()diversidadGrupo['categoria']=[0,1,2,3,4,5,6,7,8,9]diversidadGrupo['cantidad']=group_referrals.groupby('categoria').size()diversidadGrupo

#vemos el representante del grupo, el usuario cercano a su centroid

closest, _ = pairwise_distances_argmin_min(kmeans.cluster_centers_, X)

closest

users=dataframe['usuario'].values

for row in closest:

print(users[row])

Python

1234 | X_new = np.array([[45.92,57.74,15.66]]) #davidguetta new_labels = kmeans.predict(X_new)print(new_labels)

# data[].attributes.attachment_link.readable_text
K-Means es un algoritmo no supervisado de Clustering. Se utiliza cuando tenemos un montón de datos sin etiquetar. El objetivo de este algoritmo es el de encontrar "K" grupos (clusters) entre los datos crudos. En este artículo repasaremos sus conceptos básicos y veremos un ejemplo paso a paso en python que podemos descargar.

Cómo funciona K-Means

El algoritmo trabaja iterativamente para asignar a cada "punto" (las filas de nuestro conjunto de entrada forman una coordenada) uno de los "K" grupos basado en sus características. Son agrupados en base a la similitud de sus features (las columnas). Como resultado de ejecutar el algoritmo tendremos:

Los "centroids" de cada grupo que serán unas "coordenadas" de cada uno de los K conjuntos que se utilizarán para poder etiquetar nuevas muestras.

Etiquetas para el conjunto de datos de entrenamiento. Cada etiqueta perteneciente a uno de los K grupos formados.

Los grupos se van definiendo de manera "orgánica", es decir que se va ajustando su posición en cada iteración del proceso, hasta que converge el algoritmo. Una vez hallados los centroids deberemos analizarlos para ver cuales son sus características únicas, frente a la de los otros grupos. Estos grupos son las etiquetas que genera el algoritmo.

Casos de Uso de K-Means

El algoritmo de Clustering K-means es uno de los más usados para encontrar grupos ocultos, o sospechados en teoría sobre un conjunto de datos no etiquetado. Esto puede servir para confirmar -o desterrar- alguna teoría que teníamos asumida de nuestros datos. Y también puede ayudarnos a descubrir relaciones asombrosas entre conjuntos de datos, que de manera manual, no hubiéramos reconocido. Una vez que el algoritmo ha ejecutado y obtenido las etiquetas, será fácil clasificar nuevos valores o muestras entre los grupos obtenidos.

Algunos casos de uso son:

Segmentación por Comportamiento: relacionar el carrito de compras de un usuario, sus tiempos de acción e información del perfil.

Categorización de Inventario: agrupar productos por actividad en sus ventas

Detectar anomalías o actividades sospechosas: según el comportamiento en una web reconocer un troll -o un bot- de un usuario normal

Aquí se listan las aplicaciones más frecuentes en Machine Learning

Datos de Entrada para K-Means

Las "features" o características que utilizaremos como entradas para aplicar el algoritmo k-means deberán ser de valores numéricos, continuos en lo posible. En caso de valores categóricos (por ej. Hombre/Mujer o Ciencia Ficción, Terror, Novela,etc) se puede intentar pasarlo a valor numérico, pero no es recomendable pues no hay una "distancia real" -como en el caso de géneros de película o libros-. Además es recomendable que los valores utilizados estén normalizados, manteniendo una misma escala. En algunos casos también funcionan mejor datos porcentuales en vez de absolutos. No conviene utilizar features que estén correlacionados o que sean escalares de otros. Recordar los 7 pasos para el Aprendizaje Automático.

El Algoritmo K-means

El algoritmo utiliza una proceso iterativo en el que se van ajustando los grupos para producir el resultado final. Para ejecutar el algoritmo deberemos pasar como entrada el conjunto de datos y un valor de K. El conjunto de datos serán las características o features para cada punto. Las posiciones iniciales de los K centroids serán asignadas de manera aleatoria de cualquier punto del conjunto de datos de entrada. Luego se itera en dos pasos:

1- Paso de Asignación de datos

En este paso, cada "fila" de nuestro conjunto de datos se asigna al centroide más cercano basado en la distancia cuadrada Euclideana. Se utiliza la siguiente fórmula (donde dist() es la distancia Euclideana standard):

2-Paso de actualización de Centroid

En este paso los centroid de cada grupo son recalculados. Esto se hace tomando una media de todos los puntos asignados en el paso anterior.

El algoritmo itera entre estos pasos hasta cumplir un criterio de detención:
* si no hay cambios en los puntos asignados a los grupos,
* o si la suma de las distancias se minimiza,
* o se alcanza un número máximo de iteraciones.

El algoritmo converge a un resultado que puede ser el óptimo local, por lo que será conveniente volver a ejecutar más de una vez con puntos iniciales aleatorios para confirmar si hay una salida mejor. Recuerden siempre seguir los 7 pasos para construir IA

Elegir el valor de K

Este algoritmo funciona pre-seleccionando un valor de K. Para encontrar el número de clusters en los datos, deberemos ejecutar el algoritmo para un rango de valores K, ver los resultados y comparar características de los grupos obtenidos. En general no hay un modo exacto de determinar el valor K, pero se puede estimar con aceptable precisión siguiendo la siguiente técnica:

Una de las métricas usada para comparar resultados es la distancia media entre los puntos de datos y su centroid. Como el valor de la media diminuirá a medida de aumentemos el valor de K, deberemos utilizar la distancia media al centroide en función de K y entontrar el "punto codo", donde la tasa de descenso se "afila". Aquí vemos una gráfica a modo de ejemplo:

Un ejemplo K-Means en Python con Sklearn

Como ejemplo utilizaremos de entradas un conjunto de datos que obtuve de un proyecto propio, en el que se analizaban rasgos de la personalidad de usuarios de Twitter. He filtrado a 140 "famosos" del mundo en diferentes areas: deporte, cantantes, actores, etc. Basado en una metodología de psicología conocida como "Ocean: The Big Five" tendemos como características de entrada:

usuario (el nombre en Twitter)

"op" = Openness to experience - grado de apertura mental a nuevas experiencias, curiosidad, arte

"co" =Conscientiousness - grado de orden, prolijidad, organización

"ex" = Extraversion - grado de timidez, solitario o participación ante el grupo social

"ag" = Agreeableness - grado de empatía con los demás, temperamento

"ne" = Neuroticism, - grado de neuroticismo, nervioso, irritabilidad, seguridad en sí mismo.

Wordcount - Cantidad promedio de palabras usadas en sus tweets

Categoria - Actividad laboral del usuario (actor, cantante, etc.)

Utilizaremos el algoritmo K-means para que agrupe estos usuarios -no por su actividad laboral- si no, por sus similitudes en la personalidad. Si bien tenemos 8 columnas de entrada, sólo utilizaremos 3 en este ejemplo, de modo que podamos ver en un gráfico tridimensional -y sus proyecciones a 2D- los grupos resultantes. Pero para casos reales, podemos utilizar todas las dimensiones que necesitemos. Una de las hipótesis que podríamos tener es: "Todos los cantantes tendrán personalidad parecida" (y así con cada rubro laboral). Pues veremos si lo probamos, o por el contrario, los grupos no están relacionados necesariamente con la actividad de estas Celebridades.

Requerimientos para el Ejercicio

Necesitaremos tener Python 2.7 o 3.5+. Mejor si tenemos instalada una suite como Anaconda o Canopy (que funcionan en Windows, Mac y Linux). Puedes seguir este tutorial donde explico cómo instalar tu ambiente de desarrollo. Crearemos un Jupiter notebook para seguir paso a paso el ejercicio e importaremos un archivo de entrada csv. Utilizaremos los paquetes scikit-learn, pandas, matplotlib y numpy.

Agrupar usuarios Twitter de acuerdo a su personalidad con K-means

Implementando K-means en Python con Sklearn

Comenzaremos importando las librerías que nos asistirán para ejecutar el algoritmo y graficar.

Importamos el archivo csv -para simplificar, suponemos que el archivo se encuentra en el mismo directorio que el notebook- y vemos los primeros 5 registros del archivo tabulados.

También podemos ver una tabla de información estadística que nos provee Pandas dataframe:

El archivo contiene diferenciadas 9 categorías -actividades laborales- que son:

Para saber cuantos registros tenemos de cada uno hacemos:

Como vemos tenemos 34 cantantes, 27 actores, 17 deportistas, 16 políticos,etc.

Visualización de Datos

Veremos graficamente nuestros datos para tener una idea de la dispersión de los mismos:

En este caso seleccionamos 3 dimensiones: op, ex y ag y las cruzamos para ver si nos dan alguna pista de su agrupación y la relación con sus categorías.

Revisando la gráfica no pareciera que haa algún tipo de agrupación o correlación entre los usuarios y sus categorías.

Definimos la entrada

Concretamos la estructura de datos que utilizaremos para alimentar el algoritmo. Como se ve, sólo cargamos las columnas op, ex y ag en nuestra variable X.

Ahora veremos una gráfica en 3D con 9 colores representando las categorías.

Veremos si con K-means, podemos "pintar" esta misma gráfica de otra manera, con clusters diferenciados.

Obtener el valor K

Vamos a hallar el valor de K haciendo una gráfica e intentando hallar el "punto de codo" que comentábamos antes. Este es nuestro resultado:

Realmente la curva es bastante "suave". Considero a 5 como un buen número para K. Según vuestro criterio podría ser otro.

Ejecutamos K-Means

Ejecutamos el algoritmo para 5 clusters y obtenemos las etiquetas y los centroids.

Ahora veremos esto en una gráfica 3D con colores para los grupos y veremos si se diferencian: (las estrellas marcan el centro de cada cluster)

Aqui podemos ver que el Algoritmo de K-Means con K=5 ha agrupado a los 140 usuarios Twitter por su personalidad, teniendo en cuenta las 3 dimensiones que utilizamos: Openess, Extraversion y Agreeablenes. Pareciera que no hay necesariamente una relación en los grupos con sus actividades de Celebrity.

Haremos 3 gráficas en 2 dimensiones con las proyecciones a partir de nuestra gráfica 3D para que nos ayude a visualizar los grupos y su clasificación:

En estas gráficas vemos que están bastante bien diferenciados los grupos.

Podemos ver cada uno de los clusters cuantos usuarios tiene:

Y podemos ver la diversidad en rubros laborales de cada uno. Por ejemplo en el grupo 0 (rojo), vemos que hay de todas las actividades laborales aunque predominan de actividad 1 y 2 correspondiente a Actores y Cantantes con 11 y 15 famosos.

De categoría 3 "modelos" hay 6 sobre un total de 9.

Buscaremos los usuarios que están más cerca a los centroids de cada grupo que podríamos decir que tienen los rasgos de personalidad característicos que representan a cada cluster:

array([21, 107, 82, 80, 91]) #posicion en el array de usuarios

<

En los centros vemos que tenemos una modelo, un político, presentadora de Tv, locutor de Radio y un deportista.

Clasificar nuevas muestras

Y finalmente podemos agrupar y etiquetar nuevos usuarios twitter con sus características y clasificarlos. Vemos el ejemplo con el usuario de David Guetta y nos devuelve que pertenece al grupo 1 (verde).

Conclusiones

El algoritmo de K-means nos ayudará a crear clusters cuando tengamos grandes grupos de datos sin etiquetar, cuando queramos intentar descubrir nuevas relaciones entre features o para probar o declinar hipótesis que tengamos de nuestro negocio.

Atención: Puede haber casos en los que no existan grupos naturales, o clusters que contengan una verdadera razón de ser. Si bien K-means siempre nos brindará "k clusters", quedará en nuestro criterio reconocer la utilidad de los mismos o bien revisar nuestras features y descartar las que no sirven o conseguir nuevas. También tener en cuenta que en este ejemplo estamos utilizando como medida de similitud entre features la distancia Euclideana pero podemos utilizar otras diversas funciones que podrían arrojar mejores resultados (como Manhattan, Lavenshtein, Mahalanobis, etc).

Hemos visto una descripción del algoritmo, aplicaciones y un ejemplo python paso a paso, que podrán descargar también desde los siguientes enlaces:

Si aún no viste el ejercicio de Regresión Lineal, Regresión Logística paso a paso ó Arbol de decisión puedes leerlos en español y seguir practicando

Los invito a escribirme sus comentarios al respecto y si tienen dudas o inconvenientes con el ejercicio. También pueden suscribirse al blog en donde intentaré escribir artículos de interés y aprendizaje de Machine Learning.

Suscribete al Blog Aprende Machine Learning

El próximo artículo quincenal sobre Machine Learning te llegará al email para continuar estudiando!.

El libro del Blog

En junio 2020 he alcanzado 1 millón de visitas al blog y he lanzado el borrador del libro del Blog . Apreciaré mucho tu ayuda! Contiene Extras descargares como el "Lego Dataset" utilizado en el artículo de Detección de Objetos. De pago pero también gratuito!

# data[].attributes.attachment_link.description
K-Means es un algoritmo no supervisado de Clustering. Se utiliza cuando tenemos un montón de datos sin etiquetar. El objetivo de este algoritmo es el de encontrar "K" grupos (clusters) entre los datos crudos. En este artículo repasaremos sus conceptos básicos y veremos un ejemplo paso a paso en pyth

# data[].attributes.attachment_caption
1.-método elbow itera el modelo hasta que no existe mayor variabilidad, el primer número sin iteración es el indicado para el K.

# data[].attributes.headline
Algoritmo KMeans – Formas para encontrar el número K de iteración:

# data[].attributes.subject
Algoritmo KMeans – Formas para encontrar el número K de iteración:

# data[].attributes.body
https://healthdataminer.com/analitica-en-accion/modelos-no-supervisados-en-salud-clusterizando-celulas/

# data[].attributes.attachment_link.title
Modelos no supervisados en salud: clusterizando células - healthdataminer.com

# data[].attributes.attachment_link.description
En este post vamos a habar de diferentes técnicas de aprendizaje no supervisado en salud. Se utlizan para realizar un análisis clúster de los datos o bien para realizar visualizaciones de datasets de elevadas dimensiones

# data[].attributes.body
La Agrupación Espacial Basada en Densidad de Aplicaciones con Ruido, o DBSCAN (Density-Based Spatial Clustering of Applications with Noise), es otro algoritmo de agrupación especialmente útil para identificar correctamente el ruido en los datos.

Criterios de Asignación de DBSCAN

Se basa en un número de puntos con un radio especificado ε y hay una etiqueta especial asignada a cada punto de datos. El proceso de asignación de esta etiqueta es el siguiente:

Es un número especificado (MinPts) de puntos vecinos. Se asignará un punto central si existe este número de puntos de los MinPts que caen en el radio ε

Un punto fronterizo caerá en el radio de ε de un punto central, pero tendrá menos vecinos que el número de MinPts.

Todos los demás puntos serán puntos de ruido.

Algoritmo DBSCAN

El algoritmo sigue la lógica:

1. Identificar un punto central y hacer un grupo para cada uno, o para cada grupo conectado de puntos centrales (si es que establecen que el criterio es el punto central).

2. Identificar y asignar puntos fronterizos a sus respectivos puntos centrales.

La siguiente figura resume muy bien este proceso y la notación comentada.
DBSCAN vs. K-Means Clustering

# data[].attributes.body
Se suele utilizar el aprendizaje no supervisado para crear y descubrir patrones no conocidos en el comportamiento de los clientes de una web, app o comercio. Estos algoritmos pueden descubrir grupos que desconocíamos por completo o agrupar ciertas características que se correlacionan y que nosotros difícilmente lo hubiéramos identificado.

# data[].attributes.headline
Aprendizaje No Supervisado - Reglas de asociación (Association rules)

# data[].attributes.subject
Aprendizaje No Supervisado - Reglas de asociación (Association rules)

# data[].attributes.body
Se pueden citar los modelos basados en el descubrimiento de reglas de asociación (Association Rules). A lo que también se le conoce como análisis de la cesta de la compra (Market Basket Analysis) ya que surgieron en este entorno. Siendo unos tipos de análisis extremadamente importantes dentro de la minería de datos. En estos análisis se busca identificar reglas las cuales predicen la probabilidad de que se observe un consecuente después de observar un antecedente en un registro. Lo que se suele denotar A => B, donde A es el antecedente y B el consecuente. Pudiendo ser tanto el antecedente como el consecuente un elemento o un conjunto de elementos. Para obtener las reglas se suele partir de una colección de transacciones con diferentes elementos. La importancia de las reglas generalmente se mide en base al soporte, la probabilidad de observar el antecede y consecuente en los registros, y confianza, la probabilidad de observar el consecuente una vez observado el antecedente. Siendo importante notar que el sentido de la regla lo define el valor de la confianza. Algunos de los algoritmos más utilizados para obtener las reglas de asociación son Apriori y Eclat.
apriori y eclat están como ejemplos del modelo

# data[].attributes.attachment_caption
2.- Método silhouetts media de índices (distancias) valor alto de medias estás cerca del valor mayor.

# data[].attributes.headline
Algoritmo KMeans – Formas para encontrar el número K de iteración:

# data[].attributes.subject
Algoritmo KMeans – Formas para encontrar el número K de iteración:

# data[].attributes.headline
Importancia del aprendizaje no supervisado

# data[].attributes.subject
Importancia del aprendizaje no supervisado

# data[].attributes.body
El aprendizaje no supervisado pretende descubrir patrones previamente desconocidos en los datos, pero la mayoría de las veces estos patrones son aproximaciones pobres de lo que puede lograr el aprendizaje supervisado. Por ejemplo, los algoritmos no supervisados segmentarán a los clientes en grupos grandes en lugar de tratarlos como individuos y permitir que las empresas entreguen comunicaciones altamente personalizadas. La definición del aprendizaje no supervisado es que no se sabe cuál será el resultado para un modelo predictivo, lo que significa que el aprendizaje supervisado es más aplicable a contextos del mundo real.

El aprendizaje no supervisado pretende descubrir patrones previamente desconocidos en los datos, pero la mayoría de las veces estos patrones son aproximaciones pobres de lo que puede lograr el aprendizaje supervisado. Por ejemplo, los algoritmos no supervisados segmentarán a los clientes en grupos grandes en lugar de tratarlos como individuos y permitir que las empresas entreguen comunicaciones altamente personalizadas. La definición del aprendizaje no supervisado es que no se sabe cuál será el resultado para un modelo predictivo, lo que significa que el aprendizaje supervisado es más aplicable a contextos del mundo real.

# data[].attributes.headline
Aprendisaje No Supervisado -  Algoritmos

# data[].attributes.subject
Aprendisaje No Supervisado -  Algoritmos

# data[].attributes.body
USOS COMUNES:
MKT - BIOLOGIA - SEGUROS - DESASTRES NATURALES

Parametricos / No Parametricos

Jerarquicos

Cluster -  Agrupamientos
EJemplo de algoritmo de agrupamiento.
Agrupación K-Meedias
El algoritmo K-Means tiene como objetivo encontrar y agrupar en clases los puntos de datos que tienen una alta similitud entre ellos. En los términos del algoritmo, esta similitud se entiende como lo opuesto de la distancia entre puntos de datos. Cuanto más cerca estén los puntos de datos, más similares y con más probabilidades de pertenecer al mismo clúster serán.

Modelos de Mezcla Gaussiana (MMG)
Los Modelos de Mezcla Gaussiana son modelos probabilísticos que asumen que todas las muestras son generadas a partir de una mezcla de un número de finita de distribución gaussiana con parámetros desconocidos.
Pertenece al grupo de algoritmos de agrupamiento blando en el que cada punto de datos pertenecerá a cada grupo existente en el conjunto de datos, pero con diferentes niveles de pertenencia a cada grupo. Esta membresía se asigna como la probabilidad de pertenecer a un determinado grupo, que oscila entre 0 y 1.

Agrupamiento jerárquico: crea una jerarquía multinivel de clústeres mediante la creación de un árbol de clústeres.

# data[].attributes.body
l análisis de componentes principales (Principal Component Analysis PCA) es un método de reducción de dimensionalidad que permite simplificar la complejidad de espacios con múltiples dimensiones a la vez que conserva su información.

Supóngase que existe una muestra con
nn individuos cada uno con
pp variables (

X
1X1,

X
2X2, ...,

X
pXp), es decir, el espacio muestral tiene
pp dimensiones. PCA permite encontrar un número de factores subyacentes
(z<p)(z<p) que explican aproximadamente lo mismo que las
pp variables originales. Donde antes se necesitaban
pp valores para caracterizar a cada individuo, ahora bastan
zz valores. Cada una de estas
zz nuevas variables recibe el nombre de componente principal.

El método de PCA permite por lo tanto "condensar" la información aportada por múltiples variables en solo unas pocas componentes. Aun así, no hay que olvidar que sigue siendo necesario disponer del valor de las variables originales para calcular las componentes. Dos de las principales aplicaciones del PCA son la visualización y el preprocesado de predictores previo ajuste de modelos supervisados.

La librería scikitlearn contiene la clase sklearn.decomposition.PCA que implementa la mayoría de las funcionalidades necesarias para crear y utilizar modelos PCA. Para visualizaciones, Yellowbrick ofrece funcionalidades extra.

# data[].attributes.body
Un ejemplo de aprendizaje no supervisado sería la de segmentar los pacientes que han sido atendidos en urgencias en grupos homogéneos pero sin un conocimiento previo de los grupos que  queremos obtener; lo haríamos a partir de estructuras no evidentes subyacentes en los datos.