Saltar al contenido

Archivos de categoría Machine Learning

Recomendaciones basado en filtrado colaborativo

Recomendaciones basado en filtrado colaborativo.

Las recomendaciones basado en filtrado colaborativo se basa en el hecho de que existen relaciones entre productos y los intereses de la gente. Muchos sistemas de recomendaciones utilizan Filtrado colaborativo para encontrar estas relaciones y para dar una recomendación precisa de un producto que el usuario puede que le guste o que le interese. El filtrado colaborativo tiene básicamente dos enfoques: basado en el usuario y basado en artículos.

  • El filtrado colaborativo basado en el usuario se basa en la similitud o el vecindario del usuario.
  • El filtrado colaborativo basado en artículos se basa en la similaridad entre los articulos.

Recomendaciones de filtrado colaborativo basado en el usuario

En el filtrado colaborativo basado en el usuario, tenemos un usuario activo para el que la recomendación está dirigida. El motor de filtrado colaborativo, primero busca a los usuarios que son similares, es decir, los usuarios que comparten los patrones de calificación del usuario activo. El filtrado colaborativo basa esta similitud en cosas como la historia, la preferencia y las opciones que los usuarios hacen al comprar, observar, o al disfrutar de algo. Por ejemplo, las películas que usuarios similares han calificado altamente. Entonces, utiliza las calificaciones de estos usuarios similares para predecir las posibles calificaciones por parte del usuario activo para una película que no había visto previamente. Por ejemplo, si 2 usuarios son similares o son vecinos, en términos de su interés en las películas, podemos recomendar una película para el usuario activo que su vecino ya ha visto.

Recomendaciones colaborativas pesosSupongamos que tenemos una matriz simple de ítem de usuario, que muestra las calificaciones de 4 usuarios para 5 diferentes películas. Supongamos también que nuestro usuario activo ha visto y evaluado 3 de estas 5 películas. Vamos a averiguar cuál de las dos películas que nuestro usuario activo no ha visto, debe ser recomendada para el. El primer paso es descubrir lo similar que es el usuario activo a los otros usuarios. Esto se puede hacer a través de muchas técnicas estadísticas y vectoriales, tales como mediciones de distancia o similaridad, incluyendo Distancia Euclidiana, Correlación de Pearson, Similitud de Cosine, etc… Para calcular el nivel de similitud entre 2 usuarios, utilizamos las 3 películas que los usuarios han calificado en el pasado. Independientemente de lo que utilizamos para la medición de similaridad, digamos, por ejemplo, la similitud, podría ser 0.7, 0.9, y 0.4 entre el usario activo y otros usuarios. Estos números representan pesos de similitud, o la proximidad del usuario activo a otros usuarios en el dataset.
El siguiente paso es crear una matriz de evaluación ponderada. Acabamos de calcular la similaridad de los usuarios a nuestro usuario activo en la diapositiva anterior. Ahora podemos usarlo para calcular la posible opinión del usuario activo acerca de nuestras 2 peliculas objetivo. Esto se logra multiplicando los pesos de similitud a las calificaciones de usuario. Esto da como resultado una matriz de calificaciones ponderada, que representa la opinión de la vecindad del usuario acerca de nuestras 2 películas candidatas para la recomendación. De hecho, incorpora el comportamiento de otros usuarios y da más peso a las calificaciones de los usuarios que son más parecidos al usuario activo. Ahora podemos generar la matriz de recomendaciones mediante la suma de todos los pesos ponderados. Sin embargo, como 3 usuarios calificaron a la primera película potencial, y 2 usuarios calificaron la segunda película, tenemos que normalizar los valores ponderados de la calificación. Lo hacemos dividiéndolo por la suma del índice de similitud para los usuarios. El resultado es la calificación potencial que nuestro usuario activo dará a estas películas, en base a su similitud con otros usuarios. Es obvio que podemos usarlo para clasificar las películas para dar una recomendación a nuestro usuario activo.
Recomendaciones colaborativas cálculo

Recomendaciones de filtrado colaborativo basado en el artículo

En el enfoque basado en el usuario, la recomendación se basa en los usuarios del mismo vecindario, con el o ella comparte preferencias comunes. Por ejemplo, como el Usuario1 y el Usuario3, a ambos les gustó el artículo 3 y el artículo 4, los consideramos similares o usuarios vecinos, y recomendamos el artículo 1, que es evaluado positivamente por Usuario1 al Usuario3. En el enfoque basado en artículos, los artículos similares crean vecindarios en el comportamiento de los usuarios.
Por ejemplo, el artículo 1 y el artículo 3 se consideran vecinos, ya que fueron valorados positivamente por tanto Usuario1 como Usuario2. Por lo tanto, el artículo 1 se puede recomendar al Usuario3 como él ya ha mostrado interés en el artículo 3. Por lo que, las recomendaciones se basan en los artículos en el vecindario que un usuario puede preferir.

Recomendaciones colaborativasInconvenientes

El filtro colaborativo es un sistema de recomendaciones muy eficaz, sin embargo, existen algunos desafíos con él también.
Uno de ellos es la dispersión de datos. La dispersión de datos se produce cuando se dispone de un dataset grande de usuarios, que generalmente sólo califican un número limitado de artículos. Como se ha mencionado, los recomendadores basados en la colaboración sólo puede predecir la puntuación de un artículo si hay otros usuarios que lo han calificado. Debido a la dispersión, es posible que no tengamos calificaciones suficientes en el dataset de artículos de usuario, lo que hace que sea imposible proporcionar recomendaciones adecuadas.
Otra cuestión que hay que tener en cuenta es algo llamado «inicio en frío». El inicio en frío hace referencia a la dificultad del sistema de recomendación tiene cuando hay un nuevo usuario y, como tal, un perfil no existe para ellos todavía. El inicio en frío también puede ocurrir cuando tenemos un nuevo artículo que no ha recibido una calificación.
La escalabilidad también se puede convertir en un problema. A medida que aumenta el número de usuarios o artículos y la cantidad de datos se expande, los algoritmos de filtrado colaborativo comenzarán a sufrir caídas en el rendimiento, simplemente debido al crecimiento en el cálculo de similaridad.
Hay algunas soluciones para cada uno de estos desafíos, tales como el uso de sistemas de recomendación basados en híbridos.

Podemos ver un ejemplo en Python en esta entrada: Recomendaciones basado en filtrado colaborativo en Python

Ir al artículo anterior de la serie: Recomendaciones basado en contenido

0 Seguir leyendo →

Clustering DBSCAN en Python

Clustering DBSCAN

La mayoría de las técnicas tradicionales de clustering, tales como k-Means, jerárquicas, y el fuzzy clustering, se pueden utilizar para agrupar datos de una forma no supervisada.

Sin embargo, cuando se aplica a tareas con clusteres de forma arbitraria, o clusteres dentro de clusteres, las técnicas tradicionales podrían no ser capaces de lograr buenos resultados. Es decir, los elementos en el mismo cluster pueden no compartir suficiente similitud, o el rendimiento puede ser pobre. Además, el Clustering basado en densidad ubica regiones de alta densidad que se separan una de otra por regiones de baja densidad. Densidad, en este contexto, se define como el número de puntos dentro de un radio específico.

Primero, importemos las librerías necesarias:

import numpy as np 
from sklearn.cluster import DBSCAN 
from sklearn.datasets.samples_generator import make_blobs 
from sklearn.preprocessing import StandardScaler 
import matplotlib.pyplot as plt 
%matplotlib inline

Generación de datos

La siguiente función genera los puntos de datos y necesita estas entradas:

  • centroidLocation: Coordina los centroides que generarán los datos aleatorios. Por ejemplo [[4,3], [2,-1], [-1,4]]
  • numSamples: El número de datos que queremos generar, dividir sobre los centroides (# de centroides definidos en centroidLocation). Por ejemplo 1500
  • clusterDeviation: La desviación standard entre clusters. Mientras más grande el número, más lejos la distancia. Por ejemplo 0.5
def createDataPoints(centroidLocation, numSamples, clusterDeviation):
    # Crear datos aleatorios y almacenar en la matriz X y el vector y.
    X, y = make_blobs(n_samples=numSamples, centers=centroidLocation, 
                                cluster_std=clusterDeviation)

    # Estandarizar características eliminando el promedio y la unidad de escala
    X = StandardScaler().fit_transform(X)
    return X, y

Usar createDataPoints con 3 datos de entrada y guardar la salida en variable X e y.

X, y = createDataPoints([[4,3], [2,-1], [-1,4]] , 1500, 0.5)

Modelado

DBSCAN significa Density-based Spatial Clustering of Applications with Noise (Clustering espacial basado en densidad de aplicaciones con ruido). Esta técnica es una de las más comunes de algoritmos de clustering, que funciona en base a la densidad del objeto. DBSCAN trabaja en la idea de que si un punto en particular pertenece a un cluster, debería estar cerca de un montón de otros puntos en ese cluster.

Funciona en base a 2 parámetros: Radius (Radio) y Puntos Mínimos.
Epsilon determina un radio especificado que, si incluye suficientes puntos dentro de él, lo llamamos de «área densa». minimumSamples determina el número mínimo de puntos de datos que queremos en un neighborhood (vecindario) para definir un cluster.

epsilon = 0.3
minimumSamples = 7
db = DBSCAN(eps=epsilon, min_samples=minimumSamples).fit(X)
labels = db.labels_
labels
array([0, 0, 1, ..., 0, 1, 0])

Distinguir Valores Atípicos

Reemplacemos todos los elementos con ‘True’ en core_samples_mask que estan en el cluster, ‘False’ si los puntos son valores atípicos (outliers).

# Primer, crear un vector de valores booleanos (valores binarios (verdadero/falso)) usando las etiquetas de la variable db.
core_samples_mask = np.zeros_like(db.labels_, dtype=bool)
core_samples_mask[db.core_sample_indices_] = True
core_samples_mask
array([ True,  True,  True, ...,  True,  True,  True])
# Número de clusters en etiquetas, ignorando el ruido en caso de estar presente.
n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)
n_clusters_
3
# Eliminar la repetición en las etiquetas transformándolas en un conjunto.
unique_labels = set(labels)
unique_labels
{0, 1, 2}

Visualización de Datos

# Crear colores para los clusters.
colors = plt.cm.Spectral(np.linspace(0, 1, len(unique_labels)))
colors
array([[0.61960784, 0.00392157, 0.25882353, 1.        ],
       [0.99807766, 0.99923106, 0.74602076, 1.        ],
       [0.36862745, 0.30980392, 0.63529412, 1.        ]])
# Dibujar los puntos con colores
for k, col in zip(unique_labels, colors):
    if k == -1:
        # El color negro se utilizará para señalar ruido en los datos.
        col = 'k'

    class_member_mask = (labels == k)

    # Dibujoar los datos que estan agrupados (clusterizados)
    xy = X[class_member_mask & core_samples_mask]
    plt.scatter(xy[:, 0], xy[:, 1],s=50, c=col, marker=u'o', alpha=0.5)

    # Dibujar los valores atípicos
    xy = X[class_member_mask & ~core_samples_mask]
    plt.scatter(xy[:, 0], xy[:, 1],s=50, c=col, marker=u'o', alpha=0.5)

Comparativa con k-medias

Para entender mejor las diferencias entre el clustering basado en densidad y el basado en partición, intentaremos agrupar el conjunto de datos anterior en 3 clusters usando k-Medias.

from sklearn.cluster import KMeans 
k = 3
k_means3 = KMeans(init = "k-means++", n_clusters = k, n_init = 12)
k_means3.fit(X)
fig = plt.figure(figsize=(6, 4))
ax = fig.add_subplot(1, 1, 1)
for k, col in zip(range(k), colors):
    my_members = (k_means3.labels_ == k)
    plt.scatter(X[my_members, 0], X[my_members, 1],  c=col, marker=u'o', alpha=0.5)
plt.show()

Ejemplo con datos reales

DBSCAN es especialmente eficaz para tareas como la identificación de clases en un contexto espacial. El atributo maravilloso del algoritmo DBSCAN es que puede encontrar cualquier forma arbitraria de cluster sin verse afectado por el ruido. Por ejemplo, vamos a ver un conjunto de datos que muestra la ubicación de las estaciones meteorológicas en Canadá. DBSCAN puede ser usado aquí para encontrar el grupo de estaciones que muestran las mismas condiciones climáticas. Como puedremos ver, no sólo encuentra diferentes clusteres de forma arbitraria, sino que puede encontrar la parte más densa de las muestras centradas en datos, ignorando áreas menos densas o ruidos.

Acerca del set de datos

Environment Canada. Monthly Values for July – 2015

Name in the table Meaning
Stn_Name Station Name
Lat Latitude (North+, degrees)
Long Longitude (West – , degrees)
Prov Province
Tm Mean Temperature (°C)
DwTm Days without Valid Mean Temperature
D Mean Temperature difference from Normal (1981-2010) (°C)
Tx Highest Monthly Maximum Temperature (°C)
DwTx Days without Valid Maximum Temperature
Tn Lowest Monthly Minimum Temperature (°C)
DwTn Days without Valid Minimum Temperature
S Snowfall (cm)
DwS Days without Valid Snowfall
S%N Percent of Normal (1981-2010) Snowfall
P Total Precipitation (mm)
DwP Days without Valid Precipitation
P%N Percent of Normal (1981-2010) Precipitation
S_G Snow on the ground at the end of the month (cm)
Pd Number of days with Precipitation 1.0 mm or more
BS Bright Sunshine (hours)
DwBS Days without Valid Bright Sunshine
BS% Percent of Normal (1981-2010) Bright Sunshine
HDD Degree Days below 18 °C
CDD Degree Days above 18 °C
Stn_No Climate station identifier (first 3 digits indicate drainage basin, last 4 characters are for sorting alphabetically).
NA Not Available

Descargar los datos

Para descargar los datos, utilizaremos !wget

!wget -O weather-stations20140101-20141231.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/weather-stations20140101-20141231.csv
--2020-03-01 17:38:18--  https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/weather-stations20140101-20141231.csv
Resolving s3-api.us-geo.objectstorage.softlayer.net (s3-api.us-geo.objectstorage.softlayer.net)... 67.228.254.196
Connecting to s3-api.us-geo.objectstorage.softlayer.net (s3-api.us-geo.objectstorage.softlayer.net)|67.228.254.196|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 129821 (127K) 
Saving to: ‘weather-stations20140101-20141231.csv’

weather-stations201 100%[===================>] 126.78K  --.-KB/s    in 0.07s   

2020-03-01 17:38:18 (1.90 MB/s) - ‘weather-stations20140101-20141231.csv’ saved [129821/129821]

Cargar el set de datos

Importaremos el .csv, luego crearemos las columnas para el año, mes y el dia.

import csv
import pandas as pd
import numpy as np

filename='weather-stations20140101-20141231.csv'

#Read csv
pdf = pd.read_csv(filename)
pdf.head(5)
Stn_Name Lat Long Prov Tm DwTm D Tx DwTx Tn DwP P%N S_G Pd BS DwBS BS% HDD CDD Stn_No
0 CHEMAINUS 48.935 -123.742 BC 8.2 0.0 NaN 13.5 0.0 1.0 0.0 NaN 0.0 12.0 NaN NaN NaN 273.3 0.0 1011500
1 COWICHAN LAKE FORESTRY 48.824 -124.133 BC 7.0 0.0 3.0 15.0 0.0 -3.0 0.0 104.0 0.0 12.0 NaN NaN NaN 307.0 0.0 1012040
2 LAKE COWICHAN 48.829 -124.052 BC 6.8 13.0 2.8 16.0 9.0 -2.5 9.0 NaN NaN 11.0 NaN NaN NaN 168.1 0.0 1012055
3 DISCOVERY ISLAND 48.425 -123.226 BC NaN NaN NaN 12.5 0.0 NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN 1012475
4 DUNCAN KELVIN CREEK 48.735 -123.728 BC 7.7 2.0 3.4 14.5 2.0 -1.0 2.0 NaN NaN 11.0 NaN NaN NaN 267.7 0.0 1012573

Limpieza

Saquemos las filas que no tienen valor en el campo Tm.

pdf = pdf[pd.notnull(pdf["Tm"])]
pdf = pdf.reset_index(drop=True)
pdf.head(5)
Stn_Name Lat Long Prov Tm DwTm D Tx DwTx Tn DwP P%N S_G Pd BS DwBS BS% HDD CDD Stn_No
0 CHEMAINUS 48.935 -123.742 BC 8.2 0.0 NaN 13.5 0.0 1.0 0.0 NaN 0.0 12.0 NaN NaN NaN 273.3 0.0 1011500
1 COWICHAN LAKE FORESTRY 48.824 -124.133 BC 7.0 0.0 3.0 15.0 0.0 -3.0 0.0 104.0 0.0 12.0 NaN NaN NaN 307.0 0.0 1012040
2 LAKE COWICHAN 48.829 -124.052 BC 6.8 13.0 2.8 16.0 9.0 -2.5 9.0 NaN NaN 11.0 NaN NaN NaN 168.1 0.0 1012055
3 DUNCAN KELVIN CREEK 48.735 -123.728 BC 7.7 2.0 3.4 14.5 2.0 -1.0 2.0 NaN NaN 11.0 NaN NaN NaN 267.7 0.0 1012573
4 ESQUIMALT HARBOUR 48.432 -123.439 BC 8.8 0.0 NaN 13.1 0.0 1.9 8.0 NaN NaN 12.0 NaN NaN NaN 258.6 0.0 1012710

Visualización

Visualización de estaciones usando el package basemap. El toolkit basemap matplotlib es una librería para dibujo de mapas en 2D en Python. Basemap no dibuja por sí mismo, sino que facilita la transformación de las coordenadas a proyecciones de mapas. El tamaño de cada punto de datos representa el promedio máximo de temperatura para cada estación del año.

from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt
from pylab import rcParams
%matplotlib inline
rcParams['figure.figsize'] = (14,10)

llon=-140
ulon=-50
llat=40
ulat=65

pdf = pdf[(pdf['Long'] > llon) & (pdf['Long'] < ulon) & (pdf['Lat'] > llat) &(pdf['Lat'] < ulat)]

my_map = Basemap(projection='merc',
            resolution = 'l', area_thresh = 1000.0,
            llcrnrlon=llon, llcrnrlat=llat, #min longitude (llcrnrlon) and latitude (llcrnrlat)
            urcrnrlon=ulon, urcrnrlat=ulat) #max longitude (urcrnrlon) and latitude (urcrnrlat)

my_map.drawcoastlines()
my_map.drawcountries()
# my_map.drawmapboundary()
my_map.fillcontinents(color = 'white', alpha = 0.3)
my_map.shadedrelief()

# To collect data based on stations        

xs,ys = my_map(np.asarray(pdf.Long), np.asarray(pdf.Lat))
pdf['xm']= xs.tolist()
pdf['ym'] =ys.tolist()

#Visualization1
for index,row in pdf.iterrows():
#   x,y = my_map(row.Long, row.Lat)
   my_map.plot(row.xm, row.ym,markerfacecolor =([1,0,0]),  marker='o', markersize= 5, alpha = 0.75)
#plt.text(x,y,stn)
plt.show()

Clustering de las estaciones basado en su ubicación i.e. Lat & Lon

DBSCAN (parte de la librería sklearn) ejecuta el clustering desde un vector o una matriz de distancia. En nuestro caso, pasamos el arregloNumpy array Clus_dataSet para encontrar ejemplos de alta densidad y expandir clusters a partir de ellos.

from sklearn.cluster import DBSCAN
import sklearn.utils
from sklearn.preprocessing import StandardScaler
sklearn.utils.check_random_state(1000)
Clus_dataSet = pdf[['xm','ym']]
Clus_dataSet = np.nan_to_num(Clus_dataSet)
Clus_dataSet = StandardScaler().fit_transform(Clus_dataSet)

# Calcular con DBSCAN
db = DBSCAN(eps=0.15, min_samples=10).fit(Clus_dataSet)
core_samples_mask = np.zeros_like(db.labels_, dtype=bool)
core_samples_mask[db.core_sample_indices_] = True
labels = db.labels_
pdf["Clus_Db"]=labels

realClusterNum=len(set(labels)) - (1 if -1 in labels else 0)
clusterNum = len(set(labels)) 


# Muestra de clusters
pdf[["Stn_Name","Tx","Tm","Clus_Db"]].head(5)
Stn_Name Tx Tm Clus_Db
0 CHEMAINUS 13.5 8.2 0
1 COWICHAN LAKE FORESTRY 15.0 7.0 0
2 LAKE COWICHAN 16.0 6.8 0
3 DUNCAN KELVIN CREEK 14.5 7.7 0
4 ESQUIMALT HARBOUR 13.1 8.8 0

Como puedes ver con los valores atípicos, la etiqueta del clustere es -1

set(labels)
{-1, 0, 1, 2, 3, 4}

Visualización de clusters basados en ubicación

Ahora, podemos visualizar los clusters usando basemap:

from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt
from pylab import rcParams
%matplotlib inline
rcParams['figure.figsize'] = (14,10)

my_map = Basemap(projection='merc',
            resolution = 'l', area_thresh = 1000.0,
            llcrnrlon=llon, llcrnrlat=llat, #min longitude (llcrnrlon) and latitude (llcrnrlat)
            urcrnrlon=ulon, urcrnrlat=ulat) #max longitude (urcrnrlon) and latitude (urcrnrlat)

my_map.drawcoastlines()
my_map.drawcountries()
#my_map.drawmapboundary()
my_map.fillcontinents(color = 'white', alpha = 0.3)
my_map.shadedrelief()

# Para crear un mapa de colores
colors = plt.get_cmap('jet')(np.linspace(0.0, 1.0, clusterNum))



#Visualización
for clust_number in set(labels):
    c=(([0.4,0.4,0.4]) if clust_number == -1 else colors[np.int(clust_number)])
    clust_set = pdf[pdf.Clus_Db == clust_number]                    
    my_map.scatter(clust_set.xm, clust_set.ym, color =c,  marker='o', s= 20, alpha = 0.85)
    if clust_number != -1:
        cenx=np.mean(clust_set.xm) 
        ceny=np.mean(clust_set.ym) 
        plt.text(cenx,ceny,str(clust_number), fontsize=25, color='red',)
        print ("Cluster "+str(clust_number)+', Avg Temp: '+ str(np.mean(clust_set.Tm)))
Cluster 0, Avg Temp: -5.538747553816046
Cluster 1, Avg Temp: 1.9526315789473685
Cluster 2, Avg Temp: -9.195652173913045
Cluster 3, Avg Temp: -15.300833333333333
Cluster 4, Avg Temp: -7.769047619047619