Cómo programar un sistema de recomendación en R

Share on linkedin
Share on twitter
Share on email

Un sistema de recomendación permite ofrecer nuevos productos o servicios a los usuarios. Sin duda alguna, esto es algo fundamental para muchos negocios online, como por ejemplo Netflix. Por eso, hoy vamos a aprender qué son los sistemas de recomendación, qué tipos existen y, cómo no, vamos a programarlos desde cero en R. ?Vamos a ello!

Tipos de sistemas de recomendación

Básicamnete, existen dos principales tipos de sistemas de recomendación diferentes:

  • Sistema de recomendación basado en el contenido: básicamente consiste en conocer las características de los productos que se han comprado para poder ofrecer productos con características similares. Por ejemplo, si yo leo libros de novela negra de un autor, el sistema me recomendará otros libros de novela negra que no haya leído. El problema, es que no te puede proponer productos con característicsa que no has probado.
  • Sistema de recomendación colaborativo. En este caso no se tiene en cuenta las características del libro, sino la opinión de las demás personas. Dentro de este sistema existen dos tipos de sistema de recomendación:
    • Sistema colaborativo basado en usuario: consiste en detectar usuarios similares al usuario al que le vamos a hacer la recomendación. Una vez hayamos elegido n usuarios similares, veremos los libros que han leído. Si resulta que muchas de las personas similares han leído un libro que les ha gustado que yo no he leído, el sistema me lo recomendará.
    • Sistema colaborativo basado en contenido: en este caso, encontraremos la similitud entre productos. Una vez tengamos la similitud entre libros, encontraremos libros similares a los que el usuario ha leído y se los recomendaremos.

Además, también se podrían combinar ambos sistemas para crear sistemas híbridos (como si se tratara de modelos de ensembling).

Dicho esto, vamos a programar estos sistemas de recomendación en R. ¡Empezamos!

Cargando datos para crear un recomendador de libros

Para programar estos sistemas de recomendación en R lo primero que necesitamos son datos. En mi caso, en vez de usar el dataset MovieLens (muy típico), usaré uno de libros, que me parece más real. Si queréis usar otros datasets, podéis encontrar más ideas aquí.

El dataset del que yo hablo lo podéis encontrar aquí y ahora vamos a descargarlo y verlo:

url = "http://www2.informatik.uni-freiburg.de/~cziegler/BX/BX-CSV-Dump.zip"
download.file(url, destfile = "data.zip")
dir.create("data")
## Warning in dir.create("data"): 'data' already exists
unzip("data.zip",exdir = "data")   

files = paste0("data/",list.files("data"))

ratings = read.csv(files[1], sep = ";")
books = read.csv(files[2], sep = ";")
users = read.csv(files[3], sep = ";")

rm(files, url)

Conociendo los datos

Conociendo los datos de libros

Antes de ponernos a programar nada, vamos a ver qué datos tenemos en cada dataset. De esta forma, tendremos una visión más clara de las cosas que podemos o no hacer. Empecemos por el dataset de libros:

library(dplyr)
glimpse(books)
## Rows: 115,253
## Columns: 8
## $ ISBN                <fct> 0195153448, 0002005018, 0060973129, 0374157065,...
## $ Book.Title          <fct> Classical Mythology, Clara Callan, Decision in ...
## $ Book.Author         <fct> Mark P. O. Morford, Richard Bruce Wright, Carlo...
## $ Year.Of.Publication <fct> 2002, 2001, 1991, 1999, 1999, 1991, 2000, 1993,...
## $ Publisher           <fct> Oxford University Press, HarperFlamingo Canada,...
## $ Image.URL.S         <fct> http://images.amazon.com/images/P/0195153448.01...
## $ Image.URL.M         <fct> http://images.amazon.com/images/P/0195153448.01...
## $ Image.URL.L         <fct> http://images.amazon.com/images/P/0195153448.01...

Como veis contamos con 4 variables que nos dan información sobre el libro (Título, Autor, Año de Publicación y Editorial). Estas variables las usaremos únicamente para programar el sistema de recomendación basado en contenido y, cómo no, para mostrar los resultados de los sistemas de recomendación.

En cualquier caso, de cara a generar tener datos más “reales”, voy a incluir una nueva variable llamada “Category”. Esta variable indicará si el libro es de alguna de las siguiente categorías:

  • Action and Adventure.
  • Classic.
  • Detective and Mystery.
  • Fantasy.
set.seed(1234)
categories = c("Action and Adventure","Classic","Detective and Mystery","Fantasy")
books$category = sample( categories, nrow(books), replace=TRUE, prob=c(0.25, 0.3, 0.25, 0.20))
books$category = as.factor(books$category)

rm(categories)

Asimismo, voy a aplicar una transformación: a todos los ISBN y User-Id añadiré el caracter Id por delante. Esto lo hago porque más adelante los IDs se convertirán en nombres de fila o columna de las matriz que crearemos.

Como estos IDs empiezan por un número, R incluirá una X delante. De esta forma, si a todos los ids incluimos unos caracteres, nos evitaremos ese problema.

books$ISBN = paste0("Isbn.",books$ISBN)
users$User.ID = paste0("User.",users$User.ID)
ratings$ISBN = paste0("Isbn.",ratings$ISBN)
ratings$User.ID = paste0("User.",ratings$User.ID)

Conociendo los datos de ratings

Por otro lado, vamos a a ver cómo se distribuyen los ratings de los libros, ya que esto va a ser interesante para todos los sistemas de recomendación colaborativos que creemos en R:

library(ggplot2)

ratings %>%
  group_by(Book.Rating) %>%
  summarize(cases = n()) %>%
  ggplot(aes(Book.Rating, cases)) + geom_col() +
  theme_minimal() + scale_x_continuous(breaks = 0:10) 

Como vemos hay muchos ceros. Esto no parece que sea una valoración “consciente” sino, simplemente, que no han valorado el libro. Por tanto, nos quedaremos únicamente con las valoraciones que no son 0.

ratings = ratings[ratings$Book.Rating!= 0, ]

Ahora podemos volver a realizar el mismo gráfico, a ver si el resultado es algo más lógico:

ratings %>%
  group_by(Book.Rating) %>%
  summarize(cases = n()) %>%
  ggplot(aes(Book.Rating, cases)) + geom_col() +
  theme_minimal() + scale_x_continuous(breaks = 0:10)

Por último, vamos a ver cuánto puntúa cada persona:

ratings_sum = ratings %>%
  group_by(User.ID) %>%
  count() 

summary(ratings_sum$n)
##     Min.  1st Qu.   Median     Mean  3rd Qu.     Max. 
##    1.000    1.000    1.000    5.319    3.000 1906.000

Como vemos, el 75% de los usuarios ha dado 3 recomendaciones o menos. Vamos a quitar estas personas para quedarnos únicamente con usuarios más significativos y que, así, las necesidades de computación sean menores:

user_index = ratings_sum$User.ID[ratings_sum$n>4]

users = users[users$User.ID %in% user_index, ]
ratings = ratings[ratings$User.ID %in% user_index, ]
books = books[books$ISBN %in% ratings$ISBN,]

rm(ratings_sum, user_index)

Ahora que conocemos nuestros datos, vamos a crear nuestro sistema de recomendación en R. ¡Vamos a ello!

Cómo programar un Sistema de recomendación basado en el contenido en R

Calculando la disimilitud entre libros

Un sistema de recomendación basado en contenido utiliza las características de los productos para encontrar productos similares.

Como hemos visto anteriormente, en nuestro caso disponemos de distintas características de los libros: título del libro, año, autor, editorial y categoría. Sin embargo, ¿son todas esas características relevantes de cara al usuario?

El título del libro, por ejemplo, parece que no es una muy buena característica de cara a una recomendación. Quizás, si contáramos con la descripción podríamos hacer un análisis del texto para encontrar las palabras clave de la descripción. Eso sí sería algo que podría tener sentido, pero el título… yo no lo creo, así que lo descartamos.

En mi opinión, el año también puede ser engañoso: yo no compraría un libro porque sea del mismo año que uno que me ha gustado. Quizás es algo que solo tenga sentido una vez se cumplan ciertas condiciones… En cualquier caso, en mi caso lo he quitado también.

Por tanto, nos quedamos con las variables Autor, Editorial y Categoría. Pero… ¿cómo podemos saber cómo de similares son dos productos en base a unas categorías? Para eso, tenemos que calcular distancias.

La forma de distancia que podamos calcular dependerá en gran medida de los tipos de datos que tengamos. Básicamente, existen tres opciones:

  • Todos los datos son numéricos: en este caso podríamos normalizar los datos y usar la distancia Euclidea para calcular las distancias. Esto es algo que vimos cuando programamos el algoritmo K-means desde 0 en R.
  • Tienes datos numéricos y categóricos. En este caso deberás usar la distancia de Gower. Esta la podrás encontrar en la función daisy del paquete cluster (enlace).
  • Todos los datos son categóricos: existen distintas formas de calcular distancias en estos casos. Sin embargo, según este estudio, no existe gran diferencias entre todas ellas, por lo que podrías usar cualquier tipo de medición común.

En nuestro caso todos los datos son categóricos. Sin embargo, usaremos la distancia de Gower, que en nuestro caso sirve también y, así, sabes también cómo se haría en caso de que incluyéramos también datos numéricos (como el año). Veamos cómo funciona:

library(cluster)

books_distance = books[,c("ISBN","Book.Author","Publisher")] 
dissimilarity = daisy(books_distance, metric = "gower")
# Error: no se puede ubicar un vector de tamaño 49.5 Gb

Como vemos, no podemos calcular las distancias. ¿Por qué? Pues porque esta fórmula calcula la distancia entre todos los elementos. Por tanto, el resultado es una matriz de \(n x n\), siendo n el número de libros diferentes de los que disponemos.

En nuestro caso contamos con 115246 libros diferentes, por lo que habría que hacer una matriz de 115246 x 115246. Esto es algo demasiado pesado para trabajar en local. De hecho, si la intentamos crear veremos como nos devuelve el mismo error:

matrix(ncol = 115246, nrow = 115246)
# Error: no se puede ubicar un vector de tamaño 49.5 Gb

Aquí nos encontramos con uno de los principales problemas de los sistemas de recomendación basados en contenido: son muy difíciles de escalar y utilizar con muchos productos. Por sí mismo esto ya es una pega para poder utilizarlos… pero bueno, aún así, sigamos viendo cómo funcionan.

Para evitar este problema, vamos a quedarnos únicamente con 10.000 libros de los autores más comunes para ver cómo funcionan. Además, vamos a dar un peso a cada variable, de tal forma que dos libros se parezcan más por ser de la misma autora que por ser de la misma editorial.

library(dplyr)

book_feature = books[1:10000,c("Book.Author","Publisher","category")] 

dissimilarity = daisy(book_feature, metric = "gower", weights = c(2,0.5,1))
dissimilarity = as.matrix(dissimilarity)

row.names(dissimilarity)<-  books$ISBN[1:10000]
colnames(dissimilarity)<- books$ISBN[1:10000]

dissimilarity[15:20,15:20]
##                 Isbn.0971880107 Isbn.0345402871 Isbn.0345417623 Isbn.0684823802
## Isbn.0971880107       0.0000000       1.0000000       1.0000000       1.0000000
## Isbn.0345402871       1.0000000       0.0000000       0.5714286       1.0000000
## Isbn.0345417623       1.0000000       0.5714286       0.0000000       1.0000000
## Isbn.0684823802       1.0000000       1.0000000       1.0000000       0.0000000
## Isbn.0375759778       0.7142857       1.0000000       1.0000000       1.0000000
## Isbn.0375406328       1.0000000       1.0000000       1.0000000       0.7142857
##                 Isbn.0375759778 Isbn.0375406328
## Isbn.0971880107       0.7142857       1.0000000
## Isbn.0345402871       1.0000000       1.0000000
## Isbn.0345417623       1.0000000       1.0000000
## Isbn.0684823802       1.0000000       0.7142857
## Isbn.0375759778       0.0000000       1.0000000
## Isbn.0375406328       1.0000000       0.0000000

Como veis, la matriz tiene sobre todo dos valores: 0 y el 1, siendo 0 el menor grado de disimilitud y el 1 el máximo grado. Ojo, estamos hablando de disimilitud, por lo que, si que si el valor es 0, significa que esos libros son iguales, mientras que si es 1, no tienen nada en común.

Como vemos, de todos los libros que hemos sacado, vemos que hay libros que tienen cosas en común: 0684823802 se parece a 0345402871 y 0345402871 se parece a 0345417623. Veamos a ver por qué se da esa similitud:

Y es que, de hecho, las reglas de recomendación de este algoritmo se basan en recomendar libros que sean:

  1. Del mismo autor, editorial y categoría.
  2. Del mismo autor y categoría.
  3. Que sean solo del mismo autor.
  4. De la misma categoría y editorial.
  5. Que solo sean de la misma categoría.
  6. Que solo sean de la misma editorial.

Ahora que ya tenemos la distancia entre libros y sabemos cómo funciona este sistema de recomendación…. ¡vamos a ver qué libro recomendamos a un usuario!

Programar Sistema de recomendación basado en contenido en R

Para obtener las recomendaciones para un usuario, vamos a necesitar los libros que un usuario ha leído y valorado. De esta forma, podremos buscar los libros que se parezcan a esos libros. Además, hay que tener en cuenta que no contamos con todos los libros, sino con solo una muestra de ellos, ya que nos hemos quedado con los 10.000 autores más famosos.

En cualquier caso, vamos a elegir un usuario y quedarnos con los libros que ha leído sobre los que podemos aplicar el algoritmo:

user_id = "User.1167"

user_books = ratings %>%
  filter(User.ID == user_id & ISBN %in% books$ISBN[1:10000]) %>%
  arrange(desc(Book.Rating))

head(user_books,10)

Como vemos, el usuario ha dado 6 recomendaciones dando puntuaciones de 10, 9, 8, 7 y 5 puntos. Utilizar las recomendaciones es algo importante, ya que nos permite ponderar las recomendaciones que damos: priorizaremos un libro similar al que ha puntuado con un 10 que a uno que ha puntuado con un 5. Además, dejaremos de recomendar aquellos libros que se parezcan a los que ha puntuado con un 0.

Teniendo esto en cuenta vamos a encontrar los libros que más se parecen a estos dos ejemplares:

library(tidyr)

books$ISBN = as.character(books$ISBN)
selected_books = user_books[ ,c("ISBN", "Book.Rating")]

recomendar = function(selected_books, dissimilarity_matrix, 
                      books, n_recommendations = 5){

  selected_book_indexes = which(colnames(dissimilarity_matrix) %in% selected_books$ISBN)


  results = data.frame(dissimilarity_matrix[, selected_book_indexes], 
                       recommended_book = row.names(dissimilarity_matrix),
                       stringsAsFactors = FALSE) 


  recomendaciones = results %>%
    pivot_longer(cols = c(-"recommended_book") , names_to = "readed_book", 
                 values_to = "dissimilarity") %>%
      left_join(selected_books, by = c("recommended_book" = "ISBN"))%>%
    arrange(desc(dissimilarity)) %>%
    filter(recommended_book != readed_book) %>%
    filter(!is.na(Book.Rating) ) %>%
    mutate(
      similarity = 1 - dissimilarity,
      weighted_score = similarity * Book.Rating) %>%
    arrange(desc(weighted_score)) %>%
    filter(weighted_score>0) %>%
    group_by(recommended_book) %>% slice(1) %>%
    top_n(n_recommendations, weighted_score)  %>%
    left_join(books, by = c("recommended_book" = "ISBN"))

  return(recomendaciones)
}

recomendaciones = recomendar(selected_books, dissimilarity, books)
recomendaciones

Y con esto… ¡Ya hemos creado nuestro sistema de recomendación basado en contenido! Como ves, al usuario le recomendamos varios libros similares por haber leído el libro 0060929596.

Vamos a crear una función que nos permita visualizarlo de una forma más fácil:

visualizar_recomendacion = function(recomendation,
                                     recommended_book, image, n_books = 5){

  if(n_books > nrow(recomendation)) {n_books = nrow(recomendation)}

  plot = list()

  dir.create("content_recommended_images")
  for(i in 1:n_books){
    # Create dir & Download the images
    img = pull(recomendation[i,which(colnames(recomendation) == image)])
    name = paste0("content_recommended_images/",i,".jpg")
    suppressMessages(
      download.file(as.character(img), destfile = name ,mode = "wb") 
    )

    # Assign Objetc
    plot[[i]] = rasterGrob(readJPEG(name))
  }

    do.call(marrangeGrob, args = list(plot, ncol = n_books, nrow = 1, top=""))

}

visualizar_recomendacion(recomendaciones, "recommended_book","Image.URL.M")
Recomendaciones de sistema de recomendación basado en contenido programado en R

Ahora, vamos a aprender cómo crear un sistema de recomendación basado en el contenido del usuario. ¡Vamos a ello!

Programar sistema de recomendación colaborativo en R

El sistema de recomendación basado en el usuario o recomendador colaborativo consiste en utilizar las respuestas de los usuarios sobre los productos para así poder recomendarte libros. Más concretamente, existen dos grandes tipos de sistemas de recomendación basado en usuario.

  • Sistema de recomendación colaborativo basado en productos: en este caso vamos a buscar la similitud entre los productos teniendo en cuenta los ratings que obtienen. Una vez tengamos esto, buscaremos productos similares a los que el usuario ya ha comprado y se los recomendaremos.
  • Sistema de recomendación colaborativo basado en usuarios: en este caso vamos a buscar la similitud entre los usuarios. Una vez la tengamos, encontraremos los n usuarios más cercanos a la persona a la que queramos recomendar algo. Así, buscaremos los productos que les hallan gustado a las personas similares a nuestro usuario, pero que nuestro usuario no haya probado. Esos son los productos que recomendaremos.

Ahora que ya sabemos de forma intuitiva cómo funcionan estos dos sistemas de recomendación, ¡vamos a programarlos en R!

Programar sistema de recomendación colaborativo basado en productos en R

Para programar un sistema de recomendación colaborativo basado en contenido, primero tenemos que crear la matriz Usuario-Producto. Esto lo podemos hacer de forma sencilla con la función pivot_widerde tidyr.

user_item = ratings %>%
  top_n(10000) %>%
  pivot_wider(names_from = ISBN,values_from = Book.Rating) %>%
  as.data.frame()

row.names(user_item) = user_item$User.ID
user_item$User.ID = NULL

user_item = as.matrix(user_item)

user_item[1:5,1:5]
##             Isbn.0060096195 Isbn.0142302198 Isbn.038076041X Isbn.0699854289
## User.276822              10              10              10              10
## User.276847              NA              NA              NA              NA
## User.276859              NA              NA              NA              NA
## User.276861              NA              NA              NA              NA
## User.276872              NA              NA              NA              NA
##             Isbn.0786817070
## User.276822              10
## User.276847              NA
## User.276859              NA
## User.276861              NA
## User.276872              NA

Sin embargo, vemos como esto tienen un problema: hay mucho NA. Si lo piensas es algo normal, ya que un usuario solo leerá unos pocos libros de todos los que están disponibles.

En cualquier caso, al hecho de tener muchos NAs se le denomina sparsity o matriz dispersa. Podemos calcular el grado de sparsity de la siguiente manera:

sum(is.na(user_item)) /  ( ncol(user_item) * nrow(user_item) )
## [1] 0.9996276

Como puedes ver tenemos una matriz muy muy dispersa, ya que en el 99,96% de las celdas faltan datos. Esto es algo que nos limita bastante de cara a poder actuar, ya que a partir de esta matriz debemos encontrar la similitud entre productos.

Para ello, existen distintas fórmulas: similitud de coseno, coeficiente de correlación de Pearson, distancia Euclídea… En nuestro caso usaremos la similitud de coseno.

La fórmula de la similitud del coseno es esta:

Explicación de la función de similitud de coseno para programar un sistema de recomendación colaborativo en R

Sabiendo esto, la vamos a programar:

cos_similarity = function(A,B){
  num = sum(A *B, na.rm = T)
  den = sqrt(sum(A^2, na.rm = T)) * sqrt(sum(B^2, na.rm = T)) 
  result = num/den

  return(result)
}

Ahora que tenemos programada la función de coseno, podemos aplicar esta función para todos los items y así obtener la matriz Producto-Producto.

Sin embargo, no es algo que vayamos a aplicar a todos los items, sino únicamente al item del cual queremos encontrar productos similares. Y es que, una vez más, calcular la matriz item-item es computacionalmente muy exigente y requeriría de mucho tiempo y memoria.

En cualquier caso, creamos una función para calcular la similitud únicamente sobre el id de producto que nosotros elijamos.

item_recommendation = function(book_id, rating_matrix = user_item, n_recommendations = 5){

  user_index = which(rownames(rating_matrix) == book_id)

  similarity = apply(rating_matrix, 2, FUN = function(y) 
                      cos_similarity(rating_matrix[user_index,], y))

  recommendations = tibble(ISBN = names(similarity), 
                               similarity = similarity) %>%
    filter(ISBN != book_id) %>% 
    top_n(n_recommendations, similarity) %>%
    arrange(desc(similarity)) 

  return(recommendations)

}

recom_cf_item = item_recommendation("Isbn.0446677450")
recom_cf_item

¡Con esto ya tendríamos nuestra recomendación! Solo falta que apliquemos la función que hemos creado previamente para que se vea de una forma mucho más visual:

recom_cf_item = recom_cf_item %>%
  left_join(books, by = c("ISBN" = "ISBN")) 

visualizar_recomendacion(recom_cf_item[!is.na(recom_cf_item$Book.Title),],
                         "ISBN",
                         "Image.URL.M"
                         )
Recomendaciones de sistema de recomendación basado en similitud entre items programado en R

Programar sistema de recomendación colaborativo basado en usuarios en R

Para programar un sistema de recomendación colaborativo basado en usuarios partiremos de la matriz Usario – Item. Solo que en este caso, en vez calcular las distancias a nivel de columna, lo haremos a nivel de fila.

user_recommendation = function(user_id, user_item_matrix = user_item,
                               ratings_matrix = ratings,
                               n_recommendations = 5,
                               threshold = 1,
                               nearest_neighbors = 10){

  user_index = which(rownames(user_item_matrix) == user_id)

  similarity = apply(user_item_matrix, 1, FUN = function(y) 
                      cos_similarity(user_item_matrix[user_index,], y))

  similar_users = tibble(User.ID = names(similarity), 
                               similarity = similarity) %>%
    filter(User.ID != user_id) %>% 
    arrange(desc(similarity)) %>%
    top_n(nearest_neighbors, similarity)


  readed_books_user = ratings_matrix$ISBN[ratings_matrix$User.ID == user_id]

  recommendations = ratings_matrix %>%
    filter(
      User.ID %in% similar_users$User.ID &
      !(ISBN %in% readed_books_user)) %>%
    group_by(ISBN) %>%
    summarise(
      count = n(),
      Book.Rating = mean(Book.Rating)
    ) %>%
    filter(count > threshold) %>%
    arrange(desc(Book.Rating), desc(count)) %>%
    head(n_recommendations)

  return(recommendations)

}

recom_cf_user = user_recommendation("User.99", n_recommendations = 20)
recom_cf_user

¡Ya tenemos nuestro sistema de recomendación colaborativo basado en el usuario creado en R. Básicamente, este sistema busca personas similares y encuentra aquellos libros que personas similares han recomendado pero nosotros no hemos leído. Esos son los libros que hemos recomendado al usuario. ¡Vamos a verlos!

recom_cf_user = recom_cf_user %>%
  left_join(books, by = c("ISBN" = "ISBN"))

visualizar_recomendacion(recom_cf_user[!is.na(recom_cf_user$Book.Title),],
                         "ISBN","Image.URL.M")
Recomendaciones de sistema de recomendación basado en similitud entre usuarios programado en R

¡Ya hemos creado nuestro sistema de recomendación colaborativo basado en usuario en R! Ahora bien, ¿cuándo deberíamos usar cada uno de los sistemas de recomendación que hemos aprendido a programar hoy en R? ¡Veámoslo!

Cuándo utilizar los diferentes sistemas de Recomendación

Para entender mejor cuándo utilizar cada uno de los tres sistemas de recomendación que hemos aprendido a programar, es importante entender qué asume cada uno de los sistemas de recomendación.

Por un lado, el sistema de recomendación basado en la similitud entre usuarios considera que lo que a los demás les ha gustado puede que al usuario también le guste. Este sistema asume que los gustos de los usuarios no cambian con el tiempo: lo que a mí me encantaba hace 1 año me seguirá encantando.

Sin embargo, si bien esta hipótesis puede tener sentido cuando hablamos de libros o películas, en otros casos, como por ejemplo la ropa, seguramente falle más. Por tanto, si bien es uno de los sistemas de recomendación más usados, es importante considerar cómo cambia la opinión de los usuarios respecto a los productos con el tiempo antes de usar este tipo de sistema de recomendación.

Por otro lado, el sistema de recomendación basado en similitud entre libros es más robusto. Y es que, después de que haya muchas recomendaciones iniciales, es muy difícil que el rating promedio de un item se vea afectado.

Por tanto, como norma general, si tenemos más usuarios que items y si los ratings no cambian mucho en el tiempo, usaríamos el sistema de recomendación basado en similitud entre items. Sino, usaríamos el sistema de recomendación basado en similitud entre usuarios.

Por último, el sistema de recomendación basado en contenido… aunque no suele ser el sistema de recomendación más óptimo, podría tener sentido cuando los items tienen muchas variables independientes que afectan al rating del usuario. En cualquier caso, y como hemos visto al elaborarlo, tiene muchas limitaciones, desde el tipo de contenido que recomienda hasta la capacidad computacional que requiere.

¡Y hasta aquí llegamos hoy! Espero que el mundo de los sistemas de recomendación os haya parecido interesante. Como siempre, cualquier sugerencia no dudéis en escribirme por LinkedIn. ¡Hasta la próxima!

¡No te pierdas ningún post!

Si te gusta lo que lees... suscríbete para estar al día de los contenidos que subo.
¡Serás el primero en enterarte!