Recommendation (slide pratica) - unibo.itdia.apice.unibo.it/download/slides/recommendation-mahout.pdf · recommendation relative a utenti e oggetti su cui è addestrato • Il metodo

Recommender System – Mahout

Recommender Systems Mahout

Programmazione di Applicazioni Data Intensive

Laurea in Ingegneria e Scienze Informatiche

DISI – Università di Bologna, Cesena

Proff. Gianluca Moro

Giacomo Domeniconi, Roberto Pasolini DISI Università di Bologna, Cesena

[email protected]


Riepilogo: recommendation e collaborative filtering

• Un sistema di recommendation scopre relazioni nuove tra utenti e oggetti (prodotti, servizi, …) – Per ogni utente si cercano gli oggetti a cui è più probabile che sia

interessato

• Il collaborative filtering (CF) prevede nuove associazioni utente-oggetto solamente in base a quelle già presenti – Si ignorano le caratteristiche specifiche di utenti e oggetti

– Approccio generale, facilmente applicabile in molti contesti

• Vediamo ora una libreria software che fornisce supporto per i comuni metodi di collaborative filtering

Data Intensive Applications 2


Apache Mahout

• Mahout è un progetto di Apache Software Foundation che fornisce implementazioni di algoritmi di machine learning

• Progetto open source tutt’ora in via di sviluppo – Al momento non è stata rilasciata una versione 1.0.0 e le funzionalità

disponibili possono cambiare da una versione all’altra

• L’obiettivo è fornire algoritmi scalabili e (dove possibile) che funzionino anche in ambienti distribuiti – Gli algoritmi distribuiti si basano sul framework Apache Hadoop

• Il progetto include tre aree principali – recommendation (in particolare mediante collaborative filtering)

– clustering

– classificazione



Collaborative filtering con Apache Mahout

• Mahout offre un framework per il collaborative filtering (CF) – Caricamento di dati da diverse fonti (file, database relazionali, …)

– Diversi algoritmi di recommendation con parametri impostabili (misure di distanza, similarità e vicinato, ...)

– Funzionalità per valutare l’accuratezza delle recommendation

• All’interno del framework, sia gli utenti che i prodotti sono rappresentati da numeri long piuttosto che da oggetti Java – Nel CF i dettagli di utenti o prodotti sono ignorati, basta identificarli

– L’uso di numeri invece di oggetti è più efficiente per memoria e tempo

– Lavorando con i dati di un DB, i numeri possono corrispondere alle chiavi primarie numeriche usate nelle tabelle



Dati in ingresso: DataModel e Preference

• Per addestrare un sistema di recommendation basato sul collaborative filtering sono necessari dei dati

• Un DataModel rappresenta un insieme di dati utilizzabile per costruire un recommender, caratterizzato da: – gli insiemi degli ID degli utenti (user) e di quelli degli oggetti (item)

– le associazioni tra gli utenti e gli oggetti

• Un’associazione è rappresentata da un oggetto Preference – Un’associazione binaria è caratterizzata solo dagli ID dell’utente e

dell’oggetto (ad es. il fatto che l’utente abbia acquistato l’oggetto)

– Spesso ogni associazione ha anche un punteggio float che indica il rating (ad es. il voto che l’utente ha dato all’oggetto)



Generare DataModel da file

• Per importare i dati da file CSV si usa un FileDataModel – Sono supportati anche archivi compressi .zip e .gz con all’interno il file

File file = new File("...\\ratings.csv");

DataModel model = new FileDataModel(file);

• Il file deve contenere una riga per ogni associazione e tre colonne: ID utente, ID oggetto, valore (rating)


44231 26360 4 7365 76800 4 1051 109468 5 ...


Strutture dati ottimizzate di Mahout

• Un DataModel astrae un insieme di oggetti Preference – In pratica questi oggetti non sono effettivamente presenti in memoria:

ne richiederebbero una grande quantità

• Mahout usa apposite strutture dati ottimizzate sia per l’uso di memoria che per l’efficienza nella lettura dei dati

• Una di queste è PreferenceArray, che memorizza le preferenze relative ad uno stesso utente od oggetto

• Un DataModel può essere costruito come un insieme di PreferenceArray, uno per ciascun utente (od oggetto)

• I PreferenceArray usano a loro volta collezioni ottimizzate (FastIDSet, FastByIDMap) invece delle normali collezioni di Java (HashSet, HashMap, ...)



… …

Creazione di Preferenze e Generazione di un DataModel

// creo una mappa vuota dagli utenti alle loro preferenze

FastByIDMap<PreferenceArray> preferences = new FastByIDMap<PreferenceArray>();

// creo l’array per l’utente 1 con lo spazio per 10 preferenze

PreferenceArray prefsUser11 = new GenericUserPreferenceArray( 10 );

prefsUser11.setUserID( 0, 11 ); // assegno all’utente l’ID 11

// imposto una prima preferenza per l’oggetto 101 con voto 3

prefsUser11.setItemID( 0, 101 );

prefsUser11.setValue( 0, 3.0f );

// imposto una seconda preferenza

prefsUser11.setItemID( 1, 103 );

prefsUser11.setValue( 1, 4.5f );

... // altre preferenze

// aggiungo l’array alla mappa

preferences.put( 11, prefsUser11 );

... // altri array per altri utenti

// creo il DataModel dalla mappa

DataModel model = new GenericDataModel( preferences );

11

14

… … … …

101 3.0

103 4.5

… …

user item rating

GenericDataModel

FastByIDMap

GenericUser PreferenceArray (uno per ogni utente)



Ottenere un DataModel da un database

• Mahout fornisce diversi JDBCDataModel, estensioni di DataModel che leggono dati da database SQL di vari RDBMS – Ad es. PostgreSQLJDBCDataModel per accedere a PostgreSQL

• Per creare un JDBCDataModel occorre indicare – una DataSource da cui ottenere una connessione al DB

– i nomi della tabella o vista contenente i rating degli utenti sui prodotti

• Il JDBCDataModel esegue una query sul database ad ogni chiamata a metodo → il suo uso diretto è inefficiente – Anche con query rapide, la comunicazione col DB richiede tempo

• È però possibile col metodo exportWithPrefs ottenere una FastByIDMap con la copia in memoria di tutti i dati – Questa può essere poi incapsulata in un secondo oggetto DataModel



Caricamento Preferenze dal Database e Salvataggio in Memoria

DataSource src = ... ; // sorgente dati

// creo modello sul DB indicando nomi di tabella e colonne

JDBCDataModel dbModel = new PostgreSQLJDBCDataModel( src, // sorgente dati "estore.user_reviews”, // tabella o vista dei rating "user_oid", // attributo utenti "product_oid", // attributo oggetti "score", // attributo rating null // attributo timestamp (non usata) );

// carico i dati dalla tabella dbModel in memoria

FastByIDMap<PreferenceArray> data = dbModel.exportWithPrefs();

// creo il modello dai dati in memoria

DataModel model = new GenericDataModel( data );



Metodi principali di DataModel

• getNumUsers(), getNumItems(): restituiscono il numero di utenti e di oggetti distinti presenti nel set di dati

• hasPreferenceValues(): true se le preferenze hanno dei pesi numerici associati (non booleane)

• getPreferenceValue(user,item): rating dell’utente per l’item con ID dati in input (null se non associati)

• getUserIDs(), getItemIDs(): restituisce un iteratore su tutti gli ID di utenti e prodotti presenti nel set di dati

LongPrimitiveIterator users = model.getUserIDs(); while ( users.hasNext() ) { long user = users.nextLong(); ... }



Modello di Recommendation: Recommender

• Dall’analisi di un DataModel si può ottenere un modello di conoscenza, rappresentato da un oggetto Recommender

• Un Recommender è in grado di stimare la valutazione che un utente darebbe ad un oggetto sulla base di quelle note

• Esistono diverse implementazioni di Recommender, basate su diversi approcci di collaborative filtering – user-based, item-based, scomposizione di matrici

• Ciascuna implementazione richiede parametri diversi – alcuni di essi sono oggetti con parametri a loro volta

• Vediamo un esempio di recommender, mostrando poi come applicarlo una volta costruito



Riepilogo: User-based recommendation

• Uno user-based recommender prevede i rating di ogni utente in base alla media pesata dei suoi utenti simili, cioè che hanno dato voti simili ad oggetti in comune – Ignorando gli utenti non abbastanza simili, l’efficienza è maggiore

Item1 Item2 Item3 Item4 Item5

Carl 5 3 4 4 ?

Mike 3 1 2 3 3

Jake 4 3 4 3 5

Tom 3 3 1 5 4

Phill 1 5 5 2 1

simile a media



User-based Recommendation in Mahout

• La user-based recommendation richiede di definire – come misurare la similarità tra utenti (usata per pesare la media)

– come stabilire quali utenti siano simili (vicini) a quello di riferimento

• Il concetto di similarità tra utenti è rappresentato in Mahout dall’interfaccia UserSimilarity

• Definire quali siano gli utenti più simili/vicini ad uno dato è invece compito di un oggetto UserNeighborhood – La definizione di vicinato si basa a sua volta su quella di similarità

• Mahout fornisce implementazioni di queste interfacce

• Uno UserBasedRecommender si ottiene combinando un DataModel (dati), una UserSimilarity (misura di similarità) e un UserNeighborhood (definizione di vicini)



Generazione di uno User-based Recommender

// caricamento della utility matrix

DataModel model = new FileDataModel( new File("...") );

// misura di similarità: correlazione di Pearson

UserSimilarity similarity = new PearsonCorrelationSimilarity( model );

// vicinato: 10 utenti più simili

UserNeighborhood neighborhood = new NearestNUserNeighborhood( 10, similarity, model );

// creo un recommender con i componenti creati sopra

Recommender recommender = new GenericUserBasedRecommender( model, neighborhood, similarity );

Implementazione standard di UserBasedRecommender



Varianti di UserSimilarity e UserNeighborhood

• Per la costruzione di un UserBasedRecommender, Mahout fornisce diverse implementazioni dei componenti – È anche possibile creare delle proprie implementazioni

• Tra le UserSimilarity disponibili ci sono: – UncenteredCosineSimilarity (similarità coseno)

– PearsonCorrelationSimilarity (equivale alla similarità coseno sui dati “centrati” in modo tale che la loro media sia 0)

– SpearmanCorrelationSimilarity (correlazione di Pearson calcolata sulla similarità dell’ordine degli item in base ai loro rating)

– EuclideanDistanceSimilarity, CityBlockSimilarity …

• Come UserNeighborhood si può scegliere tra: – NearestNUserNeighborhood: N utenti più vicini

– ThresholdUserNeighborhood: utenti distanti non più di X



Metodi principali di un Recommender

• Una volta costruito un Recommender, è possibile ottenere recommendation relative a utenti e oggetti su cui è addestrato

• Il metodo estimatePreference prevede (se non c’è già nel DataModel) il voto di un dato utente ad un dato oggetto

• I metodi recommend restituiscono una lista ordinata (List) dei migliori N consigli per un utente, in base ai voti previsti – Di default, vengono esclusi oggetti a cui l’utente ha già dato un voto

– Si può opzionalmente indicare un IDRescorer che escluda alcuni oggetti e/o alteri i punteggi stimati secondo criteri personalizzati

• La lista data è di RecommendedItem, che ha i metodi – getItemId() per ottenere l’ID dell’oggetto suggerito

– getValue() per ottenere il voto previsto



Ottenere le Recommendation di un Utente

Recommender recommender = ...;

// a quale utente devo dare i suggerimenti ?

long userId = ...;

// ottengo la lista delle 10 migliori recommendation

List<RecommendedItem> recommendations = recommender.recommend( userId, 10 );

// visualizzo i nomi degli oggetti suggeriti

// (assumo che getItemName dia il nome dell’item dall’ID)

System.out.println( "You may also like:" );

for ( RecommendedItem recommendation: recommendations ) {

long itemId = recommendation.getItemID();

System.out.println( getItemName( itemId ) );

} Data Intensive Applications 18


Valutare l’Accuratezza di un Recommender

• Per ottenere un buon modello di recommendation, bisogna individuare quali sono le tecniche e i parametri migliori – Questi fattori possono cambiare a seconda dei dati trattati

• Mahout fornisce strumenti per valutare l’accuratezza di un recommender, confrontando le previsioni con i rating noti

• Per la valutazione si usa comunemente il metodo hold-out – i dati disponibili sono divisi tra training set e test (o validation) set

– col training set si costruisce un modello con i parametri da valutare

– il modello è usato per effettuare predizioni sul test set e confrontarle con le risposte attese per valutarne l’accuratezza



RecommenderEvaluator

• Un oggetto di tipo RecommenderEvaluator esegue un test hold-out di un recommender su un insieme di dati

• La configurazione usata per costruire il Recommender va incapsulata in un oggetto RecommenderBuilder – callback che costruisce un Recommender da un DataModel dato

• Esistono diverse classi concrete per calcolare diverse metriche – Ad es. RMSRecommenderEvaluator per calcolare il Root Mean

Square Error (RMSE), una delle metriche più comuni

– Per tutte le metriche, valori più bassi denotano maggiore accuratezza

• Il metodo evaluate esegue la valutazione, gestendo la divisione casuale dei dati in training e test set – Per eseguire test ripetibili, è possibile impostare un seed specifico RandomUtils.useTestSeed( seed )



Funzionamento di RecommenderEvaluator.evaluate

(sono evidenziati i parametri del metodo evaluate)

• Dal DataModel dato in input viene selezionata una frazione evaluationPercentage degli utenti dichiarati – Specificare 1.0 per usare l’intero dataset nella divisione training e test

• Per ogni utente, una percentuale trainingPercentage delle sue preferenze va nel training set, il resto nel test set

• Un DataModel viene costruito dal training set – Di default si usa l’intero training set, ma è possibile specificare un DataModelBuilder da usare

• Questo dataset è fornito ad un RecommenderBuilder, che deve restituire un Recommender addestrato con esso

• Tutte le preferenze del test set vengono confrontate con i valori previsti dal Recommender per calcolarne l’accuratezza



Valutazione di uno User-based Recommender

// dati in ingresso: file ratings.csv

DataModel model = new FileDataModel( new File( "...\\ratings.csv" ) );

// metrica: Root Mean Square Error

RecommenderEvaluator evaluator = new RMSRecommenderEvaluator();

// recommender user-based (come esempio precedente)

RecommenderBuilder builder = model -> {

UserSimilarity similarity = new PearsonCorrelationSimilarity(model);


return new GenericUserBasedRecommender( model, neighborhood, similarity );

};

// eseguo la valutazione dividendo i dati in 70% training e 30% test

double score = evaluator.evaluate( builder, null, model, 0.7, 1.0 );

// visualizzo il risultato

System.out.println( "Root Mean Square Error = " + score );

Stesso codice usato prima per addestrare il Recommender su tutti i dati; qui però i dati

saranno solo quelli del training set


In Java 8 si può usare un’espressione lambda in questo modo


Valutazione di un recommender con metriche dell’information retrieval

• L’information retrieval (IR) studia metodi e algoritmi per recuperare informazioni testuali rilevanti rispetto a richieste dell’utente – Ad esempio, un motore di ricerca web deve restituire, tra tutte le

pagine indicizzate, quelle attinenti rispetto alle query degli utenti

• Un recommender è assimilabile ad un sistema IR – Deve indicare, tra tanti oggetti, quelli rilevanti per un utente

• Nell’IR esistono diversi criteri per misurare l’efficacia di un sistema in base alle risposte che fornisce

• Due metriche calcolate comunemente sono la precision e la recall, che considerano due aspetti diversi – La precision indica quante delle risposte date sono rilevanti

– La recall indica quante delle possibili risposte rilevanti sono fornite Data Intensive Applications 23


Precision e Recall di un Recommender

• Si consideri un sistema che consiglia N oggetti per ogni utente

• La precision@N è la frazione degli N suggerimenti restituiti che sono effettivamente rilevanti

• La recall@N è la frazione di suggerimenti rilevanti restituiti dal recommender tra i rilevanti esistenti

• Occorre definire cosa si intende per “suggerimento rilevante” – sono gli oggetti già positivamente valutati

dagli utenti (che si usano come test)

suggerimenti rilevanti

sugg

eri

men

ti d

ati

A B

C D A

A + B

A

A + C precision =

recall = Data Intensive Applications 24

MATRICE DI CONFUSIONE


Precision e Recall di un Recommender in Mahout

• Per avere questi dati, invece di RecommenderEvaluator si usa un RecommenderIRStatsEvaluator – Implementazione: GenericRecommenderIRStatsEvaluator

• Questo ha un metodo evaluate con ulteriori due parametri oltre a quelli visti in RecommenderEvaluator – il numero N di recommendation considerati per ogni utente nel test

– il rating minimo che deve avere un oggetto del test set per essere considerato un suggerimento rilevante

• di default, questo è pari per ogni utente alla somma tra la media e la deviazione standard dei rating che ha dato

• Il metodo restituisce un oggetto IRStatistics, che fornisce i metodi getPrecision e getRecall – la (ir)rilevanza dei rating usati come test è ignorata durante il training

poiché l’obiettivo è prevederli e misurarne l’accuratezza Data Intensive Applications 25


Valutazione precision e recall di uno user-based recommender

// dati in ingresso e recommender costruiti come in precedenza

DataModel model = new FileDataModel( new File( "...\\ratings.csv" ) );

Recommender builder = new RecommenderBuilder() {

public Recommender buildRecommender( DataModel model ) throws TasteException {

UserSimilarity similarity = new PearsonCorrelationSimilarity(model);


return new GenericUserBasedRecommender( model, neighborhood, similarity );

}

};

// creo uno stimatore IR

RecommenderIRStatsEvaluator evaluator = new GenericIRStatsRecommenderEvaluator();

// effettuo la valutazione

IRStatistics stats = evaluator.evaluate( builder, null, model, null, 2, GenericRecommenderIRStatsEvaluator.CHOOSE_THRESHOLD, 1.0 );

// visualizzo precision e recall

System.out.println( "precision = " + stats.getPrecision() );

System.out.println( "recall = " + stats.getRecall() );

Parametri nell’ordine: • costruttore recommender • costruttore data model (non usato) • data model • correzione punteggi (non usata) • numero di oggetti per utente • soglia rating (quì automatica) • frazione di utenti considerati nella valutazione



Riepilogo: Item-based Recommendation

• Un item-based recommender prevede il rating di un utente su un oggetto da quelli dati dallo stesso utente ad oggetti simili

• La similarità tra oggetti è misurata sui voti dati da altri utenti

Item1 Item2 Item3 Item4 Item5

Carl 5 3 4 4 ?

Mike 3 1 2 3 3

Jake 4 3 4 3 5

Tom 3 3 1 5 4

Phill 1 5 5 2 1

simile a

media



Item-based Recommendation in Mahout

• L’impostazione e il funzionamento di un recommender item-based sono quasi analoghi al caso user-based

• Occorre definire una misura di similarità tra oggetti, rappresentata da un oggetto ItemSimilarity

• Si considerano tutti gli oggetti a cui l’utente ha dato un voto: non si usa un vicinato (avrebbe poche informazioni)

• Un ItemBasedRecommender si può quindi costruire da un DataModel e da una ItemSimilarity – L’implementazione concreta è GenericItemBasedRecommender



Generazione di un Item-based Recommender

• Molte classi viste, come UserSimilarity, si possono usare anche come ItemSimilarity con la stessa logica – PearsonCorrelationSimilarity, EuclideanDistanceSimilarity, …

// caricamento dati

DataModel model = new FileDataModel( new File( "..." ) );

// similarità: Pearson (stessa classe usata in user-based)

ItemSimilarity similarity = new PearsonCorrelationSimilarity( model );

// creo un recommender con i componenti creati sopra

Recommender recommender = new GenericItemBasedRecommender( model, similarity );



Precalcolo della Similarità tra Oggetti

• In generale nelle applicazioni di recommendation, l’insieme degli oggetti è molto più statico di quello degli utenti – Nuovi utenti entrano nel sistema continuamente e senza controllo e i

loro gusti possono cambiare nel tempo

– I prodotti invece hanno caratteristiche costanti nel tempo ed il loro inserimento è sotto il controllo del venditore

• Ci aspettiamo quindi che le similarità tra oggetti convergano a valori stabili una volta che si hanno dati sufficienti

• Dovendo ricalcolare periodicamente le recommendation per tutti gli utenti, può essere conveniente pre-calcolare, memorizzare e riutilizzare le similarità tra oggetti – Alternativamente, le similarità potrebbero essere pre-calcolate in base

a conoscenza esterna, ad es. le caratteristiche degli oggetti



Implementazioni di ItemSimilarity con similarità pre-calcolate

• Mahout fornisce implementazioni di ItemSimilarity che restituiscono valori calcolati in anticipo invece che su richiesta

• GenericItemSimilarity memorizza tutte le similarità tra oggetti calcolate con un’altra ItemSimilarity

DataModel model = ...;

ItemSimilarity onlineSimilarity = ...;

ItemSimilarity precomputedSimilarity = new GenericItemSimilarity(onlineSimilarity, model);

• FileItemSimilarity carica le similarità da un file CSV – Per ogni riga: ID oggetto 1, ID oggetto 2, similarità (tra -1 e 1)

ItemSimilarity ps = new FileItemSimilarity(file);

• Sono disponibili classi per leggere le similarità da database



Riepilogo: Algoritmi di Recommendation basati sulla Scomposizione di Matrici

• Alcuni approcci al collaborative filtering sono basati sulla scomposizione (o fattorizzazione) della matrice dei rating – nella lezione precedente abbiamo visto CF con scomposizione SVD

• Tramite queste tecniche, è possibile rappresentare utenti e oggetti in un nuovo spazio comune a dimensioni ridotte

• In questo nuovo spazio si può misurare la distanza tra utenti e oggetti e calcolare le recommendation in base ad essa

• Idealmente, le dimensioni corrispondono a categorie di utenti con gusti simili e oggetti con caratteristiche affini – Ad esempio, nel caso di film, le dimensioni possono corrispondere a

dei generi (commedia, fantascienza, ...)

– La dimensione predominante di un film indica il suo genere, quella di un utente indica il genere di film che predilige



Algoritmi basati sulla decomposizione di matrici in Mahout

• SVDRecommender rappresenta un recommender basato sulla scomposizione di matrici

• Per crearne uno, si specifica un metodo di scomposizione, rappresentato da un oggetto Factorizer

• Un esempio fornito da Mahout è ALSWRFactorizer – Basato su: Y. Zhou, D. Wilkinson, R. Schreiber, R. Pan. Large-Scale

Parallel Collaborative Filtering for the Netflix Prize. Lecture Notes in Computer Science, volume 5034. 2008

– è un metodo di scomposizione scalabile (le matrici non sono per intero in memoria RAM) ed è parallelizzabile

• Un parametro importante di tutti i Factorizer è il numero di dimensioni latenti da generare – Il numero ottimale dipende in genere dai dati a disposizione



Modello di Recommendation basato su Scomposizione di Matrici

RecommenderBuilder build = new RecommenderBuilder() {

public Recommender buildRecommender( DataModel model ) throws TasteException {

// definisco il metodo di scomposizione

Factorizer factorizer = new ALSWRFactorizer( model, 5, 0.1, 10 );

// creo il recommender col metodo scelto

return new SVDRecommender( model, factorizer );

}

};

DataModel model = ...;

RecommenderEvaluator eval = new RMSRecommenderEvaluator();

double score = eval.evaluate(model, null, build, 0.7, 1);


parametri: dati, dimensioni latenti, lambda, iterazioni


Risultati: confronto RMSE sui dati del caso di studio con diversi algoritmi e parametri

Classe algoritmo Parametri RMSE (singolo test)

UserBased Recommender

correlaz. Pearson, 5 nearest neighbors 1,343

correlaz. Pearson, 10 nearest neighbors 1,335

similarità coseno, 5 nearest neighbors 1,409

similarità coseno, 10 nearest neighbors 1,364

SVD Recommender

ALSWR, 5 dimensioni 1,006

ALSWR, 10 dimensioni 1,018

SVD++, 5 dimensioni 1,263

SVD++, 10 dimensioni 1,259

• Testando diversi algoritmi, si possono confrontare le misure di accuratezza per individuare il migliore per i propri dati

• Dal confronto dei RMSE, in questo caso la soluzione migliore tra quelle testate è ALSWR con 5 feature

Documents

Recommendation (slide pratica) - unibo.itdia.apice.unibo.it/download/slides/recommendation-mahout.pdf · recommendation relative a utenti e oggetti su cui è addestrato • Il metodo